Add files using upload-large-folder tool

parse/train/SJeNz04tDS/SJeNz04tDS.md

@@ -0,0 +1,317 @@
+# OVERLEARNING REVEALS SENSITIVE ATTRIBUTES
+
+Congzheng Song Cornell University cs2296@cornell.edu
+
+Vitaly Shmatikov   
+Cornell Tech   
+shmat@cs.cornell.edu
+
+# ABSTRACT
+
+“Overlearning” means that a model trained for a seemingly simple objective implicitly learns to recognize attributes and concepts that are (1) not part of the learning objective, and (2) sensitive from a privacy or bias perspective. For example, a binary gender classifier of facial images also learns to recognize races—even races that are not represented in the training data—and identities.
+
+We demonstrate overlearning in several vision and NLP models and analyze its harmful consequences. First, inference-time representations of an overlearned model reveal sensitive attributes of the input, breaking privacy protections such as model partitioning. Second, an overlearned model can be “re-purposed” for a different, privacy-violating task even in the absence of the original training data.
+
+We show that overlearning is intrinsic for some tasks and cannot be prevented by censoring unwanted attributes. Finally, we investigate where, when, and why overlearning happens during model training.
+
+# 1 INTRODUCTION
+
+We demonstrate that representations learned by deep models when training for seemingly simple objectives reveal privacy- and bias-sensitive attributes that are not part of the specified objective. These unintentionally learned concepts are neither finer-, nor coarse-grained versions of the model’s labels, nor statistically correlated with them. We call this phenomenon overlearning. For example, a binary classifier trained to determine the gender of a facial image also learns to recognize races (including races not represented in the training data) and even identities of individuals.
+
+Overlearning has two distinct consequences. First, the model’s inference-time representation of an input reveals the input’s sensitive attributes. For example, a facial recognition model’s representation of an image reveals if two specific individuals appear together in it. Overlearning thus breaks inference-time privacy protections based on model partitioning (Osia et al., 2018; Chi et al., 2018; Wang et al., 2018). Second, we develop a new, transfer learning-based technique to “re-purpose” a model trained for benign task into a model for a different, privacy-violating task. This shows the inadequacy of privacy regulations that rely on explicit enumeration of learned attributes.
+
+Overlearning is intrinsic for some tasks, i.e., it is not possible to prevent a model from learning sensitive attributes. We show that if these attributes are censored (Xie et al., 2017; Moyer et al., 2018), the censored models either fail to learn their specified tasks, or still leak sensitive information. We develop a new de-censoring technique to extract information from censored representations. We also show that overlearned representations enable recognition of sensitive attributes that are not present in the training data. Such attributes cannot be censored using any known technique. This shows the the inadequacy of censoring as a privacy protection technology.
+
+To analyze where and why overlearning happens, we empirically show how general features emerge in the lower layers of models trained for simple objectives and conjecture an explanation based on the complexity of the training data.
+
+# 2 BACKGROUND
+
+We focus on supervised deep learning. Given an input $x$ , a model $M$ is trained to predict the target $y$ using a discriminative approach. We represent the model $M = C \circ E$ as a feature extractor (encoder) $E$ and classifier $C$ . The representation $z = E ( x )$ is passed to $C$ to produce the prediction by modeling $p ( y | z ) = C ( z )$ . Since $E$ can have multiple layers of representation, we use $E _ { l } ( x ) = z _ { l }$ to denote the model’s internal representation at layer $l$ ; $z$ is the representation at the last layer.
+
+Model partitioning splits the model into a local, on-device part and a remote, cloud-based part to improve scalability of inference (Lane & Georgiev, 2015; Kang et al., 2017) and protect privacy of inputs into the model (Li et al., 2017; Osia et al., 2018; Chi et al., 2018; Wang et al., 2018). For privacy, the local part of the model computes a representation, censors it as described below, and sends it to the cloud part, which computes the model’s output.
+
+Censoring representations. The goal is to encode input $x$ into a representation $z$ that does not reveal unwanted properties of $x$ , yet is expressive enough to predict the task label $y$ . Censoring has been used to achieve transform-invariant representations for computer vision, bias-free representations for fair machine learning, and privacy-preserving representations that hide sensitive attributes.
+
+A straightforward censoring approach is based on adversarial training (Goodfellow et al., 2014). It involves a mini-max game between a discriminator $D$ trying to infer $s$ from $z$ during training and an encoder and classifier trying to infer the task label $y$ while minimizing the discriminator’s success (Edwards & Storkey, 2016; Iwasawa et al., 2016; Hamm, 2017; Xie et al., 2017; Li et al., 2018; Coavoux et al., 2018; Elazar & Goldberg, 2018). The game is formulated as:
+
+$$
+\displaystyle \operatorname* { m i n } _ { E , C } \operatorname* { m a x } _ { D } \mathbb { E } _ { x , y , s } [ \gamma \log p ( s | z = E ( x ) ) - \log p ( y | z = E ( x ) ) ]
+$$
+
+where $\gamma$ balances the two log likelihood terms. The inner optimization maximizes $\log p ( s | z =$ $E ( x ) ,$ ), i.e., the discriminator’s prediction of the sensitive attribute $s$ given a representation $z$ . The outer optimization, on the other hand, trains the encoder and classifier to minimize the log likelihood of the discriminator predicting $s$ and maximize that of predicting the task label $y$ .
+
+Another approach casts censoring as a single information-theoretical objective. The requirement that $z$ not reveal $s$ can be formalized as an independence constraint $z \perp s$ , but independence is intractable to measure in practice, thus the requirement is relaxed to a constraint on the mutual information between $z$ and $s$ (Osia et al., 2018; Moyer et al., 2018). The overall training objective of censoring $s$ and predicting $y$ from $z$ is formulated as:
+
+$$
+\operatorname* { m a x } I ( z , y ) - \beta I ( z , x ) - \lambda I ( z , s )
+$$
+
+where $I$ is mutual information and $\beta , \lambda$ are the balancing coefficients; $\beta = 0$ in (Osia et al., 2018). The first two terms $I ( z , y ) - \beta I ( z , x )$ is the objective of variational information bottleneck (Alemi et al., 2017), the third term is the relaxed independence constraint of $z$ and $s$ .
+
+Intuitively, this objective aims to maximize the information of $y$ in $z$ as per $I ( z , y )$ , forget the information of $x$ in $z$ as per $- \beta I ( z , x )$ , and remove the information of $s$ in $z$ as per $- \lambda I ( z , s )$ . This objective has an analytical lower bound (Moyer et al., 2018):
+
+$$
+\mathbb { E } _ { x , s } [ \mathbb { E } _ { z , y } [ \log p ( y | z ) ] - ( \beta + \lambda ) K L [ q ( z | x ) | | q ( z ) ] - \lambda \mathbb { E } _ { z } [ \log p ( x | z , s ) ] ]
+$$
+
+where $K L$ is Kullback-Leibler divergence and $\log p ( x | z , s )$ is the reconstruction likelihood of $x$ given $z$ and $s$ . The conditional distributions $p ( y | z ) = C ( z )$ , $q ( z | x ) = E ( x )$ are modeled as in adversarial training and $p ( x | z , s )$ is modeled with a decoder $R ( z , s ) = p ( x | z , s )$ .
+
+All known censoring techniques require a “blacklist” of attributes to censor, and inputs with these attributes must be represented in the training data. Censoring for fairness is applied to the model’s final layer to make its output independent of the sensitive attributes or satisfy a specific fairness constraint (Zemel et al., 2013; Louizos et al., 2016; Madras et al., 2018; Song et al., 2019). In this paper, we use censoring not for fairness but to demonstrate that models cannot be prevented from learning to recognize sensitive attributes. To show this, we apply censoring to different layers, not just the output.
+
+# 3 EXPLOITING OVERLEARNING
+
+We demonstrate two different ways to exploit overlearning in a trained model $M$ . The inferencetime attack (Section 3.1) applies $M$ to an input and uses $M$ ’s representation of that input to predict its sensitive attributes. The model-repurposing attack (Section 3.2) uses $M$ to create another model that, when applied to an input, directly predicts its sensitive attributes.
+
+# Inferring $s$ from representation:
+
+# Adversarial re-purposing:
+
+1: Input: Adversary’s auxiliary dataset $\mathcal { D } _ { \mathrm { a u x } }$ ,   
+black-box oracle $E$ , observed $z ^ { \star }$   
+2: ${ \mathcal { D } } _ { \operatorname { a t t a c k } } \gets \{ ( E ( x ) , s ) | ( x , s ) \in { \mathcal { D } } _ { \operatorname { a u x } } \}$   
+3: Train attack model $M _ { \mathrm { a t t a c k } }$ on $\mathcal { D } _ { \mathrm { a t t a c k } }$   
+4: return prediction $\hat { s } = M _ { \mathrm { a t t a c k } } \mathopen { } \mathclose \bgroup \left( z ^ { \star } \aftergroup \egroup \right)$   
+1: Input: Model $M$ for the original task, transfer   
+dataset $\mathcal { D } _ { \mathrm { t r a n s f e r } }$ for the new task   
+2: Build $M _ { \mathrm { t r a n s f e r } } = C _ { \mathrm { t r a n s f e r } } \circ E _ { l }$ on layer $l$   
+3: Fine-tune $M _ { \mathrm { t r a n s f e r } }$ on Dtransfer   
+4: return transfer model Mtransfer
+
+# Algorithm 1 De-censoring representations
+
+1: Input: Auxiliary dataset $\mathcal { D } _ { \mathrm { a u x } }$ , black-box oracle $E$ , observed representation $z ^ { \star }$   
+2: Train auxiliary model $M _ { \mathrm { a u x } } = E _ { \mathrm { a u x } } \circ C _ { \mathrm { a u x } }$ on $\mathcal { D } _ { \mathrm { a u x } }$   
+3: Initialize transform model $T$ , inference attack model $M _ { \mathrm { a t t a c k } }$   
+4: for each training iteration do   
+5: Sample a batch of data $( x , s )$ from $\mathcal { D } _ { \mathrm { a u x } }$ and compute $z = E ( x )$ , $z _ { \mathrm { a u x } } = E _ { \mathrm { a u x } } ( x )$   
+6: Update $T$ on the batch of $\left( z , z _ { \mathrm { a u x } } \right)$ with loss $| | T ( \bar { z } ) - z _ { \mathrm { a u x } } | | _ { 2 } ^ { 2 }$   
+7: Update $M _ { \mathrm { a t t a c k } }$ on the batch of $( T ( z ) , s )$ with cross-entropy loss   
+8: end for   
+9: return prediction $\hat { s } = M _ { \mathrm { a t t a c k } } ( T ( z ^ { \star } ) )$
+
+# 3.1 INFERRING SENSITIVE ATTRIBUTES FROM REPRESENTATION
+
+We measure the leakage of sensitive properties from the representations of overlearned models via the following attack. Suppose an adversary can observe the representation $z ^ { \star }$ of a trained model $M$ on input $x ^ { \star }$ at inference time but cannot observe $x ^ { \star }$ directly. This scenario arises in practice when model evaluation is partitioned in order to protect privacy of inputs—see Section 2. The adversary wants to infer some property $s$ of $x ^ { \star }$ that is not part of the task label $y$ .
+
+We assume that the adversary has an auxiliary set $\mathcal { D } _ { \mathrm { a u x } }$ of labeled $( x , s )$ pairs and black-box oracle $E$ to compute the corresponding $E ( x )$ . The purpose of $\mathcal { D } _ { \mathrm { a u x } }$ is to help the adversary recognize the property of interest in the model’s representations; it need not be drawn from the same dataset as $x ^ { \star }$ . The adversary uses supervised learning on the $( E ( x ) , s )$ pairs to train an attack model $M _ { \mathrm { a t t a c k } }$ . At inference time, the adversary predicts $\hat { s }$ from the observed $z ^ { \star }$ as $M _ { \mathrm { a t t a c k } } ( z ^ { \star } )$ .
+
+De-censoring. If the representation $z$ is “censored” (see Section 2) to reduce the amount of information it reveals about $s$ , the direct inference attack may not succeed. We develop a new, learning-based de-censoring approach (see Algorithm 1) to convert censored representations into a different form that leaks more information about the property of interest. The adversary trains $M _ { \mathrm { a u x } }$ on $\mathcal { D } _ { \mathrm { a u x } }$ to predict $s$ from $x$ , then transforms $z$ into the input features of $M _ { \mathrm { a u x } }$ .
+
+We treat de-censoring as an optimization problem with a feature space $L _ { 2 }$ loss $\lvert \lvert T ( z ) - z _ { \mathrm { a u x } } \rvert \rvert _ { 2 } ^ { 2 }$ , where $T$ is the transformer that the adversary wants to learn and ${ \cal Z } _ { \mathrm { a u x } }$ is the uncensored representation from $M _ { \mathrm { a u x } }$ . Training with a feature-space loss has been proposed for synthesizing more natural images by matching them with real images (Dosovitskiy & Brox, 2016; Nguyen et al., 2016). In our case, we match censored and uncensored representations. The adversary can then use $T ( z )$ as an uncensored approximation of $z$ to train an inference model $M _ { \mathrm { a t t a c k } }$ and infer property $s$ as $\dot { M } _ { \mathrm { a t t a c k } } ( T ( z ^ { \star } ) )$ .
+
+# 3.2 RE-PURPOSING MODELS TO PREDICT SENSITIVE ATTRIBUTES
+
+To re-purpose a model—for example, to convert a model trained for a benign task into a model that predicts a sensitive attribute—we can use features $z _ { l }$ in any layer of $M$ as the feature extractor and connect a new classifier $C _ { \mathrm { t r a n s f e r } }$ to $E _ { l }$ . The transferred model $M _ { \mathrm { t r a n s f e r } } = C _ { \mathrm { t r a n s f e r } } \circ E _ { l }$ is fine-tuned on another, small dataset $\mathcal { D } _ { \mathrm { t r a n s f e r } }$ , which in itself is not sufficient to train an accurate model for the new task. Utilizing features learned by $M$ on the original $\mathcal { D }$ , $M _ { \mathrm { t r a n s f e r } }$ can achieve better results than models trained from scratch on $\mathcal { D } _ { \mathrm { t r a n s f e r } }$ .
+
+Feasibility of model re-purposing complicates the application of policies and regulations such as GDPR (EU, 2018). GDPR requires data processors to disclose every purpose of data collection and obtain consent from the users whose data was collected. We show that, given a trained model, it is not possible to determine—nor, consequently, disclose or obtain user consent for—what the model has learned. Learning per se thus cannot be a regulated “purpose” of data collection. Regulators must be aware that even if the original training data has been erased, a model can be re-purposed for a different objective, possibly not envisioned at the time of original data collection. We discuss this further in Section 6.
+
+Table 1: Summary of datasets and tasks. Cramer’s V captures statistical correlation between $_ y$ and $s$ (0 indicates no correlation and 1 indicates perfectly correlated).   
+
+<table><tr><td>Dataset</td><td>Health</td><td>UTKFace</td><td>FaceScrub</td><td>Places365</td><td>Twitter</td><td>Yelp</td><td>PIPA</td></tr><tr><td>Target y</td><td>CCI</td><td>gender</td><td>gender</td><td>in/outdoor</td><td>age</td><td>review score</td><td>facial IDs</td></tr><tr><td>Attribute s</td><td>age</td><td>race</td><td>facial IDs</td><td> scene type</td><td>author</td><td>author</td><td>IDs together</td></tr><tr><td>Cramer&#x27;s V</td><td>0.149</td><td>0.035</td><td>0.044</td><td>0.052</td><td>0.134</td><td>0.033</td><td>n/a</td></tr></table>
+
+# 4 EXPERIMENTAL RESULTS
+
+# 4.1 DATASETS, TASKS, AND MODELS
+
+Health is the Heritage Health dataset (Heritage Health Prize) with medical records of over 55,000 patients, binarized into 112 features with age information removed. The task is to predict if Charlson Index (an estimate of patient mortality) is greater than zero; the sensitive attribute is age (binned into 9 ranges).
+
+UTKFace is a set of over 23,000 face images labeled with age, gender, and race (UTKFace; Zhang et al., 2017). We rescaled them into $5 0 \times 5 0$ RGB pixels. The task is to predict gender; the sensitive attribute is race.
+
+FaceScrub is a set of face images labeled with gender (FaceScrub). Some URLs are expired, but we were able to download 74,000 images for 500 individuals and rescale them into $5 0 \times 5 0$ RGB pixels. The task is to predict gender; the sensitive attribute is identity.
+
+Places365 is a set of 1.8 million images labeled with 365 fine-grained scene categories. We use a subset of 73,000 images, 200 per category. The task is to predict whether the scene is indoor or outdoor; the sensitive attribute is the fine-grained scene label.
+
+Twitter is a set of tweets from the PAN16 dataset (Rangel et al., 2016) labeled with user information. We removed tweets with fewer than 20 tokens and users with fewer than 50 tweets, yielding a dataset of over 46,000 tweets from 151 users with an over 80,000-word vocabulary. The task is to predict the age of the user given a tweet; the sensitive attribute is the author’s identity.
+
+Yelp is a set of Yelp reviews labeled with user identities (Yelp Open Dataset). We removed users with fewer than 1,000 reviews and reviews with more than 200 tokens, yielding a dataset of over 39,000 reviews from 137 users with an over 69,000-word vocabulary. The task is to predict the review score between 1 to 5; the sensitive attribute is the author’s identity.
+
+PIPA is a set of over 60,000 photos of 2,000 individuals gathered from public Flickr photo albums (Piper project page; Zhang et al., 2015). Each image can include one or more individuals. We cropped their head regions using the bounding boxes in the image annotations. The task is to predict the identity given the head region; the sensitive attribute is whether two head regions are from the same photo.
+
+Models. For Health, we use a two-layer fully connected (FC) neural network with 128 and 32 hidden units, respectively, following (Xie et al., 2017; Moyer et al., 2018). For UTKFace and FaceScrub, we use a LeNet (LeCun et al., 1998) variant: three $3 \times 3$ convolutional and $2 \times 2$ max-pooling layers with 16, 32, and 64 filters, followed by two FC layers with 128 and 64 hidden units. For Twitter and Yelp, we use text CNN (Kim, 2014). For Places365 and PIPA, we use AlexNet (Krizhevsky et al., 2012) with convolutional layers pre-trained on ImageNet (Deng et al., 2009) and further add a $3 \times 3$ convolutional layer with 128 filters and $2 \times 2$ max-pooling followed by two FC layers with 128 and 64 hidden units, respectively.
+
+Table 2: Accuracy of inference from representations (last FC layer). RAND is random guessing based on majority class labels; BASE is inference from the uncensored representation; ADV from the representation censored with adversarial training; IT from the information-theoretically censored representation.   
+
+<table><tr><td></td><td colspan="4">Acc of predicting target y</td><td colspan="4">Acc of inferring sensitive attribute s</td></tr><tr><td>Dataset</td><td>RAND</td><td>BASE</td><td>ADV</td><td>IT</td><td>RAND</td><td>BASE</td><td>ADV</td><td>IT</td></tr><tr><td>Health</td><td>66.31</td><td>84.33</td><td>80.16</td><td>82.63</td><td>16.00</td><td>32.52</td><td>32.00</td><td>26.60</td></tr><tr><td>UTKFace</td><td>52.27</td><td>90.38</td><td>90.15</td><td>88.15</td><td>42.52</td><td>62.18</td><td>53.28</td><td>53.30</td></tr><tr><td>FaceScrub</td><td>53.53</td><td>98.77</td><td>97.90</td><td>97.66</td><td>1.42</td><td>33.65</td><td>30.23</td><td>10.61</td></tr><tr><td>Places365</td><td>56.16</td><td>91.41</td><td>90.84</td><td>89.82</td><td>1.37</td><td>31.03</td><td>12.56</td><td>2.29</td></tr><tr><td>Twitter</td><td>45.17</td><td>76.22</td><td>57.97</td><td>n/a</td><td>6.93</td><td>38.46</td><td>34.27</td><td>n/a</td></tr><tr><td>Yelp</td><td>42.56</td><td>57.81</td><td>56.79</td><td>n/a</td><td>15.88</td><td>33.09</td><td>27.32</td><td>n/a</td></tr><tr><td>PIPA</td><td>7.67</td><td>77.34</td><td>52.02</td><td>29.64</td><td>68.50</td><td>87.95</td><td>69.96</td><td>82.02</td></tr></table>
+
+# 4.2 INFERRING SENSITIVE ATTRIBUTES FROM REPRESENTATIONS
+
+Setup. We use $80 \%$ of the data for training the target models and $20 \%$ for evaluation. The size of the adversary’s auxiliary dataset is $50 \%$ of the training data. Success of the inference attack is measured on the final FC layer’s representation of test data. The baseline is inference from the uncensored representation. We also measure the success of inference against representations censored with $\gamma = 1 . 0$ for adversarial training and $\beta = 0 . 0 1 , \lambda = 0 . 0 0 0 1$ for information-theoretical censoring, following (Xie et al., 2017; Moyer et al., 2018).
+
+For censoring with adversarial training, we simulate the adversary with a two-layer FC neural network with 256 and 128 hidden units. The number of epochs is 50 for censoring with adversarial training, 30 for the other models. We use the Adam optimizer with the learning rate of 0.001 and batch size of 128. For information-theoretical censoring, the model is based on VAE (Kingma & Welling, 2013; Moyer et al., 2018). The encoder $q ( z | x )$ has the same architecture as the CNN models with all convolutional layers. On top of that, the encoder outputs a mean vector and a standard deviation vector to model the random variable $z$ with the re-parameterization trick. The decoder $p ( x | z )$ has three de-convolution layers with up-sampling to map $z$ back to the same shape as the input $x$ .
+
+For our inference model, we use the same architecture as the censoring adversary. For the PIPA inference model, which takes two representations of faces and outputs a binary prediction of whether these faces appear in the same photo, we use two FC layers followed by a bilinear model: $p ( s | z _ { 1 } , z _ { 2 } ) = \sigma ( h ( z _ { 1 } ) { \mathrm { \hat { W } } } h ( z _ { 2 } ) ^ { \top } )$ , where $z _ { 1 } , z _ { 2 }$ are the two input representations, $h$ is the two FC layers, and $\sigma$ is the sigmoid function. We train the inference model for 50 epochs with the Adam optimizer, learning rate of 0.001, and batch size of 128.
+
+Results. Table 2 reports the results. When representations are not censored, accuracy of inference from the last-layer representations is much higher than random guessing for all tasks, which means models overlearn even in the higher, task-specific layers. When representations are censored with adversarial training, accuracy drops for both the main and inference tasks. Accuracy of inference is much higher than in (Xie et al., 2017). The latter uses logistic regression, which is weaker than the training-time censoring-adversary network, whereas we use the same architecture for both the training-time and post-hoc adversaries. Information-theoretical censoring reduces accuracy of inference, but also damages main-task accuracy more than adversarial training for almost all models.
+
+Overlearning can cause a model to recognize even the sensitive attributes that are not represented in the training dataset. Such attributes cannot be censored using any known technique. We trained a UTKFace gender classifier on datasets where all faces are of the same race. We then applied this model to test images with four races (White, Black, Asian, Indian) and attempted to infer the race attribute from the model’s representations. Inference accuracy is $6 1 . 9 5 \%$ , $6 1 . 9 9 \%$ , $6 0 . 8 5 \%$ and $6 0 . 8 1 \%$ for models trained only on, respectively, White, Black, Asian, and Indian images—almost as good as the $6 2 . 1 8 \%$ baseline and much higher than random guessing $( 4 2 . 5 2 \% )$ ).
+
+Effect of censoring strength. Fig. 2 shows that stronger censoring does not help. On FaceScrub and Twitter with adversarial training, increasing $\gamma$ damages the model’s accuracy on the main task, while accuracy of inference decreases slightly or remains the same. For UTKFace and Yelp, increasing $\gamma$ improves accuracy of inference. This may indicate that the simulated “adversary” during adversarial training overpowers the optimization process and censoring defeats itself.
+
+![](images/68d5f5347278f8ca3a5ebe228c048f583261579957dc513fd2dc7032fa89e3c2.jpg)  
+Figure 2: Reduction in accuracy due to censoring. Blue lines are the main task, red lines are the inference of sensitive attributes. First row is adversarial training with different $\gamma$ values; second and third row is information-theoretical censoring with different $\beta$ and $\lambda$ values respectively.
+
+Table 3: Improving inference accuracy with de-censoring. $\delta$ is the increase from Table 2.   
+
+<table><tr><td>Dataset</td><td>Health</td><td>UTKFace</td><td>FaceScrub</td><td>Places365</td><td>Twitter</td><td>Yelp</td></tr><tr><td>ADV+δ</td><td>32.55 +0.55</td><td>59.38 +6.10</td><td>40.37 +12.24</td><td>19.71 +7.15</td><td>36.55 +2.22</td><td>31.36 +4.04</td></tr><tr><td>IT+δ</td><td>27.05+0.45</td><td>54.31 +1.01</td><td>16.40 +5.79</td><td>3.10 +0.81</td><td>n/a</td><td>n/a</td></tr></table>
+
+For all models with information-theoretical censoring, increasing $\beta$ reduces the accuracy of inference but can lead to the model not converging on its main task. Increasing $\lambda$ results in the model not converging on the main task, without affecting the accuracy of inference, on Health, UTKFace and FaceScrub. This seems to contradict the censoring objective, but the reconstruction loss in Equation 2 dominates the other loss terms, which leads to poor divergence between conditional $q ( \bar { z } | x )$ and $q ( z )$ , i.e., information about $x$ is still retained in $z$ .
+
+De-censoring. As described in Section 3.1, we developed a new technique to transform censored representations to make inference easier. We first train an auxiliary model on $\mathcal { D } _ { \mathrm { a u x } }$ to predict the sensitive attribute from representations, using the same architecture as in the baseline models. The resulting uncensored representations from the last convolutional layer are the target for the decensoring transformations. We use a single-layer fully connected neural network as the transformer and set the number of hidden units to the dimension of the uncensored representation. The inference model operates on top of the transformer network, with the same hyper-parameters as before.
+
+Table 3 shows that de-censoring significantly boosts the accuracy of inference from representations censored with adversarial training. The boost is smaller against information-theoretical censoring because its objective not only censors $z$ with $I ( z , s )$ , but also forgets $x$ with $I ( x , z )$ . On the Health task, there is not much difference since the baseline attack is already similar to the attack on censored representations, leaving little room for improvement.
+
+Table 4: Adversarial re-purposing. The values are differences between the accuracy of predicting sensitive attributes using a re-purposed model vs. a model trained from scratch.   
+
+<table><tr><td>|Dtransfer/|D|</td><td>Health</td><td>UTKFace</td><td>FaceScrub</td><td>Places365</td><td>Twitter</td><td>Yelp</td><td>PIPA</td></tr><tr><td>0.02</td><td>-0.57</td><td>4.72</td><td>7.01</td><td>4.42</td><td>12.99</td><td>5.57</td><td>1.33</td></tr><tr><td>0.04</td><td>0.22</td><td>2.70</td><td>15.07</td><td>2.14</td><td>10.87</td><td>3.60</td><td>2.41</td></tr><tr><td>0.06</td><td>-1.21</td><td>2.83</td><td>7.02</td><td>2.06</td><td>10.51</td><td>8.45</td><td>6.50</td></tr><tr><td>0.08</td><td>-0.99</td><td>0.25</td><td>11.80</td><td>3.39</td><td>9.57</td><td>0.33</td><td>4.93</td></tr><tr><td>0.10</td><td>0.35</td><td>2.24</td><td>9.43</td><td>2.86</td><td>7.30</td><td>2.1</td><td>5.89</td></tr></table>
+
+Table 5: The effect of censoring on adversarial re-purposing for FaceScrub with $\gamma = 0 . 5 , 0 . 7 5 , 1 . 0$ . $\delta _ { A }$ is the difference in the original-task accuracy (second column) between uncensored and censored models; $\delta _ { B }$ is the difference in the accuracy of inferring the sensitive attribute (columns 3 to 7) between the models re-purposed from different layers and the model trained from scratch. Negative values mean reduced accuracy. Heatmaps on the right are linear CKA similarities between censored and uncensored representations. Numbers 0 through 4 represent layers conv1, conv2, conv3, fc4, and fc5. For each model censored at layer $i$ $\mathbf { \bar { X } }$ -axis), we measure similarity between the censored and uncensored models at layer $j$ (y-axis).
+
+<table><tr><td>Censored on γ = 0.5</td><td>8A conv1</td><td colspan="5">δB when transferred from</td></tr><tr><td>conv1</td><td>-1.66</td><td>-6.42</td><td>conv2 -4.09</td><td>conv3 -1.65</td><td>fc4 0.46</td><td>fc5 -3.87</td></tr><tr><td>conv2</td><td>-2.87</td><td>0.95</td><td>-1.77</td><td>-2.88</td><td>-1.53</td><td>-2.22</td></tr><tr><td>conv3</td><td>-0.64</td><td>1.49</td><td>1.49</td><td>0.67</td><td>-0.48</td><td>-1.38</td></tr><tr><td>fc4</td><td>-0.16</td><td>2.03</td><td>5.16</td><td>6.73</td><td>6.12</td><td>0.54</td></tr><tr><td>fc5</td><td>0.05</td><td>1.52</td><td>4.53</td><td>7.42</td><td>6.14</td><td>4.53</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>γ = 0.75</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>conv1 conv2</td><td>-4.48</td><td>-7.33</td><td>-5.01</td><td>-1.51</td><td>-7.99</td><td>-7.82</td></tr><tr><td>conv3</td><td>-6.02 -1.90</td><td>0.44</td><td>-7.04</td><td>-5.46</td><td>-5.94</td><td>-5.82</td></tr><tr><td></td><td></td><td>1.32</td><td>1.37</td><td>1.88</td><td>0.74</td><td>-0.67</td></tr><tr><td>fc4 fc5</td><td>0.01</td><td>3.65</td><td>4.56</td><td>5.11</td><td>4.44</td><td>0.91</td></tr><tr><td></td><td>-0.74</td><td>1.54</td><td>3.61</td><td>6.75</td><td>7.18</td><td>4.99</td></tr><tr><td>γ=1</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>conv1</td><td>-45.25</td><td>-7.36</td><td>-3.93</td><td>-2.75</td><td>-4.37</td><td>-2.91</td></tr><tr><td>conv2</td><td>-20.30</td><td>-3.28</td><td>-5.27</td><td>-7.03</td><td>-6.38</td><td>-5.54</td></tr><tr><td>conv3</td><td>-45.20</td><td>-2.13</td><td>-3.06</td><td>-4.48</td><td>-4.05</td><td>-5.18</td></tr><tr><td>fc4</td><td>-0.52</td><td>1.73</td><td>5.19</td><td>4.80</td><td>5.83</td><td>1.84</td></tr><tr><td>fc5</td><td>-0.86</td><td>1.56</td><td>3.55</td><td>5.59</td><td>5.14</td><td>1.97</td></tr></table>
+
+![](images/3719b59afccadae3d67568f8a193353da487259eec836bf83762fe3920ddeea0.jpg)
+
+In summary, these results demonstrate that information about sensitive attributes unintentionally captured by the overlearned representations cannot be suppressed by censoring.
+
+# 4.3 RE-PURPOSING MODELS TO PREDICT SENSITIVE ATTRIBUTES
+
+To demonstrate that overlearned representations can be picked up by a small set of unseen data to create a model for predicting sensitive attributes, we re-purpose uncensored baseline models from Section 4.2 by fine-tuning them on a small $( 2 - 1 0 \%$ of $\mathcal { D }$ ) set $\mathcal { D } _ { \mathrm { t r a n s f e r } }$ and compare with the models trained from scratch on $\mathcal { D } _ { \mathrm { t r a n s f e r } }$ . We fine-tune all models for 50 epochs with batch size of 32; the other hyper-parameters are as in Section 4.2. For all CNN models, we use the trained convolutional layers as the feature extractor and randomly initialize the other layers. Table 4 shows that the re-purposed models always outperform those trained from scratch. FaceScrub and Twitter exhibit the biggest gain.
+
+Effect of censoring. Previous work only censored the highest layer of the models. Model repurposing can use any layer of the model for transfer learning. Therefore, to prevent re-purposing, inner layers must be censored, too. We perform the first study of inner-layers censoring and measure its effect on both the original and re-purposed tasks. We use FaceScrub for this experiment and apply adversarial training to every layer with different strengths $( \gamma = 0 . 5 , 0 . 7 5 , 1 . 0 )$ .
+
+![](images/f65fc4068d3991232ab719746e8227b77de78087433df71159ec7115d49f4b23.jpg)  
+Figure 3: Pairwise similarities of layer representations between models for the original task (A) and for predicting a sensitive attribute (B). Numbers 0 through 4 denote layers conv1, conv2, conv3, fc4 and fc5.
+
+Table 5 summarizes the results. Censoring lower layers (conv1 to conv3) blocks adversarial repurposing, at the cost of reducing the model’s accuracy on its original task. Hyper-parameters must be tuned carefully, e.g. when $\gamma = 1$ , there is a huge drop in the original-task accuracy.
+
+To further investigate how censoring in one layer affects the representations learned across all layers, we measure per-layer similarity between censored and uncensored models using CKA, linear centered kernel alignment (Kornblith et al., 2019)—see Table 5. When censoring is applied to a specific layer, similarity for that layer is the smallest (values on the diagonal). When censoring lower layers with moderate strength $\gamma = 0 . 5$ or 0.75), similarity between higher layers is still strong; when censoring higher layers, similarity between lower layers is strong. Therefore, censoring can block adversarial re-purposing from a specific layer, but the adversary can still re-purpose representations in the other layer(s) to obtain an accurate model for predicting sensitive attributes.
+
+# 4.4 WHEN, WHERE, AND WHY OVERLEARNING HAPPENS
+
+To investigate when (during training) and where (in which layer) the models overlearn, we use linear CKA similarity (Kornblith et al., 2019) to compare the representations at different epochs of training between models trained for the original task (A) and models trained to predict a sensitive attribute (B). We use UTKFace and FaceScrub for these experiments.
+
+Fig. 3 shows that lower layers of models A and B learn very similar features. This was observed in (Kornblith et al., 2019) for CIFAR-10 and CIFAR-100 models, but those tasks are closely related. In our case, the tasks are entirely different and B reveals the sensitive attribute while A does not. The similar low-level features are learned very early during training. There is little similarity between the low-level features of A and high-level features of B (and vice versa), matching intuition. Interestingly, on FaceScrub even the high-level features are similar between A and B.
+
+We conjecture that one of the reasons for overlearning is structural complexity of the data. Previous work theoretically showed that over-parameterized neural networks favor simple solutions on structured data when optimized with SGD, where structure is quantified as the number of distributions (e.g., images from different identities) within each class in the target task (Li & Liang, 2018), i.e., the fewer distributions, the more structured the data. For data generated from more complicated distributions, networks learn more complex solutions, leading to the emergence of features that are much more general than the learning objective and, consequently, overlearning.
+
+Fig. 4 shows that the representations of a gender classifier trained on the faces from 50 individuals are closer to the random initialization than the representations trained on the faces from 500 individuals (the hyper-parameters and the total number of training examples are the same in both cases). More complex training data thus results in more complex representations for the same objective.
+
+![](images/3d71cf94d52b1cdc93f46ed05951b3cdad8fb3ec4a7f2a7f1f9adbc376ed148c.jpg)  
+Figure 4: Similarity of layer representations of a partially trained gender classifier to a randomly initialized model before training. Models are trained on FaceScrub using $5 0 \mathrm { I D s }$ (blue line) and 500 IDs (red line).
+
+# 5 RELATED WORK
+
+Prior work studied transferability of representations only between closely related tasks. Transferability of features between ImageNet models decreases as the distance between the base and target tasks grows (Yosinski et al., 2014), and performance of tasks is correlated to their distance from the source task (Azizpour et al., 2015). CNN models trained to distinguish coarse classes also distinguish their subsets (Huh et al., 2016). By contrast, we show that models trained for simple tasks implicitly learn privacy-sensitive concepts unrelated to the labels of the original task. Other than an anecdotal mention in the acknowledgments paragraph of (Kim et al., 2017) that logit-layer activations leak non-label concepts, this phenomenon has never been described in the research literature.
+
+Gradient updates revealed by participants in distributed learning leak information about individual training batches that is uncorrelated with the learning objective (Melis et al., 2019). We show that overlearning is a generic problem in (fully trained) models, helping explain these observations.
+
+There is a large body of research on learning disentangled representations (Bengio et al., 2013; Locatello et al., 2019). The goal is to separate the underlying explanatory factors in the representation so that it contains all information about the input in an interpretable structure. State-of-the-art approaches use variational autoencoders (Kingma & Welling, 2013) and their variants to learn disentangled representations in an unsupervised fashion (Higgins et al., 2017; Kumar et al., 2018; Kim & Mnih, 2018; Chen et al., 2018). By contrast, overlearning means that representations learned during supervised training for one task implicitly and automatically enable another task—without disentangling the representation on purpose during training.
+
+Work on censoring representations aims to suppress sensitive demographic attributes and identities in the model’s output for fairness and privacy. Techniques include adversarial training (Edwards & Storkey, 2016), which has been applied to census and health records (Xie et al., 2017), text (Li et al., 2018; Coavoux et al., 2018; Elazar & Goldberg, 2018), images (Hamm, 2017) and sensor data of wearables (Iwasawa et al., 2016). An alternative approach is to minimize mutual information between the representation and the sensitive attribute (Moyer et al., 2018; Osia et al., 2018). Neither approach can prevent overlearning, except at the cost of destroying the model’s accuracy. Furthermore, these techniques cannot censor attributes that are not represented in the training data. We show that overlearned models recognize such attributes, too.
+
+# 6 CONCLUSIONS
+
+We demonstrated that models trained for seemingly simple tasks implicitly learn concepts that are not represented in the objective function. In particular, they learn to recognize sensitive attributes, such as race and identity, that are statistically orthogonal to the objective. The failure of censoring to suppress these attributes and the similarity of learned representations across uncorrelated tasks suggest that overlearning may be intrinsic, i.e., learning for some objectives may not be possible without recognizing generic low-level features that enable other tasks, including inference of sensitive attributes. For example, there may not exist a set of features that enables a model to accurately determine the gender of a face but not its race or identity.
+
+This is a challenge for regulations such as GDPR that aim to control the purposes and uses of machine learning technologies. To protect privacy and ensure certain forms of fairness, users and regulators may desire that models not learn some features and attributes. If overlearning is intrinsic, it may not be technically possible to enumerate, let alone control, what models are learning. Therefore, regulators should focus on ensuring that models are applied in a way that respects privacy and fairness, while acknowledging that they may still recognize and use sensitive attributes.
+
+Acknowledgments. This research was supported in part by NSF grants 1611770, 1704296, and 1916717, the generosity of Eric and Wendy Schmidt by recommendation of the Schmidt Futures program, and a Google Faculty Research Award.
+
+# REFERENCES
+
+Alexander A. Alemi, Ian Fischer, Joshua V. Dillon, and Kevin Murphy. Deep variational information bottleneck. In ICLR, 2017.
+
+Hossein Azizpour, Ali Sharif Razavian, Josephine Sullivan, Atsuto Maki, and Stefan Carlsson. From generic to specific deep representations for visual recognition. In CVPR Workshops, 2015.
+
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. PAMI, 2013.
+
+Tian Qi Chen, Xuechen Li, Roger B Grosse, and David K Duvenaud. Isolating sources of disentanglement in variational autoencoders. In NIPS, 2018.
+
+Jianfeng Chi, Emmanuel Owusu, Xuwang Yin, Tong Yu, William Chan, Patrick Tague, and Yuan Tian. Privacy partitioning: Protecting user data during the deep learning inference phase. arXiv:1812.02863, 2018.
+
+Maximin Coavoux, Shashi Narayan, and Shay B. Cohen. Privacy-preserving neural representations of text. In EMNLP, 2018.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009.
+
+Alexey Dosovitskiy and Thomas Brox. Generating images with perceptual similarity metrics based on deep networks. In NIPS, 2016.
+
+Harrison Edwards and Amos J. Storkey. Censoring representations with an adversary. In ICLR, 2016.
+
+Yanai Elazar and Yoav Goldberg. Adversarial removal of demographic attributes from text data. In EMNLP, 2018.
+
+EU. General Data Protection Regulation. https://en.wikipedia.org/wiki/General_ Data_Protection_Regulation, 2018.
+
+FaceScrub. http://vintage.winklerbros.net/facescrub.html, 2014.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, 2014.
+
+Jihun Hamm. Minimax filter: Learning to preserve privacy from inference attacks. JMLR, 18(129): 1–31, 2017.
+
+Heritage Health Prize. https://www.kaggle.com/c/hhp, 2012.
+
+Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-VAE: Learning basic visual concepts with a constrained variational framework. In ICLR, 2017.
+
+Minyoung Huh, Pulkit Agrawal, and Alexei A Efros. What makes ImageNet good for transfer learning? arXiv:1608.08614, 2016.
+
+Yusuke Iwasawa, Kotaro Nakayama, Ikuko Yairi, and Yutaka Matsuo. Privacy issues regarding the application of DNNs to activity-recognition using wearables and its countermeasures by use of adversarial training. In IJCAI, 2016.
+
+Yiping Kang, Johann Hauswald, Cao Gao, Austin Rovinski, Trevor Mudge, Jason Mars, and Lingjia Tang. Neurosurgeon: Collaborative intelligence between the cloud and mobile edge. In ASPLOS, 2017.
+
+Been Kim, Martin Wattenberg, Justin Gilmer, Carrie Cai, James Wexler, Fernanda Viegas, and Rory Sayres. Interpretability beyond feature attribution: Quantitative testing with concept activation vectors (TCAV). arXiv:1711.11279, 2017.
+
+Hyunjik Kim and Andriy Mnih. Disentangling by factorising. In ICML, 2018.
+
+Yoon Kim. Convolutional neural networks for sentence classification. In EMNLP, 2014.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. arXiv:1312.6114, 2013.
+
+Simon Kornblith, Mohammad Norouzi, Honglak Lee, and Geoffrey Hinton. Similarity of neural network representations revisited. In ICML, 2019.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, 2012.
+
+Abhishek Kumar, Prasanna Sattigeri, and Avinash Balakrishnan. Variational inference of disentangled latent concepts from unlabeled observations. In ICLR, 2018.
+
+Nicholas D Lane and Petko Georgiev. Can deep learning revolutionize mobile sensing? In HotMobile, 2015.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proc. IEEE, 86(11):2278–2324, 1998.
+
+Meng Li, Liangzhen Lai, Naveen Suda, Vikas Chandra, and David Z Pan. PrivyNet: A flexible framework for privacy-preserving deep neural network training. arXiv:1709.06161, 2017.
+
+Yitong Li, Timothy Baldwin, and Trevor Cohn. Towards robust and privacy-preserving text representations. In ACL, 2018.
+
+Yuanzhi Li and Yingyu Liang. Learning overparameterized neural networks via stochastic gradient descent on structured data. In NIPS, 2018.
+
+Francesco Locatello, Stefan Bauer, Mario Lucic, Gunnar Raetsch, Sylvain Gelly, Bernhard Scholkopf, and Olivier Bachem. Challenging common assumptions in the unsupervised learn- ¨ ing of disentangled representations. In ICML, 2019.
+
+Christos Louizos, Kevin Swersky, Yujia Li, Max Welling, and Richard Zemel. The variational fair autoencoder. In ICLR, 2016.
+
+David Madras, Elliot Creager, Toniann Pitassi, and Richard Zemel. Learning adversarially fair and transferable representations. In ICML, 2018.
+
+Luca Melis, Congzheng Song, Emiliano De Cristofaro, and Vitaly Shmatikov. Exploiting unintended feature leakage in collaborative learning. In S&P, 2019.
+
+Daniel Moyer, Shuyang Gao, Rob Brekelmans, Aram Galstyan, and Greg Ver Steeg. Invariant representations without adversarial training. In NIPS, 2018.
+
+Anh Nguyen, Alexey Dosovitskiy, Jason Yosinski, Thomas Brox, and Jeff Clune. Synthesizing the preferred inputs for neurons in neural networks via deep generator networks. In NIPS, 2016.
+
+Seyed Ali Osia, Ali Taheri, Ali Shahin Shamsabadi, Minos Katevas, Hamed Haddadi, and Hamid R. R. Rabiee. Deep private-feature extraction. TKDE, 2018.
+
+Piper project page. https://people.eecs.berkeley.edu/˜nzhang/piper.html, 2015.
+
+Francisco Rangel, Paolo Rosso, Ben Verhoeven, Walter Daelemans, Martin Potthast, and Benno Stein. Overview of the 4th author profiling task at PAN 2016: Cross-genre evaluations. In CEUR Workshop, 2016.
+
+Jiaming Song, Pratyusha Kalluri, Aditya Grover, Shengjia Zhao, and Stefano Ermon. Learning controllable fair representations. In AISTATS, 2019.
+
+UTKFace. http://aicip.eecs.utk.edu/wiki/UTKFace, 2017.
+
+Ji Wang, Jianguo Zhang, Weidong Bao, Xiaomin Zhu, Bokai Cao, and Philip S Yu. Not just privacy: Improving performance of private deep learning in mobile cloud. In KDD, 2018.
+
+Qizhe Xie, Zihang Dai, Yulun Du, Eduard H. Hovy, and Graham Neubig. Controllable invariance through adversarial feature learning. In NIPS, 2017.
+
+Yelp Open Dataset. https://www.yelp.com/dataset, 2018.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In NIPS, 2014.
+
+Rich Zemel, Yu Wu, Kevin Swersky, Toni Pitassi, and Cynthia Dwork. Learning fair representations. In ICML, 2013.
+
+Ning Zhang, Manohar Paluri, Yaniv Taigman, Rob Fergus, and Lubomir Bourdev. Beyond frontal faces: Improving person recognition using multiple cues. In CVPR, 2015.
+
+Zhifei Zhang, Yang Song, and Hairong Qi. Age progression/regression by conditional adversarial autoencoder. In CVPR, 2017.

parse/train/SJeNz04tDS/SJeNz04tDS_content_list.json

@@ -0,0 +1,1680 @@
+[
+    {
+        "type": "text",
+        "text": "OVERLEARNING REVEALS SENSITIVE ATTRIBUTES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            789,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Congzheng Song Cornell University cs2296@cornell.edu ",
+        "bbox": [
+            183,
+            145,
+            362,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vitaly Shmatikov   \nCornell Tech   \nshmat@cs.cornell.edu ",
+        "bbox": [
+            496,
+            145,
+            696,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            224,
+            544,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "“Overlearning” means that a model trained for a seemingly simple objective implicitly learns to recognize attributes and concepts that are (1) not part of the learning objective, and (2) sensitive from a privacy or bias perspective. For example, a binary gender classifier of facial images also learns to recognize races—even races that are not represented in the training data—and identities. ",
+        "bbox": [
+            233,
+            256,
+            764,
+            325
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate overlearning in several vision and NLP models and analyze its harmful consequences. First, inference-time representations of an overlearned model reveal sensitive attributes of the input, breaking privacy protections such as model partitioning. Second, an overlearned model can be “re-purposed” for a different, privacy-violating task even in the absence of the original training data. ",
+        "bbox": [
+            233,
+            328,
+            764,
+            397
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We show that overlearning is intrinsic for some tasks and cannot be prevented by censoring unwanted attributes. Finally, we investigate where, when, and why overlearning happens during model training. ",
+        "bbox": [
+            232,
+            400,
+            766,
+            441
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            469,
+            336,
+            484
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate that representations learned by deep models when training for seemingly simple objectives reveal privacy- and bias-sensitive attributes that are not part of the specified objective. These unintentionally learned concepts are neither finer-, nor coarse-grained versions of the model’s labels, nor statistically correlated with them. We call this phenomenon overlearning. For example, a binary classifier trained to determine the gender of a facial image also learns to recognize races (including races not represented in the training data) and even identities of individuals. ",
+        "bbox": [
+            174,
+            501,
+            825,
+            585
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Overlearning has two distinct consequences. First, the model’s inference-time representation of an input reveals the input’s sensitive attributes. For example, a facial recognition model’s representation of an image reveals if two specific individuals appear together in it. Overlearning thus breaks inference-time privacy protections based on model partitioning (Osia et al., 2018; Chi et al., 2018; Wang et al., 2018). Second, we develop a new, transfer learning-based technique to “re-purpose” a model trained for benign task into a model for a different, privacy-violating task. This shows the inadequacy of privacy regulations that rely on explicit enumeration of learned attributes. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            689
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Overlearning is intrinsic for some tasks, i.e., it is not possible to prevent a model from learning sensitive attributes. We show that if these attributes are censored (Xie et al., 2017; Moyer et al., 2018), the censored models either fail to learn their specified tasks, or still leak sensitive information. We develop a new de-censoring technique to extract information from censored representations. We also show that overlearned representations enable recognition of sensitive attributes that are not present in the training data. Such attributes cannot be censored using any known technique. This shows the the inadequacy of censoring as a privacy protection technology. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            794
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To analyze where and why overlearning happens, we empirically show how general features emerge in the lower layers of models trained for simple objectives and conjecture an explanation based on the complexity of the training data. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            843
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            863,
+            326,
+            880
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We focus on supervised deep learning. Given an input $x$ , a model $M$ is trained to predict the target $y$ using a discriminative approach. We represent the model $M = C \\circ E$ as a feature extractor (encoder) $E$ and classifier $C$ . The representation $z = E ( x )$ is passed to $C$ to produce the prediction by modeling $p ( y | z ) = C ( z )$ . Since $E$ can have multiple layers of representation, we use $E _ { l } ( x ) = z _ { l }$ to denote the model’s internal representation at layer $l$ ; $z$ is the representation at the last layer. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Model partitioning splits the model into a local, on-device part and a remote, cloud-based part to improve scalability of inference (Lane & Georgiev, 2015; Kang et al., 2017) and protect privacy of inputs into the model (Li et al., 2017; Osia et al., 2018; Chi et al., 2018; Wang et al., 2018). For privacy, the local part of the model computes a representation, censors it as described below, and sends it to the cloud part, which computes the model’s output. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Censoring representations. The goal is to encode input $x$ into a representation $z$ that does not reveal unwanted properties of $x$ , yet is expressive enough to predict the task label $y$ . Censoring has been used to achieve transform-invariant representations for computer vision, bias-free representations for fair machine learning, and privacy-preserving representations that hide sensitive attributes. ",
+        "bbox": [
+            174,
+            229,
+            823,
+            286
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A straightforward censoring approach is based on adversarial training (Goodfellow et al., 2014). It involves a mini-max game between a discriminator $D$ trying to infer $s$ from $z$ during training and an encoder and classifier trying to infer the task label $y$ while minimizing the discriminator’s success (Edwards & Storkey, 2016; Iwasawa et al., 2016; Hamm, 2017; Xie et al., 2017; Li et al., 2018; Coavoux et al., 2018; Elazar & Goldberg, 2018). The game is formulated as: ",
+        "bbox": [
+            173,
+            291,
+            825,
+            362
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9e7b114969623f531abe4e3cb4b1f1cc6f532a91b3ba49655c3c1234ce6c9eb.jpg",
+        "text": "$$\n\\displaystyle \\operatorname* { m i n } _ { E , C } \\operatorname* { m a x } _ { D } \\mathbb { E } _ { x , y , s } [ \\gamma \\log p ( s | z = E ( x ) ) - \\log p ( y | z = E ( x ) ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            366,
+            694,
+            391
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\gamma$ balances the two log likelihood terms. The inner optimization maximizes $\\log p ( s | z =$ $E ( x ) ,$ ), i.e., the discriminator’s prediction of the sensitive attribute $s$ given a representation $z$ . The outer optimization, on the other hand, trains the encoder and classifier to minimize the log likelihood of the discriminator predicting $s$ and maximize that of predicting the task label $y$ . ",
+        "bbox": [
+            173,
+            395,
+            825,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another approach casts censoring as a single information-theoretical objective. The requirement that $z$ not reveal $s$ can be formalized as an independence constraint $z \\perp s$ , but independence is intractable to measure in practice, thus the requirement is relaxed to a constraint on the mutual information between $z$ and $s$ (Osia et al., 2018; Moyer et al., 2018). The overall training objective of censoring $s$ and predicting $y$ from $z$ is formulated as: ",
+        "bbox": [
+            173,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/756f04a113dfa116debb39d5c111b5dbecdeaf3af4dfa4b29e0baf1424acc692.jpg",
+        "text": "$$\n\\operatorname* { m a x } I ( z , y ) - \\beta I ( z , x ) - \\lambda I ( z , s )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            532,
+            616,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $I$ is mutual information and $\\beta , \\lambda$ are the balancing coefficients; $\\beta = 0$ in (Osia et al., 2018). The first two terms $I ( z , y ) - \\beta I ( z , x )$ is the objective of variational information bottleneck (Alemi et al., 2017), the third term is the relaxed independence constraint of $z$ and $s$ . ",
+        "bbox": [
+            174,
+            553,
+            826,
+            597
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, this objective aims to maximize the information of $y$ in $z$ as per $I ( z , y )$ , forget the information of $x$ in $z$ as per $- \\beta I ( z , x )$ , and remove the information of $s$ in $z$ as per $- \\lambda I ( z , s )$ . This objective has an analytical lower bound (Moyer et al., 2018): ",
+        "bbox": [
+            176,
+            602,
+            825,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9ed3e7bab25923570768e923e8472ffdd792b467a362ccb35adc393523077f48.jpg",
+        "text": "$$\n\\mathbb { E } _ { x , s } [ \\mathbb { E } _ { z , y } [ \\log p ( y | z ) ] - ( \\beta + \\lambda ) K L [ q ( z | x ) | | q ( z ) ] - \\lambda \\mathbb { E } _ { z } [ \\log p ( x | z , s ) ] ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            648,
+            735,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $K L$ is Kullback-Leibler divergence and $\\log p ( x | z , s )$ is the reconstruction likelihood of $x$ given $z$ and $s$ . The conditional distributions $p ( y | z ) = C ( z )$ , $q ( z | x ) = E ( x )$ are modeled as in adversarial training and $p ( x | z , s )$ is modeled with a decoder $R ( z , s ) = p ( x | z , s )$ . ",
+        "bbox": [
+            174,
+            670,
+            825,
+            713
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "All known censoring techniques require a “blacklist” of attributes to censor, and inputs with these attributes must be represented in the training data. Censoring for fairness is applied to the model’s final layer to make its output independent of the sensitive attributes or satisfy a specific fairness constraint (Zemel et al., 2013; Louizos et al., 2016; Madras et al., 2018; Song et al., 2019). In this paper, we use censoring not for fairness but to demonstrate that models cannot be prevented from learning to recognize sensitive attributes. To show this, we apply censoring to different layers, not just the output. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            818
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 EXPLOITING OVERLEARNING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            837,
+            450,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate two different ways to exploit overlearning in a trained model $M$ . The inferencetime attack (Section 3.1) applies $M$ to an input and uses $M$ ’s representation of that input to predict its sensitive attributes. The model-repurposing attack (Section 3.2) uses $M$ to create another model that, when applied to an input, directly predicts its sensitive attributes. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Inferring $s$ from representation: ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            104,
+            387,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adversarial re-purposing: ",
+        "text_level": 1,
+        "bbox": [
+            511,
+            106,
+            676,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Adversary’s auxiliary dataset $\\mathcal { D } _ { \\mathrm { a u x } }$ ,   \nblack-box oracle $E$ , observed $z ^ { \\star }$   \n2: ${ \\mathcal { D } } _ { \\operatorname { a t t a c k } } \\gets \\{ ( E ( x ) , s ) | ( x , s ) \\in { \\mathcal { D } } _ { \\operatorname { a u x } } \\}$   \n3: Train attack model $M _ { \\mathrm { a t t a c k } }$ on $\\mathcal { D } _ { \\mathrm { a t t a c k } }$   \n4: return prediction $\\hat { s } = M _ { \\mathrm { a t t a c k } } \\mathopen { } \\mathclose \\bgroup \\left( z ^ { \\star } \\aftergroup \\egroup \\right)$   \n1: Input: Model $M$ for the original task, transfer   \ndataset $\\mathcal { D } _ { \\mathrm { t r a n s f e r } }$ for the new task   \n2: Build $M _ { \\mathrm { t r a n s f e r } } = C _ { \\mathrm { t r a n s f e r } } \\circ E _ { l }$ on layer $l$   \n3: Fine-tune $M _ { \\mathrm { t r a n s f e r } }$ on Dtransfer   \n4: return transfer model Mtransfer ",
+        "bbox": [
+            187,
+            119,
+            486,
+            184
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            516,
+            119,
+            812,
+            184
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 De-censoring representations ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            229,
+            455,
+            244
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Auxiliary dataset $\\mathcal { D } _ { \\mathrm { a u x } }$ , black-box oracle $E$ , observed representation $z ^ { \\star }$   \n2: Train auxiliary model $M _ { \\mathrm { a u x } } = E _ { \\mathrm { a u x } } \\circ C _ { \\mathrm { a u x } }$ on $\\mathcal { D } _ { \\mathrm { a u x } }$   \n3: Initialize transform model $T$ , inference attack model $M _ { \\mathrm { a t t a c k } }$   \n4: for each training iteration do   \n5: Sample a batch of data $( x , s )$ from $\\mathcal { D } _ { \\mathrm { a u x } }$ and compute $z = E ( x )$ , $z _ { \\mathrm { a u x } } = E _ { \\mathrm { a u x } } ( x )$   \n6: Update $T$ on the batch of $\\left( z , z _ { \\mathrm { a u x } } \\right)$ with loss $| | T ( \\bar { z } ) - z _ { \\mathrm { a u x } } | | _ { 2 } ^ { 2 }$   \n7: Update $M _ { \\mathrm { a t t a c k } }$ on the batch of $( T ( z ) , s )$ with cross-entropy loss   \n8: end for   \n9: return prediction $\\hat { s } = M _ { \\mathrm { a t t a c k } } ( T ( z ^ { \\star } ) )$ ",
+        "bbox": [
+            178,
+            250,
+            696,
+            367
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 INFERRING SENSITIVE ATTRIBUTES FROM REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            395,
+            629,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We measure the leakage of sensitive properties from the representations of overlearned models via the following attack. Suppose an adversary can observe the representation $z ^ { \\star }$ of a trained model $M$ on input $x ^ { \\star }$ at inference time but cannot observe $x ^ { \\star }$ directly. This scenario arises in practice when model evaluation is partitioned in order to protect privacy of inputs—see Section 2. The adversary wants to infer some property $s$ of $x ^ { \\star }$ that is not part of the task label $y$ . ",
+        "bbox": [
+            174,
+            420,
+            825,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We assume that the adversary has an auxiliary set $\\mathcal { D } _ { \\mathrm { a u x } }$ of labeled $( x , s )$ pairs and black-box oracle $E$ to compute the corresponding $E ( x )$ . The purpose of $\\mathcal { D } _ { \\mathrm { a u x } }$ is to help the adversary recognize the property of interest in the model’s representations; it need not be drawn from the same dataset as $x ^ { \\star }$ . The adversary uses supervised learning on the $( E ( x ) , s )$ pairs to train an attack model $M _ { \\mathrm { a t t a c k } }$ . At inference time, the adversary predicts $\\hat { s }$ from the observed $z ^ { \\star }$ as $M _ { \\mathrm { a t t a c k } } ( z ^ { \\star } )$ . ",
+        "bbox": [
+            174,
+            497,
+            825,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "De-censoring. If the representation $z$ is “censored” (see Section 2) to reduce the amount of information it reveals about $s$ , the direct inference attack may not succeed. We develop a new, learning-based de-censoring approach (see Algorithm 1) to convert censored representations into a different form that leaks more information about the property of interest. The adversary trains $M _ { \\mathrm { a u x } }$ on $\\mathcal { D } _ { \\mathrm { a u x } }$ to predict $s$ from $x$ , then transforms $z$ into the input features of $M _ { \\mathrm { a u x } }$ . ",
+        "bbox": [
+            173,
+            573,
+            825,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We treat de-censoring as an optimization problem with a feature space $L _ { 2 }$ loss $\\lvert \\lvert T ( z ) - z _ { \\mathrm { a u x } } \\rvert \\rvert _ { 2 } ^ { 2 }$ , where $T$ is the transformer that the adversary wants to learn and ${ \\cal Z } _ { \\mathrm { a u x } }$ is the uncensored representation from $M _ { \\mathrm { a u x } }$ . Training with a feature-space loss has been proposed for synthesizing more natural images by matching them with real images (Dosovitskiy & Brox, 2016; Nguyen et al., 2016). In our case, we match censored and uncensored representations. The adversary can then use $T ( z )$ as an uncensored approximation of $z$ to train an inference model $M _ { \\mathrm { a t t a c k } }$ and infer property $s$ as $\\dot { M } _ { \\mathrm { a t t a c k } } ( T ( z ^ { \\star } ) )$ . ",
+        "bbox": [
+            174,
+            650,
+            825,
+            734
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 RE-PURPOSING MODELS TO PREDICT SENSITIVE ATTRIBUTES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            752,
+            637,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To re-purpose a model—for example, to convert a model trained for a benign task into a model that predicts a sensitive attribute—we can use features $z _ { l }$ in any layer of $M$ as the feature extractor and connect a new classifier $C _ { \\mathrm { t r a n s f e r } }$ to $E _ { l }$ . The transferred model $M _ { \\mathrm { t r a n s f e r } } = C _ { \\mathrm { t r a n s f e r } } \\circ E _ { l }$ is fine-tuned on another, small dataset $\\mathcal { D } _ { \\mathrm { t r a n s f e r } }$ , which in itself is not sufficient to train an accurate model for the new task. Utilizing features learned by $M$ on the original $\\mathcal { D }$ , $M _ { \\mathrm { t r a n s f e r } }$ can achieve better results than models trained from scratch on $\\mathcal { D } _ { \\mathrm { t r a n s f e r } }$ . ",
+        "bbox": [
+            174,
+            776,
+            825,
+            862
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Feasibility of model re-purposing complicates the application of policies and regulations such as GDPR (EU, 2018). GDPR requires data processors to disclose every purpose of data collection and obtain consent from the users whose data was collected. We show that, given a trained model, it is not possible to determine—nor, consequently, disclose or obtain user consent for—what the model has learned. Learning per se thus cannot be a regulated “purpose” of data collection. Regulators must be aware that even if the original training data has been erased, a model can be re-purposed for a different objective, possibly not envisioned at the time of original data collection. We discuss this further in Section 6. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/ec2abca41aaee7587db672e9255690aae8e64c47fb1ec79d719f80dfb239289e.jpg",
+        "table_caption": [
+            "Table 1: Summary of datasets and tasks. Cramer’s V captures statistical correlation between $_ y$ and $s$ (0 indicates no correlation and 1 indicates perfectly correlated). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Health</td><td>UTKFace</td><td>FaceScrub</td><td>Places365</td><td>Twitter</td><td>Yelp</td><td>PIPA</td></tr><tr><td>Target y</td><td>CCI</td><td>gender</td><td>gender</td><td>in/outdoor</td><td>age</td><td>review score</td><td>facial IDs</td></tr><tr><td>Attribute s</td><td>age</td><td>race</td><td>facial IDs</td><td> scene type</td><td>author</td><td>author</td><td>IDs together</td></tr><tr><td>Cramer&#x27;s V</td><td>0.149</td><td>0.035</td><td>0.044</td><td>0.052</td><td>0.134</td><td>0.033</td><td>n/a</td></tr></table>",
+        "bbox": [
+            179,
+            138,
+            818,
+            207
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            242,
+            825,
+            297
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            330,
+            418,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS, TASKS, AND MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            369,
+            441,
+            383
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Health is the Heritage Health dataset (Heritage Health Prize) with medical records of over 55,000 patients, binarized into 112 features with age information removed. The task is to predict if Charlson Index (an estimate of patient mortality) is greater than zero; the sensitive attribute is age (binned into 9 ranges). ",
+        "bbox": [
+            174,
+            400,
+            825,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "UTKFace is a set of over 23,000 face images labeled with age, gender, and race (UTKFace; Zhang et al., 2017). We rescaled them into $5 0 \\times 5 0$ RGB pixels. The task is to predict gender; the sensitive attribute is race. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "FaceScrub is a set of face images labeled with gender (FaceScrub). Some URLs are expired, but we were able to download 74,000 images for 500 individuals and rescale them into $5 0 \\times 5 0$ RGB pixels. The task is to predict gender; the sensitive attribute is identity. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            554
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Places365 is a set of 1.8 million images labeled with 365 fine-grained scene categories. We use a subset of 73,000 images, 200 per category. The task is to predict whether the scene is indoor or outdoor; the sensitive attribute is the fine-grained scene label. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Twitter is a set of tweets from the PAN16 dataset (Rangel et al., 2016) labeled with user information. We removed tweets with fewer than 20 tokens and users with fewer than 50 tweets, yielding a dataset of over 46,000 tweets from 151 users with an over 80,000-word vocabulary. The task is to predict the age of the user given a tweet; the sensitive attribute is the author’s identity. ",
+        "bbox": [
+            174,
+            609,
+            823,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Yelp is a set of Yelp reviews labeled with user identities (Yelp Open Dataset). We removed users with fewer than 1,000 reviews and reviews with more than 200 tokens, yielding a dataset of over 39,000 reviews from 137 users with an over 69,000-word vocabulary. The task is to predict the review score between 1 to 5; the sensitive attribute is the author’s identity. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "PIPA is a set of over 60,000 photos of 2,000 individuals gathered from public Flickr photo albums (Piper project page; Zhang et al., 2015). Each image can include one or more individuals. We cropped their head regions using the bounding boxes in the image annotations. The task is to predict the identity given the head region; the sensitive attribute is whether two head regions are from the same photo. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            805
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Models. For Health, we use a two-layer fully connected (FC) neural network with 128 and 32 hidden units, respectively, following (Xie et al., 2017; Moyer et al., 2018). For UTKFace and FaceScrub, we use a LeNet (LeCun et al., 1998) variant: three $3 \\times 3$ convolutional and $2 \\times 2$ max-pooling layers with 16, 32, and 64 filters, followed by two FC layers with 128 and 64 hidden units. For Twitter and Yelp, we use text CNN (Kim, 2014). For Places365 and PIPA, we use AlexNet (Krizhevsky et al., 2012) with convolutional layers pre-trained on ImageNet (Deng et al., 2009) and further add a $3 \\times 3$ convolutional layer with 128 filters and $2 \\times 2$ max-pooling followed by two FC layers with 128 and 64 hidden units, respectively. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/cb13b282f8345888fb16f6ff040e94bf590a791b20bf82e22b73d33e8656047c.jpg",
+        "table_caption": [
+            "Table 2: Accuracy of inference from representations (last FC layer). RAND is random guessing based on majority class labels; BASE is inference from the uncensored representation; ADV from the representation censored with adversarial training; IT from the information-theoretically censored representation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">Acc of predicting target y</td><td colspan=\"4\">Acc of inferring sensitive attribute s</td></tr><tr><td>Dataset</td><td>RAND</td><td>BASE</td><td>ADV</td><td>IT</td><td>RAND</td><td>BASE</td><td>ADV</td><td>IT</td></tr><tr><td>Health</td><td>66.31</td><td>84.33</td><td>80.16</td><td>82.63</td><td>16.00</td><td>32.52</td><td>32.00</td><td>26.60</td></tr><tr><td>UTKFace</td><td>52.27</td><td>90.38</td><td>90.15</td><td>88.15</td><td>42.52</td><td>62.18</td><td>53.28</td><td>53.30</td></tr><tr><td>FaceScrub</td><td>53.53</td><td>98.77</td><td>97.90</td><td>97.66</td><td>1.42</td><td>33.65</td><td>30.23</td><td>10.61</td></tr><tr><td>Places365</td><td>56.16</td><td>91.41</td><td>90.84</td><td>89.82</td><td>1.37</td><td>31.03</td><td>12.56</td><td>2.29</td></tr><tr><td>Twitter</td><td>45.17</td><td>76.22</td><td>57.97</td><td>n/a</td><td>6.93</td><td>38.46</td><td>34.27</td><td>n/a</td></tr><tr><td>Yelp</td><td>42.56</td><td>57.81</td><td>56.79</td><td>n/a</td><td>15.88</td><td>33.09</td><td>27.32</td><td>n/a</td></tr><tr><td>PIPA</td><td>7.67</td><td>77.34</td><td>52.02</td><td>29.64</td><td>68.50</td><td>87.95</td><td>69.96</td><td>82.02</td></tr></table>",
+        "bbox": [
+            225,
+            167,
+            767,
+            297
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 INFERRING SENSITIVE ATTRIBUTES FROM REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            332,
+            637,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Setup. We use $80 \\%$ of the data for training the target models and $20 \\%$ for evaluation. The size of the adversary’s auxiliary dataset is $50 \\%$ of the training data. Success of the inference attack is measured on the final FC layer’s representation of test data. The baseline is inference from the uncensored representation. We also measure the success of inference against representations censored with $\\gamma = 1 . 0$ for adversarial training and $\\beta = 0 . 0 1 , \\lambda = 0 . 0 0 0 1$ for information-theoretical censoring, following (Xie et al., 2017; Moyer et al., 2018). ",
+        "bbox": [
+            174,
+            359,
+            825,
+            443
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For censoring with adversarial training, we simulate the adversary with a two-layer FC neural network with 256 and 128 hidden units. The number of epochs is 50 for censoring with adversarial training, 30 for the other models. We use the Adam optimizer with the learning rate of 0.001 and batch size of 128. For information-theoretical censoring, the model is based on VAE (Kingma & Welling, 2013; Moyer et al., 2018). The encoder $q ( z | x )$ has the same architecture as the CNN models with all convolutional layers. On top of that, the encoder outputs a mean vector and a standard deviation vector to model the random variable $z$ with the re-parameterization trick. The decoder $p ( x | z )$ has three de-convolution layers with up-sampling to map $z$ back to the same shape as the input $x$ . ",
+        "bbox": [
+            173,
+            449,
+            825,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For our inference model, we use the same architecture as the censoring adversary. For the PIPA inference model, which takes two representations of faces and outputs a binary prediction of whether these faces appear in the same photo, we use two FC layers followed by a bilinear model: $p ( s | z _ { 1 } , z _ { 2 } ) = \\sigma ( h ( z _ { 1 } ) { \\mathrm { \\hat { W } } } h ( z _ { 2 } ) ^ { \\top } )$ , where $z _ { 1 } , z _ { 2 }$ are the two input representations, $h$ is the two FC layers, and $\\sigma$ is the sigmoid function. We train the inference model for 50 epochs with the Adam optimizer, learning rate of 0.001, and batch size of 128. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            666
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Results. Table 2 reports the results. When representations are not censored, accuracy of inference from the last-layer representations is much higher than random guessing for all tasks, which means models overlearn even in the higher, task-specific layers. When representations are censored with adversarial training, accuracy drops for both the main and inference tasks. Accuracy of inference is much higher than in (Xie et al., 2017). The latter uses logistic regression, which is weaker than the training-time censoring-adversary network, whereas we use the same architecture for both the training-time and post-hoc adversaries. Information-theoretical censoring reduces accuracy of inference, but also damages main-task accuracy more than adversarial training for almost all models. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            784
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Overlearning can cause a model to recognize even the sensitive attributes that are not represented in the training dataset. Such attributes cannot be censored using any known technique. We trained a UTKFace gender classifier on datasets where all faces are of the same race. We then applied this model to test images with four races (White, Black, Asian, Indian) and attempted to infer the race attribute from the model’s representations. Inference accuracy is $6 1 . 9 5 \\%$ , $6 1 . 9 9 \\%$ , $6 0 . 8 5 \\%$ and $6 0 . 8 1 \\%$ for models trained only on, respectively, White, Black, Asian, and Indian images—almost as good as the $6 2 . 1 8 \\%$ baseline and much higher than random guessing $( 4 2 . 5 2 \\% )$ ). ",
+        "bbox": [
+            173,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Effect of censoring strength. Fig. 2 shows that stronger censoring does not help. On FaceScrub and Twitter with adversarial training, increasing $\\gamma$ damages the model’s accuracy on the main task, while accuracy of inference decreases slightly or remains the same. For UTKFace and Yelp, increasing $\\gamma$ improves accuracy of inference. This may indicate that the simulated “adversary” during adversarial training overpowers the optimization process and censoring defeats itself. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/68d5f5347278f8ca3a5ebe228c048f583261579957dc513fd2dc7032fa89e3c2.jpg",
+        "image_caption": [
+            "Figure 2: Reduction in accuracy due to censoring. Blue lines are the main task, red lines are the inference of sensitive attributes. First row is adversarial training with different $\\gamma$ values; second and third row is information-theoretical censoring with different $\\beta$ and $\\lambda$ values respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            826,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/0336228e89d0914616174ec83bd57128b9392a491b0732046585a6572afe39ca.jpg",
+        "table_caption": [
+            "Table 3: Improving inference accuracy with de-censoring. $\\delta$ is the increase from Table 2. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Health</td><td>UTKFace</td><td>FaceScrub</td><td>Places365</td><td>Twitter</td><td>Yelp</td></tr><tr><td>ADV+δ</td><td>32.55 +0.55</td><td>59.38 +6.10</td><td>40.37 +12.24</td><td>19.71 +7.15</td><td>36.55 +2.22</td><td>31.36 +4.04</td></tr><tr><td>IT+δ</td><td>27.05+0.45</td><td>54.31 +1.01</td><td>16.40 +5.79</td><td>3.10 +0.81</td><td>n/a</td><td>n/a</td></tr></table>",
+        "bbox": [
+            184,
+            518,
+            810,
+            573
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            609,
+            823,
+            652
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For all models with information-theoretical censoring, increasing $\\beta$ reduces the accuracy of inference but can lead to the model not converging on its main task. Increasing $\\lambda$ results in the model not converging on the main task, without affecting the accuracy of inference, on Health, UTKFace and FaceScrub. This seems to contradict the censoring objective, but the reconstruction loss in Equation 2 dominates the other loss terms, which leads to poor divergence between conditional $q ( \\bar { z } | x )$ and $q ( z )$ , i.e., information about $x$ is still retained in $z$ . ",
+        "bbox": [
+            173,
+            659,
+            823,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "De-censoring. As described in Section 3.1, we developed a new technique to transform censored representations to make inference easier. We first train an auxiliary model on $\\mathcal { D } _ { \\mathrm { a u x } }$ to predict the sensitive attribute from representations, using the same architecture as in the baseline models. The resulting uncensored representations from the last convolutional layer are the target for the decensoring transformations. We use a single-layer fully connected neural network as the transformer and set the number of hidden units to the dimension of the uncensored representation. The inference model operates on top of the transformer network, with the same hyper-parameters as before. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows that de-censoring significantly boosts the accuracy of inference from representations censored with adversarial training. The boost is smaller against information-theoretical censoring because its objective not only censors $z$ with $I ( z , s )$ , but also forgets $x$ with $I ( x , z )$ . On the Health task, there is not much difference since the baseline attack is already similar to the attack on censored representations, leaving little room for improvement. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/6db17898fb876a43fb6b8c4552d86eb0408c4dcaeab3530b8ed97671b808fe6a.jpg",
+        "table_caption": [
+            "Table 4: Adversarial re-purposing. The values are differences between the accuracy of predicting sensitive attributes using a re-purposed model vs. a model trained from scratch. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>|Dtransfer/|D|</td><td>Health</td><td>UTKFace</td><td>FaceScrub</td><td>Places365</td><td>Twitter</td><td>Yelp</td><td>PIPA</td></tr><tr><td>0.02</td><td>-0.57</td><td>4.72</td><td>7.01</td><td>4.42</td><td>12.99</td><td>5.57</td><td>1.33</td></tr><tr><td>0.04</td><td>0.22</td><td>2.70</td><td>15.07</td><td>2.14</td><td>10.87</td><td>3.60</td><td>2.41</td></tr><tr><td>0.06</td><td>-1.21</td><td>2.83</td><td>7.02</td><td>2.06</td><td>10.51</td><td>8.45</td><td>6.50</td></tr><tr><td>0.08</td><td>-0.99</td><td>0.25</td><td>11.80</td><td>3.39</td><td>9.57</td><td>0.33</td><td>4.93</td></tr><tr><td>0.10</td><td>0.35</td><td>2.24</td><td>9.43</td><td>2.86</td><td>7.30</td><td>2.1</td><td>5.89</td></tr></table>",
+        "bbox": [
+            217,
+            141,
+            776,
+            233
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 5: The effect of censoring on adversarial re-purposing for FaceScrub with $\\gamma = 0 . 5 , 0 . 7 5 , 1 . 0$ . $\\delta _ { A }$ is the difference in the original-task accuracy (second column) between uncensored and censored models; $\\delta _ { B }$ is the difference in the accuracy of inferring the sensitive attribute (columns 3 to 7) between the models re-purposed from different layers and the model trained from scratch. Negative values mean reduced accuracy. Heatmaps on the right are linear CKA similarities between censored and uncensored representations. Numbers 0 through 4 represent layers conv1, conv2, conv3, fc4, and fc5. For each model censored at layer $i$ $\\mathbf { \\bar { X } }$ -axis), we measure similarity between the censored and uncensored models at layer $j$ (y-axis). ",
+        "bbox": [
+            173,
+            246,
+            825,
+            358
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/1761cfab0f1a845bfb5c58d5532fdc53ef42a2dc66a82b8522aac74091b68b09.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Censored on γ = 0.5</td><td>8A conv1</td><td colspan=\"5\">δB when transferred from</td></tr><tr><td>conv1</td><td>-1.66</td><td>-6.42</td><td>conv2 -4.09</td><td>conv3 -1.65</td><td>fc4 0.46</td><td>fc5 -3.87</td></tr><tr><td>conv2</td><td>-2.87</td><td>0.95</td><td>-1.77</td><td>-2.88</td><td>-1.53</td><td>-2.22</td></tr><tr><td>conv3</td><td>-0.64</td><td>1.49</td><td>1.49</td><td>0.67</td><td>-0.48</td><td>-1.38</td></tr><tr><td>fc4</td><td>-0.16</td><td>2.03</td><td>5.16</td><td>6.73</td><td>6.12</td><td>0.54</td></tr><tr><td>fc5</td><td>0.05</td><td>1.52</td><td>4.53</td><td>7.42</td><td>6.14</td><td>4.53</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>γ = 0.75</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>conv1 conv2</td><td>-4.48</td><td>-7.33</td><td>-5.01</td><td>-1.51</td><td>-7.99</td><td>-7.82</td></tr><tr><td>conv3</td><td>-6.02 -1.90</td><td>0.44</td><td>-7.04</td><td>-5.46</td><td>-5.94</td><td>-5.82</td></tr><tr><td></td><td></td><td>1.32</td><td>1.37</td><td>1.88</td><td>0.74</td><td>-0.67</td></tr><tr><td>fc4 fc5</td><td>0.01</td><td>3.65</td><td>4.56</td><td>5.11</td><td>4.44</td><td>0.91</td></tr><tr><td></td><td>-0.74</td><td>1.54</td><td>3.61</td><td>6.75</td><td>7.18</td><td>4.99</td></tr><tr><td>γ=1</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>conv1</td><td>-45.25</td><td>-7.36</td><td>-3.93</td><td>-2.75</td><td>-4.37</td><td>-2.91</td></tr><tr><td>conv2</td><td>-20.30</td><td>-3.28</td><td>-5.27</td><td>-7.03</td><td>-6.38</td><td>-5.54</td></tr><tr><td>conv3</td><td>-45.20</td><td>-2.13</td><td>-3.06</td><td>-4.48</td><td>-4.05</td><td>-5.18</td></tr><tr><td>fc4</td><td>-0.52</td><td>1.73</td><td>5.19</td><td>4.80</td><td>5.83</td><td>1.84</td></tr><tr><td>fc5</td><td>-0.86</td><td>1.56</td><td>3.55</td><td>5.59</td><td>5.14</td><td>1.97</td></tr></table>",
+        "bbox": [
+            196,
+            377,
+            594,
+            656
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3719b59afccadae3d67568f8a193353da487259eec836bf83762fe3920ddeea0.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            627,
+            372,
+            839,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In summary, these results demonstrate that information about sensitive attributes unintentionally captured by the overlearned representations cannot be suppressed by censoring. ",
+        "bbox": [
+            173,
+            690,
+            823,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 RE-PURPOSING MODELS TO PREDICT SENSITIVE ATTRIBUTES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            738,
+            637,
+            751
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate that overlearned representations can be picked up by a small set of unseen data to create a model for predicting sensitive attributes, we re-purpose uncensored baseline models from Section 4.2 by fine-tuning them on a small $( 2 - 1 0 \\%$ of $\\mathcal { D }$ ) set $\\mathcal { D } _ { \\mathrm { t r a n s f e r } }$ and compare with the models trained from scratch on $\\mathcal { D } _ { \\mathrm { t r a n s f e r } }$ . We fine-tune all models for 50 epochs with batch size of 32; the other hyper-parameters are as in Section 4.2. For all CNN models, we use the trained convolutional layers as the feature extractor and randomly initialize the other layers. Table 4 shows that the re-purposed models always outperform those trained from scratch. FaceScrub and Twitter exhibit the biggest gain. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Effect of censoring. Previous work only censored the highest layer of the models. Model repurposing can use any layer of the model for transfer learning. Therefore, to prevent re-purposing, inner layers must be censored, too. We perform the first study of inner-layers censoring and measure its effect on both the original and re-purposed tasks. We use FaceScrub for this experiment and apply adversarial training to every layer with different strengths $( \\gamma = 0 . 5 , 0 . 7 5 , 1 . 0 )$ . ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f65fc4068d3991232ab719746e8227b77de78087433df71159ec7115d49f4b23.jpg",
+        "image_caption": [
+            "Figure 3: Pairwise similarities of layer representations between models for the original task (A) and for predicting a sensitive attribute (B). Numbers 0 through 4 denote layers conv1, conv2, conv3, fc4 and fc5. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            97,
+            867,
+            276
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            364,
+            821,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 5 summarizes the results. Censoring lower layers (conv1 to conv3) blocks adversarial repurposing, at the cost of reducing the model’s accuracy on its original task. Hyper-parameters must be tuned carefully, e.g. when $\\gamma = 1$ , there is a huge drop in the original-task accuracy. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            441
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To further investigate how censoring in one layer affects the representations learned across all layers, we measure per-layer similarity between censored and uncensored models using CKA, linear centered kernel alignment (Kornblith et al., 2019)—see Table 5. When censoring is applied to a specific layer, similarity for that layer is the smallest (values on the diagonal). When censoring lower layers with moderate strength $\\gamma = 0 . 5$ or 0.75), similarity between higher layers is still strong; when censoring higher layers, similarity between lower layers is strong. Therefore, censoring can block adversarial re-purposing from a specific layer, but the adversary can still re-purpose representations in the other layer(s) to obtain an accurate model for predicting sensitive attributes. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            559
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 WHEN, WHERE, AND WHY OVERLEARNING HAPPENS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            583,
+            578,
+            595
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To investigate when (during training) and where (in which layer) the models overlearn, we use linear CKA similarity (Kornblith et al., 2019) to compare the representations at different epochs of training between models trained for the original task (A) and models trained to predict a sensitive attribute (B). We use UTKFace and FaceScrub for these experiments. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 shows that lower layers of models A and B learn very similar features. This was observed in (Kornblith et al., 2019) for CIFAR-10 and CIFAR-100 models, but those tasks are closely related. In our case, the tasks are entirely different and B reveals the sensitive attribute while A does not. The similar low-level features are learned very early during training. There is little similarity between the low-level features of A and high-level features of B (and vice versa), matching intuition. Interestingly, on FaceScrub even the high-level features are similar between A and B. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We conjecture that one of the reasons for overlearning is structural complexity of the data. Previous work theoretically showed that over-parameterized neural networks favor simple solutions on structured data when optimized with SGD, where structure is quantified as the number of distributions (e.g., images from different identities) within each class in the target task (Li & Liang, 2018), i.e., the fewer distributions, the more structured the data. For data generated from more complicated distributions, networks learn more complex solutions, leading to the emergence of features that are much more general than the learning objective and, consequently, overlearning. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4 shows that the representations of a gender classifier trained on the faces from 50 individuals are closer to the random initialization than the representations trained on the faces from 500 individuals (the hyper-parameters and the total number of training examples are the same in both cases). More complex training data thus results in more complex representations for the same objective. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d71cf94d52b1cdc93f46ed05951b3cdad8fb3ec4a7f2a7f1f9adbc376ed148c.jpg",
+        "image_caption": [
+            "Figure 4: Similarity of layer representations of a partially trained gender classifier to a randomly initialized model before training. Models are trained on FaceScrub using $5 0 \\mathrm { I D s }$ (blue line) and 500 IDs (red line). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            102,
+            816,
+            243
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            330,
+            344,
+            347
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Prior work studied transferability of representations only between closely related tasks. Transferability of features between ImageNet models decreases as the distance between the base and target tasks grows (Yosinski et al., 2014), and performance of tasks is correlated to their distance from the source task (Azizpour et al., 2015). CNN models trained to distinguish coarse classes also distinguish their subsets (Huh et al., 2016). By contrast, we show that models trained for simple tasks implicitly learn privacy-sensitive concepts unrelated to the labels of the original task. Other than an anecdotal mention in the acknowledgments paragraph of (Kim et al., 2017) that logit-layer activations leak non-label concepts, this phenomenon has never been described in the research literature. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            478
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gradient updates revealed by participants in distributed learning leak information about individual training batches that is uncorrelated with the learning objective (Melis et al., 2019). We show that overlearning is a generic problem in (fully trained) models, helping explain these observations. ",
+        "bbox": [
+            176,
+            484,
+            825,
+            526
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There is a large body of research on learning disentangled representations (Bengio et al., 2013; Locatello et al., 2019). The goal is to separate the underlying explanatory factors in the representation so that it contains all information about the input in an interpretable structure. State-of-the-art approaches use variational autoencoders (Kingma & Welling, 2013) and their variants to learn disentangled representations in an unsupervised fashion (Higgins et al., 2017; Kumar et al., 2018; Kim & Mnih, 2018; Chen et al., 2018). By contrast, overlearning means that representations learned during supervised training for one task implicitly and automatically enable another task—without disentangling the representation on purpose during training. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Work on censoring representations aims to suppress sensitive demographic attributes and identities in the model’s output for fairness and privacy. Techniques include adversarial training (Edwards & Storkey, 2016), which has been applied to census and health records (Xie et al., 2017), text (Li et al., 2018; Coavoux et al., 2018; Elazar & Goldberg, 2018), images (Hamm, 2017) and sensor data of wearables (Iwasawa et al., 2016). An alternative approach is to minimize mutual information between the representation and the sensitive attribute (Moyer et al., 2018; Osia et al., 2018). Neither approach can prevent overlearning, except at the cost of destroying the model’s accuracy. Furthermore, these techniques cannot censor attributes that are not represented in the training data. We show that overlearned models recognize such attributes, too. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            777
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            804,
+            328,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We demonstrated that models trained for seemingly simple tasks implicitly learn concepts that are not represented in the objective function. In particular, they learn to recognize sensitive attributes, such as race and identity, that are statistically orthogonal to the objective. The failure of censoring to suppress these attributes and the similarity of learned representations across uncorrelated tasks suggest that overlearning may be intrinsic, i.e., learning for some objectives may not be possible without recognizing generic low-level features that enable other tasks, including inference of sensitive attributes. For example, there may not exist a set of features that enables a model to accurately determine the gender of a face but not its race or identity. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This is a challenge for regulations such as GDPR that aim to control the purposes and uses of machine learning technologies. To protect privacy and ensure certain forms of fairness, users and regulators may desire that models not learn some features and attributes. If overlearning is intrinsic, it may not be technically possible to enumerate, let alone control, what models are learning. Therefore, regulators should focus on ensuring that models are applied in a way that respects privacy and fairness, while acknowledging that they may still recognize and use sensitive attributes. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments. This research was supported in part by NSF grants 1611770, 1704296, and 1916717, the generosity of Eric and Wendy Schmidt by recommendation of the Schmidt Futures program, and a Google Faculty Research Award. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            271
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            292,
+            285,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander A. Alemi, Ian Fischer, Joshua V. Dillon, and Kevin Murphy. Deep variational information bottleneck. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            316,
+            823,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hossein Azizpour, Ali Sharif Razavian, Josephine Sullivan, Atsuto Maki, and Stefan Carlsson. From generic to specific deep representations for visual recognition. In CVPR Workshops, 2015. ",
+        "bbox": [
+            173,
+            354,
+            823,
+            383
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. PAMI, 2013. ",
+        "bbox": [
+            173,
+            392,
+            821,
+            422
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tian Qi Chen, Xuechen Li, Roger B Grosse, and David K Duvenaud. Isolating sources of disentanglement in variational autoencoders. In NIPS, 2018. ",
+        "bbox": [
+            174,
+            431,
+            820,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianfeng Chi, Emmanuel Owusu, Xuwang Yin, Tong Yu, William Chan, Patrick Tague, and Yuan Tian. Privacy partitioning: Protecting user data during the deep learning inference phase. arXiv:1812.02863, 2018. ",
+        "bbox": [
+            174,
+            469,
+            823,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Maximin Coavoux, Shashi Narayan, and Shay B. Cohen. Privacy-preserving neural representations of text. In EMNLP, 2018. ",
+        "bbox": [
+            173,
+            522,
+            823,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009. ",
+        "bbox": [
+            174,
+            560,
+            823,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy and Thomas Brox. Generating images with perceptual similarity metrics based on deep networks. In NIPS, 2016. ",
+        "bbox": [
+            176,
+            599,
+            823,
+            630
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Harrison Edwards and Amos J. Storkey. Censoring representations with an adversary. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yanai Elazar and Yoav Goldberg. Adversarial removal of demographic attributes from text data. In EMNLP, 2018. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "EU. General Data Protection Regulation. https://en.wikipedia.org/wiki/General_ Data_Protection_Regulation, 2018. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "FaceScrub. http://vintage.winklerbros.net/facescrub.html, 2014. ",
+        "bbox": [
+            174,
+            755,
+            740,
+            770
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, 2014. ",
+        "bbox": [
+            171,
+            779,
+            823,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jihun Hamm. Minimax filter: Learning to preserve privacy from inference attacks. JMLR, 18(129): 1–31, 2017. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Heritage Health Prize. https://www.kaggle.com/c/hhp, 2012. ",
+        "bbox": [
+            173,
+            857,
+            645,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-VAE: Learning basic visual concepts with a constrained variational framework. In ICLR, 2017. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Minyoung Huh, Pulkit Agrawal, and Alexei A Efros. What makes ImageNet good for transfer learning? arXiv:1608.08614, 2016. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yusuke Iwasawa, Kotaro Nakayama, Ikuko Yairi, and Yutaka Matsuo. Privacy issues regarding the application of DNNs to activity-recognition using wearables and its countermeasures by use of adversarial training. In IJCAI, 2016. ",
+        "bbox": [
+            176,
+            142,
+            823,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yiping Kang, Johann Hauswald, Cao Gao, Austin Rovinski, Trevor Mudge, Jason Mars, and Lingjia Tang. Neurosurgeon: Collaborative intelligence between the cloud and mobile edge. In ASPLOS, 2017. ",
+        "bbox": [
+            174,
+            194,
+            826,
+            237
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Been Kim, Martin Wattenberg, Justin Gilmer, Carrie Cai, James Wexler, Fernanda Viegas, and Rory Sayres. Interpretability beyond feature attribution: Quantitative testing with concept activation vectors (TCAV). arXiv:1711.11279, 2017. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hyunjik Kim and Andriy Mnih. Disentangling by factorising. In ICML, 2018. ",
+        "bbox": [
+            173,
+            300,
+            687,
+            316
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim. Convolutional neural networks for sentence classification. In EMNLP, 2014. ",
+        "bbox": [
+            169,
+            325,
+            751,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. arXiv:1312.6114, 2013. ",
+        "bbox": [
+            173,
+            351,
+            805,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Simon Kornblith, Mohammad Norouzi, Honglak Lee, and Geoffrey Hinton. Similarity of neural network representations revisited. In ICML, 2019. ",
+        "bbox": [
+            174,
+            376,
+            823,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            171,
+            414,
+            823,
+            444
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Kumar, Prasanna Sattigeri, and Avinash Balakrishnan. Variational inference of disentangled latent concepts from unlabeled observations. In ICLR, 2018. ",
+        "bbox": [
+            169,
+            453,
+            823,
+            483
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas D Lane and Petko Georgiev. Can deep learning revolutionize mobile sensing? In HotMobile, 2015. ",
+        "bbox": [
+            173,
+            492,
+            823,
+            521
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proc. IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            171,
+            531,
+            823,
+            560
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Meng Li, Liangzhen Lai, Naveen Suda, Vikas Chandra, and David Z Pan. PrivyNet: A flexible framework for privacy-preserving deep neural network training. arXiv:1709.06161, 2017. ",
+        "bbox": [
+            173,
+            569,
+            821,
+            599
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yitong Li, Timothy Baldwin, and Trevor Cohn. Towards robust and privacy-preserving text representations. In ACL, 2018. ",
+        "bbox": [
+            173,
+            608,
+            823,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuanzhi Li and Yingyu Liang. Learning overparameterized neural networks via stochastic gradient descent on structured data. In NIPS, 2018. ",
+        "bbox": [
+            173,
+            647,
+            823,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francesco Locatello, Stefan Bauer, Mario Lucic, Gunnar Raetsch, Sylvain Gelly, Bernhard Scholkopf, and Olivier Bachem. Challenging common assumptions in the unsupervised learn- ¨ ing of disentangled representations. In ICML, 2019. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos, Kevin Swersky, Yujia Li, Max Welling, and Richard Zemel. The variational fair autoencoder. In ICLR, 2016. ",
+        "bbox": [
+            171,
+            739,
+            825,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Madras, Elliot Creager, Toniann Pitassi, and Richard Zemel. Learning adversarially fair and transferable representations. In ICML, 2018. ",
+        "bbox": [
+            171,
+            777,
+            825,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luca Melis, Congzheng Song, Emiliano De Cristofaro, and Vitaly Shmatikov. Exploiting unintended feature leakage in collaborative learning. In S&P, 2019. ",
+        "bbox": [
+            169,
+            816,
+            825,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Moyer, Shuyang Gao, Rob Brekelmans, Aram Galstyan, and Greg Ver Steeg. Invariant representations without adversarial training. In NIPS, 2018. ",
+        "bbox": [
+            173,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anh Nguyen, Alexey Dosovitskiy, Jason Yosinski, Thomas Brox, and Jeff Clune. Synthesizing the preferred inputs for neurons in neural networks via deep generator networks. In NIPS, 2016. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Seyed Ali Osia, Ali Taheri, Ali Shahin Shamsabadi, Minos Katevas, Hamed Haddadi, and Hamid R. R. Rabiee. Deep private-feature extraction. TKDE, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Piper project page. https://people.eecs.berkeley.edu/˜nzhang/piper.html, 2015. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Francisco Rangel, Paolo Rosso, Ben Verhoeven, Walter Daelemans, Martin Potthast, and Benno Stein. Overview of the 4th author profiling task at PAN 2016: Cross-genre evaluations. In CEUR Workshop, 2016. ",
+        "bbox": [
+            176,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiaming Song, Pratyusha Kalluri, Aditya Grover, Shengjia Zhao, and Stefano Ermon. Learning controllable fair representations. In AISTATS, 2019. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "UTKFace. http://aicip.eecs.utk.edu/wiki/UTKFace, 2017. ",
+        "bbox": [
+            174,
+            268,
+            666,
+            284
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ji Wang, Jianguo Zhang, Weidong Bao, Xiaomin Zhu, Bokai Cao, and Philip S Yu. Not just privacy: Improving performance of private deep learning in mobile cloud. In KDD, 2018. ",
+        "bbox": [
+            174,
+            291,
+            821,
+            321
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Qizhe Xie, Zihang Dai, Yulun Du, Eduard H. Hovy, and Graham Neubig. Controllable invariance through adversarial feature learning. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            359
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yelp Open Dataset. https://www.yelp.com/dataset, 2018. ",
+        "bbox": [
+            173,
+            367,
+            627,
+            383
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In NIPS, 2014. ",
+        "bbox": [
+            173,
+            391,
+            823,
+            420
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rich Zemel, Yu Wu, Kevin Swersky, Toni Pitassi, and Cynthia Dwork. Learning fair representations. In ICML, 2013. ",
+        "bbox": [
+            173,
+            429,
+            823,
+            458
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ning Zhang, Manohar Paluri, Yaniv Taigman, Rob Fergus, and Lubomir Bourdev. Beyond frontal faces: Improving person recognition using multiple cues. In CVPR, 2015. ",
+        "bbox": [
+            169,
+            467,
+            823,
+            496
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhifei Zhang, Yang Song, and Hairong Qi. Age progression/regression by conditional adversarial autoencoder. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            505,
+            825,
+            534
+        ],
+        "page_idx": 11
+    }
+]

parse/train/r1VGvBcxl/r1VGvBcxl.md

@@ -0,0 +1,233 @@
+# REINFORCEMENT LEARNING THROUGH ASYN-CHRONOUS ADVANTAGE ACTOR-CRITIC ON A GPU
+
+Mohammad Babaeizadeh   
+Department of Computer Science   
+University of Illinois at Urbana-Champaign, USA   
+mb2@uiuc.edu
+
+Iuri Frosio, Stephen Tyree, Jason Clemons, Jan Kautz NVIDIA, USA {ifrosio,styree,jclemons,jkautz}@nvidia.com
+
+# ABSTRACT
+
+We introduce a hybrid CPU/GPU version of the Asynchronous Advantage ActorCritic (A3C) algorithm, currently the state-of-the-art method in reinforcement learning for various gaming tasks. We analyze its computational traits and concentrate on aspects critical to leveraging the GPU’s computational power. We introduce a system of queues and a dynamic scheduling strategy, potentially helpful for other asynchronous algorithms as well. Our hybrid CPU/GPU version of A3C, based on TensorFlow, achieves a significant speed up compared to a CPU implementation; we make it publicly available to other researchers at https://github.com/NVlabs/GA3C.
+
+# 1 INTRODUCTION
+
+In the past, the need for task-specific, or even hand-crafted, features limited the application of Reinforcement Learning (RL) in real world problems (Sutton & Barto, 1998). However, the introduction of Deep Q-Learning Networks (DQN) (Mnih et al., 2015) revived the use of Deep Neural Networks (DNNs) as function approximators for value and policy functions, unleashing a rapid series of advancements. Remarkable results include learning to play video games from raw pixels (Bellemare et al., 2016; Lample & Singh Chaplot, 2016) and demonstrating super-human performance on the ancient board game Go (Silver et al., 2016). Research has yielded a variety of effective training formulations and DNN architectures (van Hasselt et al., 2015; Wang et al., 2015), as well as methods to increase parallelism while decreasing the computational cost and memory footprint (Nair et al., 2015; Mnih et al., 2016). In particular, Mnih et al. (2016) achieve state-of-the-art results on many gaming tasks through a novel lightweight, parallel method called Asynchronous Advantage ActorCritic (A3C). When the proper learning rate is used, A3C learns to play an Atari game (Brockman et al., 2016) from raw screen inputs more quickly and efficiently than previous methods: on a 16- core CPU, A3C achieves higher scores than previously published methods run for the same amount of time on a GPU.
+
+Our study sets aside many of the learning aspects of recent work and instead delves into the computational issues of deep RL. Computational complexities are numerous, largely centering on a common factor: RL has an inherently sequential aspect, since the training data are generated while learning. The DNN model is constantly queried to guide the actions of agents whose gameplay in turn feeds DNN training. Training batches are commonly small and must be efficiently shepherded from the agents and simulator to the DNN trainer. When using a GPU, the mix of small DNN architectures, small training batch sizes, and contention for the GPU for both inference and training can lead to a severe under-utilization of the computational resources.
+
+To systematically investigate these issues, we implement both CPU and GPU versions of A3C in TensorFlow (TF) (Abadi et al., 2015), optimizing each for efficient system utilization and to approximately replicate published scores in the Atari 2600 environment (Brockman et al., 2016). We analyze a variety of “knobs” in the system and demonstrate effective automatic tuning of those during training. Our hybrid CPU/GPU implementation of A3C, named GA3C, generates and consumes training data substantially faster than its CPU counterpart, up to $\sim 6 \times$ faster for small DNNs and $\sim 4 5 \times$ for larger DNNs. While we focus on the A3C architecture, this analysis can be helpful for researchers and framework developers designing the next generation of deep RL methods.
+
+# 2 RELATED WORK
+
+Recent advances in deep RL have derived from both novel algorithmic approaches and related systems optimizations. Investigation of the algorithmic space seems to be the most common approach among researchers. Deep Q-Learning Networks (DQN) demonstrate a general approach to the learning problem (Mnih et al., 2015), relying heavily on the introduction of an experience replay memory to stabilize the learning procedure. This improves reliability but also increases the computational cost and memory footprint of the algorithm. Inspired by DQN, researchers have proposed more effective learning procedures, achieving faster and more stable convergence: Prioritized DQN (Schaul et al., 2015) makes better use of the replay memory by more frequently selecting frames associated with significant experiences. Double-DQN (van Hasselt et al., 2015) separates the estimate of the value function from the choice of actions (policy), thus reducing the tendency in DQN to be overly optimistic when evaluating its choices. Dueling Double DQN (Wang et al., 2015) goes a step further by explicitly splitting the computation of the value and advantage functions within the network. The presence of the replay memory makes the DQN approaches more suitable for a GPU implementation when compared to other LR methods, but state-of-the-art results are achieved by A3C (Mnih et al., 2016), which does not make use of it.
+
+Among systems approaches, AlphaGo (Silver et al., 2016) recently achieved astonishing results through combined algorithmic and hardware specialization. The computational effort is impressive: 40 search threads, 1202 CPUs, and 176 GPUs are used in the distributed version for inference only. Supervised training took around three weeks for the policy network, using 50 GPUs, and another day using the RL approach for refinement. A similar amount of time was required to train the value network. Gorilla DQN (Nair et al., 2015) is a similarly impressive implementation of distributed RL system, achieving a significant improvement over DQN. The system requires 100 concurrent actors on 31 machines, 100 learners and a central parameter server with the network model. This work demonstrates the potential scalability of deep RL algorithms, achieving better results in less time, but with a significantly increased computational load, memory footprint, and cost.
+
+# 3 ASYNCHRONOUS ADVANTAGE ACTOR CRITIC (A3C)
+
+# 3.1 REINFORCEMENT LEARNING BACKGROUND
+
+In standard RL, an agent interacts with an environment over a number of discrete time steps. At each time step $t$ , the agent observes a state $s _ { t }$ and, in the discrete case, selects an action $a _ { t }$ from the set of valid actions. An agent is guided by policy $\pi$ , a function mapping from states $s _ { t }$ to actions $a _ { t }$ . After each action, the agent observes the next state $s _ { t + 1 }$ and receives feedback in the form of a reward $r _ { t }$ . This process continues until the agent reaches a terminal state or time limit, after which the environment is reset and a new episode is played.
+
+The goal of learning is to find a policy $\pi$ that maximizes the expected reward. In policy-based modelfree methods, a function approximator such as a neural network computes the policy $\pi ( { a } _ { t } | { s } _ { t } ; \theta )$ , where $\theta$ is the set of parameters of the function. There are many methods for updating $\theta$ based on the rewarascent on $\mathbb { E } [ R _ { t } ]$ eived fr, where $\begin{array} { r } { R _ { t } = \sum _ { i = 0 } ^ { \infty } \gamma ^ { i } r _ { t + i } } \end{array}$ . REINFORCE methods (Williams, 1992) use grais the accumulated reward starting from time step $t$ ientand increasingly discounted at each subsequent step by factor $\gamma \in ( 0 , 1 ]$ .
+
+The standard REINFORCE method updates $\theta$ using the gradient $\nabla _ { \theta } \log \pi ( a _ { t } | s _ { t } ; \theta ) R _ { t }$ , which is an unbiased estimator of $\nabla _ { \boldsymbol { \theta } } \mathbb { E } [ R _ { t } ]$ . The variance of the estimator is reduced by subtracting a learned baseline (a function of the state $b _ { t } ( s _ { t } ) )$ and using the gradient $\nabla _ { \theta } \log \pi ( a _ { t } | s _ { t } ; \theta ) \big ( R _ { t } ~ - ~ b _ { t } ( s _ { t } ) \big )$ instead. One common baseline is the value function defined as $V ^ { \pi } ( s _ { t } ) = \mathbb { E } [ R _ { t } | s _ { t } ]$ which is the expected return for following the policy $\pi$ in state $s _ { t }$ . In this approach the policy $\pi$ and the baseline $b _ { t }$ can be viewed as actor and critic in an actor-critic architecture (Sutton $\&$ Barto, 1998).
+
+# 3.2 ASYNCHRONOUS ADVANTAGE ACTOR CRITIC (A3C)
+
+A3C (Mnih et al., 2016), which achieves state-of-the-art results on many gaming tasks including Atari 2600, uses a single DNN to approximate both the policy and value function. The DNN has two convolutional layers with $1 6 \times 8 \times 8$ filters with a stride of 4, and $3 2 \times 4 \times 4$ filters with a stride of 2, followed by a fully connected layer with 256 units; each hidden layer is followed by a rectifier nonlinearity. The two outputs are a softmax layer which approximates the policy function $\pi \left( a _ { t } | s _ { t } ; \theta \right)$ , and a linear layer to output an estimate of $V \left( s _ { t } ; \theta \right)$ . Multiple agents play concurrently and optimize the DNN through asynchronous gradient descent. Similar to other asynchronous methods, the network weights are stored in a central parameter server (Figure 1a). Agents calculate gradients and send updates to the server after every $t _ { m a x } = 5$ actions, or when a terminal state is reached. After each update, the central server propagates new weights to the agents to guarantee they share a common policy.
+
+Two cost functions are associated with the two DNN outputs. For the policy function, this is:
+
+$$
+f _ { \pi } \left( \theta \right) = \log \pi \left( a _ { t } | s _ { t } ; \theta \right) \left( R _ { t } - V \left( s _ { t } ; \theta _ { t } \right) \right) + \beta H \left( \pi \left( s _ { t } ; \theta \right) \right) ,
+$$
+
+where estima $\theta _ { t }$ are the values of the parameters  discounted reward in the time i $\theta$ at time erval fro $t$ , $\begin{array} { r } { R _ { t } = \sum _ { i = 0 } ^ { k - 1 } \gamma ^ { i } r _ { t + i } + \gamma ^ { k } V \left( s _ { t + k } ; \theta _ { t } \right) } \end{array}$ $t$ $t + k$ $k$ $t _ { m a x }$ while $H \left( \pi \left( s _ { t } ; \boldsymbol { \theta } \right) \right)$ is an entropy term, used to favor exploration during the training process. The factor $\beta$ controls the strength of the entropy regularization term. The cost function for the estimated value function is:
+
+$$
+f _ { v } \left( \theta \right) = \left( R _ { t } - V \left( s _ { t } ; \theta \right) \right) ^ { 2 } .
+$$
+
+Training is performed by collecting the gradients $\nabla \theta$ from both of the cost functions and using the standard non-centered RMSProp algorithm (Tieleman $\&$ Hinton, 2012) as optimization:
+
+$$
+\begin{array} { l } { g = \alpha g + ( 1 - \alpha ) \Delta \theta ^ { 2 } } \\ { \theta  \theta - \eta \Delta \theta / \sqrt { g + \epsilon } . } \end{array}
+$$
+
+The gradients $g$ can be either shared or separated between agent threads but the shared implementation is known to be more robust (Mnih et al., 2016).
+
+The original implementation of A3C (Mnih et al., 2016) uses 16 agents on a 16 core CPU and it takes about four days to learn how to play an Atari game (Brockman et al., 2016). The main reason for using CPU other than GPU, is the inherently sequential nature of RL in general, and A3C in particular. In RL, the training data are generated while learning, which means the training and inference batches are small and GPU is mostly idle during the training, waiting for new data to arrive. Since A3C does not utilize any replay memory, it is completely sequential and therefore a CPU implementation is as fast as a naive GPU implementation.
+
+# 4 HYBRID CPU/GPU A3C (GA3C)
+
+We propose GA3C, an alternative architecture of A3C, with emphasize on an efficient GPU utilization to increase the number of training data generated and processed per second. We demonstrate that our implementation of GA3C effectively converges significantly faster than our CPU implementation of A3C, achieving the state-of-the-art performance in a shorter time.
+
+# 4.1 GA3C ARCHITECTURE
+
+The primary components of GA3C (Figure 1b) are a DNN with training and prediction on a GPU, as well as a multi-process, multi-thread CPU architecture with the following components:
+
+• Agent is a process interacting with the simulation environment: choosing actions according to the learned policy and gathering experiences for further training. Similar to A3C, multiple concurrent agents run independent instances of the environment. Unlike the original, each agent does not have its own copy of the model. Instead it queues policy requests in a Prediction Queue before each action, and periodically submits a batch of input/reward experiences to a Training Queue; the size of each training batch is typically equal to $t _ { m a x }$ experiences, though it is sometimes smaller for experiences collected at the end of an episode.
+
+![](images/d529a55a2458aed93556db2b17245be6121593b3507fa86dc39534060ea4695e.jpg)  
+Figure 1: Comparison of A3C and GA3C architectures. Agents act concurrently both in A3C and GA3C. In A3C, however, each agent has a replica of the model, whereas in GA3C there is only one GPU instance of the model. In GA3C, agents utilize predictors to query the network for policies while trainers gather experiences for network updates.
+
+• Predictor is a thread which dequeues as many prediction requests as are immediately available and batches them into a single inference query to the DNN model on the GPU. When predictions are completed, the predictor returns the requested policy to each respective waiting agent. To hide latency, one or more predictors can act concurrently.
+
+• Trainer is a thread which dequeues training batches submitted by agents and submits them to the GPU for model updates. GPU utilization can be increased by grouping training batches among several agents; we found that this generally leads to a more stable convergence, but the convergence speed is reduced when the merged training batches are too large; a compromise is explored in Section 5.3. Multiple trainers may run in parallel to hide latency.
+
+Unlike A3C, GA3C maintains only one copy of the DNN model (Fig. 1a and 1b), centralizing predictions and training updates and removing the need for synchronization. Also, in comparison with A3C, agents in GA3C do not compute the gradients themselves. Instead, they send experiences to trainers that update the network on the GPU accordingly. This introduces a potential lag between the generation and consumption of experiences, which we analyze in detail in Sections 4.4 and 5.3.
+
+# 4.2 PERFORMANCE METRICS AND TRADE-OFFS
+
+The GA3C architecture exposes numerous tradeoffs for tuning its computational efficiency. In general, it is most efficient to transfer data to a GPU in large enough blocks to maximize the usage of the bandwidth between the GPU and CPU. Application performance on the GPU is optimized when the application has large amounts of parallel computations that can hide the latency of fetching data from memory. Thus, we want to maximize the parallel computations the GPU is performing, maximize the size of data transfer to the GPU, and minimize the number of transfers to the GPU. Increasing the number of predictors, $N _ { P }$ , allows faster fetching prediction queries, but leads to smaller prediction batches, resulting in multiple data transfers and overall lower GPU utilization. A larger number of trainers, $N _ { T }$ , potentially leads to more frequent updates to the model, but an overhead is paid when too many trainers occupy the GPU while predictors cannot access it. Lastly, increasing the number of agents, $N _ { A }$ , ideally generates more training experiences while hiding prediction latency. However, we would expect diminishing returns from unnecessary context switching overheads after exceeding some threshold depending on the number of CPU cores.
+
+These aspects are well captured by a metric like the Trainings Per Second (TPS), which is the rate at which we remove batches from the training queue. It corresponds to the rate of model updates and it is approximately proportional to the overall learning speed, given a fixed learning rate and training batch size. Another metric is the Predictions Per Second (PPS), the rate of issuing prediction queries from prediction queue, which maps to the combined rate of gameplay among all agents. Notice that in A3C a model update occurs every time an agent plays $t _ { m a x } = 5$ actions (Mnih et al., 2016).
+
+![](images/8281b416d1f3ce3805668c76149925533dd6d5611570574cd211760bedb0fd40.jpg)  
+Figure 2: Automatic dynamic adjustment of $N _ { T }$ , $N _ { P }$ , and $N _ { A }$ , to maximize TPS for BOXING (left) and PONG (right), starting from a sub-optimal configuration $( N _ { A } = N _ { T } = N _ { P } = 1 )$ )
+
+Hence, in a balanced configuration, $\mathrm { P P S } \approx \mathrm { T P S } \times t _ { m a x }$ . Since each action is repeated four times as in (Mnih et al., 2016), the number of frames per second is $4 \times \mathrm { P P S }$ .
+
+Computational aspects are not disconnected from the convergence of the learning algorithm. For instance, employing too many agents will tend to fill the training queue, introducing a significant time delay between agent experiences $( a _ { t } , ~ s _ { t }$ and $R _ { t }$ in Eq. (1)) and the corresponding model updates, possibly threatening model convergence (see Section 4.4). Another example is batching of training data: larger batches improves GPU occupancy by increasing the parallelism. They also decrease the TPS (i.e., the number of model updates per second), increasing the chance that the DNN model used in prediction and to compute the gradient in Eq. (4) are indeed the same model. The consequence (experimentally observed, see Section 5.3) is an increased stability of the learning process but, beyond a certain training batch size, this leads to a reduction in the convergence speed. In short, $N _ { T }$ , $N _ { P }$ , and $N _ { A }$ encapsulate many complex dynamics relating both computational and convergence aspects of the learning procedure. Their effect on the convergence of the learning process has to be measured by analyzing not only TPS but also the learning curves.
+
+# 4.3 DYNAMIC ADJUSTMENT OF TRADE-OFFS
+
+The setting of $N _ { P }$ , $N _ { T }$ and $N _ { A }$ that maximizes the TPS depends on many aspects such as the computational load of the simulation environment, the size of the DNN, and the available hardware. As a rule of thumb, we found that the number of agents $N _ { A }$ should at least match the available CPU cores, with two predictors and two trainers $N _ { P } = N _ { T } = 2$ . However, this rule hardly generalizes to a large variety of different situations and only occasionally corresponds to the computationally most efficient configuration. Therefore, we propose an annealing process to configure the system dynamically. Every minute, we randomly change $N _ { P }$ , $N _ { T }$ , or $N _ { A }$ by $\pm 1$ , monitoring alterations in TPS to accept or reject the new setting. The optimal configuration is then automatically identified in a reasonable time, for different environments or systems. Figure 2 shows the automatic adjustment procedure finding two different optimal settings for two different games, on the same real system.
+
+# 4.4 POLICY LAG IN GA3C
+
+At a first sight, GA3C and A3C are different implementations of the same algorithm, but GA3C has a subtle difference which affects the stability of the algorithm. This problem is caused by the latency between the time $t - k$ , when a training example has been generated, and when it is consumed for training, $t$ , essentially changing the gradients to:
+
+$$
+\nabla _ { \theta } \left[ \log \pi \left( a _ { t - k } | s _ { t - k } ; \theta \right) \left( R _ { t - k } - V \left( s _ { t - k } ; \theta _ { t } \right) \right) + \beta H \left( \pi \left( s _ { t - k } ; \theta \right) \right) \right] .
+$$
+
+Since the Training Queue is not blocking, the states it contains can be old. The value of the delay $k$ is bounded by the maximum size of the queue and influenced by how the system configuration balances training and prediction rates. In other words, the DNN controller selects the action $a _ { t - k }$ at time $t - k$ ; the corresponding experience lies in a training queue until time $t$ , when a trainer thread pops the element out of the queue to compute the gradient as in Eq. (4). The DNN controller at time $t$ generally differs from the one at time $t - k$ , since trainers can modify the DNN weights at any time. Therefore, the policy and value function $\pi$ and $V$ used to compute the gradient at time $t$ will differ from those used at time $t - k$ to collect the experience, whereas the action used to compute the gradient in Eq. (4) remains $a _ { t - k }$ .
+
+This delay can lead to instabilities for two reasons. The first one is the possible generation of very large values in $\log \pi \left( a _ { t - k } | s _ { t - k } ; \theta _ { t } \right)$ . In fact, $\pi \left( a _ { t - k } | s _ { t - k } ; \theta _ { t - k } \right)$ is generally large, since it is the probability of sampled action $a _ { t - k }$ , but over the course of lag $k$ new parameters $\theta _ { t }$ can make $\pi \left( a _ { t - k } | s _ { t - k } ; \theta _ { t } \right)$ very small. In the worst case, the updated probability is zero, generating infinite values in the log and causing optimization to fail. To avoid this, we add a small term $\epsilon > 0$ :
+
+$$
+\nabla _ { \theta } \left[ \log \left( \pi \left( a _ { t - k } \middle | s _ { t - k } ; \theta \right) + \epsilon \right) \left( R _ { t - k } - V \left( s _ { t - k } ; \theta _ { t } \right) \right) + \beta H \left( \pi \left( s _ { t - k } ; \theta \right) + \epsilon \right) \right] .
+$$
+
+Beyond fixing the error in the case $\pi = 0$ , this fix also improves the stability of the algorithm and removes the necessity of gradient clipping. In fact, as $\bar { \partial \log ( \pi + \epsilon ) } / \partial \theta \stackrel { - } { = } ( \partial \pi / \partial \theta ) \bar { / } ( \pi + \epsilon ) ,$ $\epsilon$ establishes an upper bound for the multiplicative factor in front of $\partial \pi / \partial \theta$ . A similar term is also added in the entropy computation to avoid a similar explosion. It is important to remember that even A3C suffers from a similar issue. In fact, as the action $a _ { t }$ in Eq. (1) is selected by sampling the output softmax, there is a chance that $\pi ( { a } _ { t } )$ is very small and therefore $\partial \log ( \pi ) / \dot { \partial } \theta$ is large. However, gradient clipping prevents the usage of a gradient with large magnitude in A3C.
+
+The second reason for introducing instabilities in GA3C is a generalization of the first one. Since training and predictions are computed with potentially different DNN parameters, the resulting gradient is noisy, and can therefore lead to unreliable updates of the DNN weights. This is different from A3C, where every agent has its own copy of the model and uses it to compute both $\pi$ and $\partial \log ( \pi ) / \partial \theta$ , before synchronizing the DNN model with the other agents.
+
+# 5 ANALYSIS
+
+We profile the performance of GA3C and in the process seek to better understand the system dynamics of deep RL training on hybrid CPU/GPU systems. Experiments are conducted on the GPUenabled systems described in Table 1 and monitored with CUDA profilers and custom profiling code based on performance counter timing within Python. We present profiling and convergence experiments both with and without automatic adjustment of the number of agents $N _ { A }$ , trainers $N _ { T }$ , and predictors $N _ { P }$ , and without constraints on the size of the prediction and training queues.
+
+![](images/06e9c560da6d5f597629e0687072ccae3030c4959e8c93f01c05686c94f37056.jpg)  
+Figure 3: TPS of the top three configurations of predictors $N _ { P }$ and trainers $N _ { T }$ for several settings of agents $N _ { A }$ , while learning PONG on System I from Table 1. TPS is normalized by best performance after 16 minutes. Larger DNN models are also shown, as described in the text.
+
+# 5.1 EFFECT OF RESOURCE UTILIZATION ON TPS
+
+Maximizing training speed. To begin, consider raw training speed as expressed in model update frequency, or trainings per second (TPS). Figure 3 shows TPS on System I in Table 1 for the first 16 minutes of training on PONG. We consider numbers of agents $N _ { A } \dot { \in } \{ 1 6 , 3 2 , 6 4 , 1 2 8 \}$ and plot the top 3 combinations of $N _ { P } , N _ { T } \in \{ 1 , 2 , 4 , 8 , 1 6 \}$ . On this system, increasing $N _ { A }$ yields a higher TPS up to $N _ { A } = 1 2 8$ where diminishing returns are observed, likely due to additional process overhead. The highest consistent TPS on this system is observed with $N _ { A } = 1 2 8$ and $N _ { P } = N _ { T } = 2$ with a speed-up of $\sim 4 \times$ relative to the CPU-only implementation (see Table 2).
+
+![](images/526023fd63c04b3b1262fd781abadbb999851fc3930efcd55d5e279396a31e95.jpg)  
+Figure 4: The average training queue size (left) and prediction batch size (right) of the top 3 performing configurations of $N _ { P }$ and $N _ { T }$ , for each $N _ { A }$ , with PONG and the System I in Table 1.
+
+Table 1: Systems used for profiling and testing.   
+
+<table><tr><td></td><td>System I</td><td>System II</td><td>System III</td><td>System IV</td></tr><tr><td>Processor (Intel)</td><td>Xeon E5-2640v3 2.60 GHz 16 cores,dual socket</td><td>Core i-3820 3.60 GHz 8cores</td><td>HaswellE5-2698v3 2.30 GHz 16 cores</td><td>Xeon E5-2680v2 2.80 GHz 10 cores</td></tr><tr><td>GPU (NVIDIA)</td><td>Geforce Titan X (Maxwell)</td><td>GeForce 980 (Maxwell)</td><td>Tesla K80 (Kepler)</td><td>Quadro M6000 (Maxwell)</td></tr><tr><td>Software / Profilers</td><td colspan="4">Python 3.5,CUDA 7.5 (I-II)/CUDA 8 (IV), CUDNN v5.1,TensorFlow r0.11 nvprof, nvvp</td></tr></table>
+
+GPU utilization and DNN size. The fastest configuration ( $N _ { A } = 1 2 8$ , $N _ { P } = N _ { T } = 2 $ ) for System I in Table 1 has an average GPU utilization time of only $5 6 \%$ , with average and peak occupancy of $7 6 \%$ and $9 8 \%$ , respectively.1 This suggests there is computational capacity for a larger network model. Therefore we profile GA3C on a series of deeper DNN architectures2 to evaluate this hypothesis. Figure 3 shows that TPS drops by only $7 \%$ with a one-layer deeper DNN controller; at the same time, the
+
+Table 2: PPS on different systems (Table 1), for small and large DNNs, with CPU and GPU utilization for GA3C.   
+
+<table><tr><td></td><td></td><td colspan="3">PPS</td><td colspan="2">Utilization (%)</td></tr><tr><td>System</td><td>DNN</td><td>A3C</td><td>GA3C</td><td>Speed up</td><td>CPU</td><td>GPU</td></tr><tr><td rowspan="5">System I</td><td>small</td><td>352</td><td>1361</td><td>4×</td><td>32</td><td>56</td></tr><tr><td>large, stride 4</td><td>113</td><td>1271</td><td>11×</td><td>27</td><td>68</td></tr><tr><td>large,stride 3</td><td>97</td><td>1206</td><td>12×</td><td>27</td><td>77</td></tr><tr><td>large, stride 2</td><td>43</td><td>874</td><td>20×</td><td>26</td><td>82</td></tr><tr><td>large, stride 1</td><td>11</td><td>490</td><td>45×</td><td>17</td><td>90</td></tr><tr><td rowspan="2">System II</td><td>small</td><td>116</td><td>728</td><td>6×</td><td>62</td><td>33</td></tr><tr><td>large, stride 1</td><td>12</td><td>336</td><td>28×</td><td>49</td><td>78</td></tr><tr><td rowspan="2">System III</td><td>small</td><td>300</td><td>1248</td><td>4×</td><td>31</td><td>60</td></tr><tr><td>large, stride 1</td><td>38</td><td>256</td><td>6×</td><td>17</td><td>82</td></tr></table>
+
+average GPU utilization and occupancy increase by approximately $1 2 \%$ and $0 . 5 \%$ , respectively. The $7 \%$ drop in TPS is the consequence of the increased depth which forces an additional serial computational on the GPU (and therefore a $1 2 \%$ increase in its utilization). The negligible $0 . 5 \%$ increase in occupancy is likely explained by an efficient management of the computational resources by cuDNN; there is still room available to run additional parallel tasks (or, in other words, a wider DNN) at minimal cost.
+
+![](images/ad0b179398676c633b7b47258fc7efaa5686750f4af3d0d5760ee3d128420c30.jpg)  
+Figure 5: Effect of PPS on convergence speed. For each game, four different settings of GA3C are shown, all starting from the same DNN initialization. Numbers on the right show the cumulative number of frames played among all agents for each setting over the course of 3 hours. Configurations playing more frames converge faster. The dynamic configuration method is capable of catching up with the optimal configuration despite starting with a sub-optimal setting, $N _ { T } = N _ { P } = N _ { A } = 1$ .
+
+By reducing the stride of the first layer of the DNN (in addition to adding a convolutional layer), we scale DNN size with finer granularity, and we compare FPS between GA3C and our CPU implementation of A3C. Table 2 shows the speed up provided by GA3C increases as the DNN grows. This is mainly due to increasing GPU utilization, as reported in Table 2. With the largest DNN, our CPU implementation achieves $\mathrm { T P S } \approx 1 1$ , which is approximately $4 5 \times$ slower than GA3C. This behavior is consistent across different systems, as shown in Table 2, where the CPU implementation of A3C using the largest DNN with stride 1 is $7 \times$ (System III) to $3 2 \times$ (System I) slower than the small network. Scaling with DNN size is more favorable on a GPU, with a slow down factor of $4 . 9 \times$ in the worst case (System III) and $2 . 2 \times$ in the best case (System II). Further, more recent GPUs (Maxwell architecture) scale better ( $2 . 2 \times$ and $2 . 7 \times$ slow down for Systems I and II) than older GPUs $( 4 . 8 \times$ slow down for the Kepler architecture, System III).
+
+Generally speaking, for large DNNs, maximum TPS and FPS are achieved by intensively using the GPU for prediction and training, while the CPU runs the simulation environment and remains mostly idle. In practice, this allows experimenting with larger architectures, which may be particularly important for real world problems, e.g. robotics or autonomous driving (Lillicrap et al., 2015). Moreover, the idle CPU represents an additional computational resource, but such investigation is beyond the scope of this paper.
+
+Significant latency. Profiling on System I in Table 1 reveals that the average time spent by an agent waiting for a prediction call to be completed is $1 0 8 \mathrm { m s }$ , only $1 0 \%$ of which is taken by the GPU inference. The remaining $9 0 \%$ is overhead spent accumulating the batch and calling the prediction function in Python. Similarly, for training we find that of the average 11.1ms spent performing a DNN update, $5 9 \%$ is overhead. This seems to suggest that a more optimized implementation (possibly based on a low level language like $\mathrm { C } { + + }$ ) may reduce these overheads, but this investigation remains for future work.
+
+Manually balancing components. Agents, predictors, and trainers all share the GPU as a resource; thus balance is important. Figure 3 shows the top three performing configurations of $N _ { P }$ and $N _ { T }$ for different numbers of agents, $N _ { A }$ , with System I in Table 1. A $1 4 \%$ drop in TPS is exhibited between the best and worst depicted configuration, despite the exclusion of all but the top three performers for each number of agents. The best results have 4 or fewer predictor threads, seemingly preventing batches from becoming too small. The $N _ { P } : N _ { T }$ ratios for top performers tend to be $1 : 2 , 1 : 1$ , or $2 : 1$ , whereas higher ratios such as $1 : 8$ and $1 : 4$ are rarely successful, likely due to the implicit dependence of training on prediction speed. However, if the training queue is too full, training calls take more GPU time, thereby throttling prediction speed. This is further confirmed by our experimental finding that TPS and PPS plots track closely. Figure 4 shows training queue size and prediction batch size for the top configurations. In all cases, the training queue stabilizes well below its maximum capacity. Additionally, the fastest configuration has one of the largest average prediction batch sizes, yielding higher GPU utilization.
+
+<table><tr><td></td><td colspan="8">Atari Game Scores</td><td colspan="2">Attributes</td></tr><tr><td></td><td>AMIDAR BOXING CENTIPEDE</td><td></td><td></td><td>NAME THISGAME</td><td>PACMANPONG</td><td></td><td>QBERT SEAQUEST</td><td>UP-DOWN</td><td>Time</td><td>System</td></tr><tr><td>Human</td><td>1676</td><td>10</td><td>10322</td><td>6796</td><td>15375</td><td>16 12085</td><td>40426</td><td>9896</td><td></td><td>1</td></tr><tr><td>Random</td><td>6</td><td>-2</td><td>1926</td><td>198</td><td>1748</td><td>-18 272</td><td>216</td><td>533</td><td></td><td>1</td></tr><tr><td>A3C</td><td>264</td><td>60</td><td>3756</td><td>10476</td><td>654</td><td>6 15149</td><td>2355</td><td>74706</td><td>4 days</td><td>CPU</td></tr><tr><td>GA3C</td><td>218</td><td>92</td><td>7386</td><td>5643</td><td>1978</td><td>18 14966</td><td>1706</td><td>8623</td><td>1day</td><td>GPU</td></tr></table>
+
+Table 3: Average scores on a subset of Atari games achieved by: a random player (Mnih et al., 2015); a human player (Mnih et al., 2015); A3C after four days of training on a CPU (Mnih et al., 2016); and GA3C after one day of training. For GA3C, we measured the average score on 30 games, each initialized with a random seed.
+
+# 5.2 EFFECT OF TPS ON LEARNING SPEED
+
+The beneficial effect of an efficient configuration on the training speed is shown in Figure 5. Training with a suboptimal configuration (e.g. $N _ { P } = N _ { T } = N _ { A } = 1$ or $N _ { P } = N _ { T } = 1$ , $N _ { A } = 1 6$ ) leads to a severe underutilization of the GPU, a low TPS, and a slow training process. Using the optimal configuration achieves a much higher score in a shorter period of time, mainly driven by playing more frames, i.e. collecting more experiences, in the same amount of time.
+
+Mnih et al. (2016) note that asynchronous methods generally achieve significant speedups from using a greater number of agents, and even report superlinear speedups for asynchronous one-step Q-learning. It is worth noting that optimal configurations for GA3C generally employ a much higher number of agents compared to the CPU counterpart, e.g. the optimal configuration for System I in Table 1 uses 128 agents. This suggests that GPU implementations of asynchronous learning methods may benefit from both a higher TPS and from collecting experiences from a wider number of agents.
+
+The learning curve for GA3C with dynamic configuration (Figure 5) tracks closely with the learning curve of the optimal configuration. The total number of frames played is generally slightly lower over the same time due to the search procedure overhead: the configuration is changed once every minute, tending to oscillate around the optimal configuration. Notice also that, in Figure 5, the starting point of the dynamic configuration is $N _ { T } = N _ { P } = N _ { A } = 1$ , which is much slower than the optimal configuration. But scoring performance is nearly identical, indicating that the dynamic method may ease the burden of configuring GA3C on a new system.
+
+Table 3 compares scores achieved by A3C on the CPU (as reported in (Mnih et al., 2016)) with the best agent trained by our TensorFlow implementation of GA3C. Unfortunately, a direct speed comparison is infeasible without either the original source code or the average number of frames or training updates per second. However, results in this table do show that after one day of training our open-source implementation can achieve similar scores to A3C after four days of training.
+
+Figure 6 shows typical training curves for GA3C on several Atari games as a function of wallclock time. When compared to the training curves reported in Mnih et al. (2016), GA3C shows faster convergence toward the maximum score in a shorter time for certain games such as PONG, convergence towards a better score in a larger amount of time (e.g. QBERT) or, for other games, a slower convergence rate (e.g. BREAKOUT). It has to be noted, however, that data reported by Mnih et al. (2016) are the average learning curves of the top five learners in a set of fifty learners, each with a different learning rate. On the other hand, in Figure 6, we are reporting three different runs for two (not essentially optimal) learning rates, fixed for all the games. This demonstrates some robustness of GA3C with respect to the choice of the learning rate, whereas it is also likely that better learning curves can be obtained using optimized learning rates. A deeper investigation on a large amount of data, potentially facilitated by our release of the GA3C code, may also reveal how peculiarities of each game differently affect the convergence of A3C and GA3C, but this goes beyond the scope of this paper.
+
+# 5.3 POLICY LAG, LEARNING STABILITY AND CONVERGENCE SPEED
+
+One of the main differences between GA3C and A3C is the asynchronous computation of the forward step (policy $\pi$ ) and the gradients (Eq. (4)) used to update the DNN. Delays between these two operations may introduce noise in the gradients, making the learning process unstable. We experimentally investigated the impact of this asynchrony on the learning process to determine if a synchronization mechanism, which may negatively impact both PPS and TPS, can increase the stability of the algorithm.
+
+![](images/0c16b7d73245082b17a8e33dba0e2a6872587f179bdffd9c7e929b578017e41b.jpg)  
+Figure 6: Training curves for GA3C on five Atari games. Each training has been performed three times for each of two learning rates (0.0003 and 0.0001) on System IV in Table 1.
+
+![](images/e18b30807e242a8195c95e4286f18a813a54e1147dbd6401fa2dfaaca1809132.jpg)  
+Figure 7: Training GA3C with a range of minimum training batch sizes. Increasing the minimum training batch size from 1 to 40 reduces the effect of the policy lag (delay $k$ in Eq. (4)), leading to convergence that is faster and more stable. GA3C achieved the overall best results with a minimum batch size between 20 and 40. Increasing beyond this threshold dramatically reduces convergence speed for some games, especially those inclined to unstable learning curves.
+
+In GA3C, each agent generally pushes $t _ { m a x }$ experiences in the training queue. By default, trainers collect a batch of experiences from a single agent from the training queue and send the batch to the GPU to compute gradients, as in Eq. (5). Each time a trainer updates the DNN weights, the remaining experiences in the training queue are no longer in sync with the DNN model. This situation becomes worse when the average length of the training queue is large.
+
+By allowing larger training batch sizes, we reduce the number of DNN updates per second (TPS), and consequently diminish the effect of the delay $k$ in Eq. (5). In this way we increase the chance that the collected experiences and the computed gradients are in sync, which improves the stability. Notice that, even if the TPS is lower, the average magnitude of the updates is indeed larger, since we sum the gradients computed over the training batch.
+
+In this setting, the optimal training batch size compromises among TPS, the average gradient step magnitude and the training stability. Another factor to be considered is that batching training data potentially leverages the GPU computational capability better by reducing the time devoted to compute the DNN updates while increasing the GPU occupancy during this phase. This gives more GPU time to the predictors, potentially increasing the PPS. However, this advantage tends to disappear when the training batch size is too large and predictors stay idle while the DNN update is computed.
+
+Figure 7 compares convergence curves when no minimum size for training batch is compulsory (the default GA3C implementation where gradient updates are computed on a single agent’s batch) and when a minimum training batch size is enforced (combining multiple agent batches into a single gradient update). In the latter case, trainers collect experiences from multiple agents at the same time from the training queue and send them to the GPU for computation of gradients as in Eq. (5). Up to a certain batch size (between 20 and 40, in our experiments), increasing the training batch size stabilizes the learning procedure and generally leads to faster convergence. Some games such as PONG indeed do not suffer from this instability, and the effect of the minimum batch size is less evident in this case. We speculate that a careful selection of the learning rate combined with the proper minimum training batch size may lead to even faster convergence.
+
+# 6 CONCLUSION
+
+By investigating the computational aspects of our hybrid CPU/GPU implementation of GA3C, we achieve a significant speed up with respect to its CPU counter part. This comes as a result of a flexible system capable of finding a reasonable allocation of the available computational resources. Our approach allows producing and consuming training data at the maximum pace on different systems, or to adapt to temporal changes of the computational load on one system. Despite the fact that we analyze A3C only, most of our findings can be applied to similar RL asynchronous algorithms.
+
+We believe that the analysis of the computational aspects of RL algorithms may be a consistent theme in RL in the future, motivating further studies such as this one. The potential benefits of such investigation goes well beyond the computational aspects. For instance, we demonstrate that GA3C scales with the size of the DNN much more efficiently than our CPU implementation of A3C, thus opening the possibility to explore the use of large DNN controllers to solve real world RL problems.
+
+By open sourcing GA3C (see https://github.com/NVlabs/GA3C), we allow other researchers to further explore this space, investigate in detail the computational aspects of deep RL algorithms, and test new algorithmic solutions, including strategies for the combined utilization of the CPU and GPU computational resources.
+
+# ACKNOWLEDGMENTS
+
+We thank Prof. Roy H. Campbell for partially supporting this work.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´ Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´ berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org.
+
+M. G. Bellemare, S. Srinivasan, G. Ostrovski, T. Schaul, D. Saxton, and R. Munos. Unifying CountBased Exploration and Intrinsic Motivation. ArXiv e-prints, June 2016.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.
+
+G. Lample and D. Singh Chaplot. Playing FPS Games with Deep Reinforcement Learning. ArXiv e-prints, September 2016.
+
+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. CoRR, abs/1509.02971, 2015. URL http://arxiv.org/abs/1509.02971.
+
+V. Mnih, A. Puigdomenech Badia, M. Mirza, A. Graves, T. P. Lillicrap, T. Harley, D. Silver, and K. Kavukcuoglu. Asynchronous Methods for Deep Reinforcement Learning. ArXiv preprint arXiv:1602.01783, 2016.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 02 2015. URL http://dx.doi.org/10.1038/ nature14236.
+
+Arun Nair, Praveen Srinivasan, Sam Blackwell, Cagdas Alcicek, Rory Fearon, Alessandro De Maria, Vedavyas Panneershelvam, Mustafa Suleyman, Charles Beattie, Stig Petersen, Shane Legg, Volodymyr Mnih, Koray Kavukcuoglu, and David Silver. Massively parallel methods for deep reinforcement learning. CoRR, abs/1507.04296, 2015. URL http://arxiv.org/abs/ 1507.04296.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. CoRR, abs/1511.05952, 2015. URL http://arxiv.org/abs/1511.05952.
+
+David Silver, Aja Huang, Christopher J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with deep neural networks and tree search. Nature, 529:484–503, 2016. URL http: //www.nature.com/nature/journal/v529/n7587/full/nature16961.html.
+
+Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, Cambridge, MA, USA, 1st edition, 1998. ISBN 0262193981.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 4(2), 2012.
+
+Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. CoRR, abs/1509.06461, 2015. URL http://arxiv.org/abs/1509.06461.
+
+Ziyu Wang, Nando de Freitas, and Marc Lanctot. Dueling network architectures for deep reinforcement learning. CoRR, abs/1511.06581, 2015. URL http://arxiv.org/abs/1511. 06581.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.

parse/train/r1VGvBcxl/r1VGvBcxl_content_list.json

@@ -0,0 +1,1271 @@
+[
+    {
+        "type": "text",
+        "text": "REINFORCEMENT LEARNING THROUGH ASYN-CHRONOUS ADVANTAGE ACTOR-CRITIC ON A GPU",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Babaeizadeh   \nDepartment of Computer Science   \nUniversity of Illinois at Urbana-Champaign, USA   \nmb2@uiuc.edu ",
+        "bbox": [
+            183,
+            170,
+            511,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Iuri Frosio, Stephen Tyree, Jason Clemons, Jan Kautz NVIDIA, USA {ifrosio,styree,jclemons,jkautz}@nvidia.com ",
+        "bbox": [
+            183,
+            247,
+            599,
+            290
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            327,
+            544,
+            342
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce a hybrid CPU/GPU version of the Asynchronous Advantage ActorCritic (A3C) algorithm, currently the state-of-the-art method in reinforcement learning for various gaming tasks. We analyze its computational traits and concentrate on aspects critical to leveraging the GPU’s computational power. We introduce a system of queues and a dynamic scheduling strategy, potentially helpful for other asynchronous algorithms as well. Our hybrid CPU/GPU version of A3C, based on TensorFlow, achieves a significant speed up compared to a CPU implementation; we make it publicly available to other researchers at https://github.com/NVlabs/GA3C. ",
+        "bbox": [
+            233,
+            358,
+            764,
+            484
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            515,
+            336,
+            531
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the past, the need for task-specific, or even hand-crafted, features limited the application of Reinforcement Learning (RL) in real world problems (Sutton & Barto, 1998). However, the introduction of Deep Q-Learning Networks (DQN) (Mnih et al., 2015) revived the use of Deep Neural Networks (DNNs) as function approximators for value and policy functions, unleashing a rapid series of advancements. Remarkable results include learning to play video games from raw pixels (Bellemare et al., 2016; Lample & Singh Chaplot, 2016) and demonstrating super-human performance on the ancient board game Go (Silver et al., 2016). Research has yielded a variety of effective training formulations and DNN architectures (van Hasselt et al., 2015; Wang et al., 2015), as well as methods to increase parallelism while decreasing the computational cost and memory footprint (Nair et al., 2015; Mnih et al., 2016). In particular, Mnih et al. (2016) achieve state-of-the-art results on many gaming tasks through a novel lightweight, parallel method called Asynchronous Advantage ActorCritic (A3C). When the proper learning rate is used, A3C learns to play an Atari game (Brockman et al., 2016) from raw screen inputs more quickly and efficiently than previous methods: on a 16- core CPU, A3C achieves higher scores than previously published methods run for the same amount of time on a GPU. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our study sets aside many of the learning aspects of recent work and instead delves into the computational issues of deep RL. Computational complexities are numerous, largely centering on a common factor: RL has an inherently sequential aspect, since the training data are generated while learning. The DNN model is constantly queried to guide the actions of agents whose gameplay in turn feeds DNN training. Training batches are commonly small and must be efficiently shepherded from the agents and simulator to the DNN trainer. When using a GPU, the mix of small DNN architectures, small training batch sizes, and contention for the GPU for both inference and training can lead to a severe under-utilization of the computational resources. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To systematically investigate these issues, we implement both CPU and GPU versions of A3C in TensorFlow (TF) (Abadi et al., 2015), optimizing each for efficient system utilization and to approximately replicate published scores in the Atari 2600 environment (Brockman et al., 2016). We analyze a variety of “knobs” in the system and demonstrate effective automatic tuning of those during training. Our hybrid CPU/GPU implementation of A3C, named GA3C, generates and consumes training data substantially faster than its CPU counterpart, up to $\\sim 6 \\times$ faster for small DNNs and $\\sim 4 5 \\times$ for larger DNNs. While we focus on the A3C architecture, this analysis can be helpful for researchers and framework developers designing the next generation of deep RL methods. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            339,
+            209
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in deep RL have derived from both novel algorithmic approaches and related systems optimizations. Investigation of the algorithmic space seems to be the most common approach among researchers. Deep Q-Learning Networks (DQN) demonstrate a general approach to the learning problem (Mnih et al., 2015), relying heavily on the introduction of an experience replay memory to stabilize the learning procedure. This improves reliability but also increases the computational cost and memory footprint of the algorithm. Inspired by DQN, researchers have proposed more effective learning procedures, achieving faster and more stable convergence: Prioritized DQN (Schaul et al., 2015) makes better use of the replay memory by more frequently selecting frames associated with significant experiences. Double-DQN (van Hasselt et al., 2015) separates the estimate of the value function from the choice of actions (policy), thus reducing the tendency in DQN to be overly optimistic when evaluating its choices. Dueling Double DQN (Wang et al., 2015) goes a step further by explicitly splitting the computation of the value and advantage functions within the network. The presence of the replay memory makes the DQN approaches more suitable for a GPU implementation when compared to other LR methods, but state-of-the-art results are achieved by A3C (Mnih et al., 2016), which does not make use of it. ",
+        "bbox": [
+            174,
+            224,
+            825,
+            433
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Among systems approaches, AlphaGo (Silver et al., 2016) recently achieved astonishing results through combined algorithmic and hardware specialization. The computational effort is impressive: 40 search threads, 1202 CPUs, and 176 GPUs are used in the distributed version for inference only. Supervised training took around three weeks for the policy network, using 50 GPUs, and another day using the RL approach for refinement. A similar amount of time was required to train the value network. Gorilla DQN (Nair et al., 2015) is a similarly impressive implementation of distributed RL system, achieving a significant improvement over DQN. The system requires 100 concurrent actors on 31 machines, 100 learners and a central parameter server with the network model. This work demonstrates the potential scalability of deep RL algorithms, achieving better results in less time, but with a significantly increased computational load, memory footprint, and cost. ",
+        "bbox": [
+            174,
+            439,
+            825,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 ASYNCHRONOUS ADVANTAGE ACTOR CRITIC (A3C) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            599,
+            647,
+            614
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 REINFORCEMENT LEARNING BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            630,
+            521,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In standard RL, an agent interacts with an environment over a number of discrete time steps. At each time step $t$ , the agent observes a state $s _ { t }$ and, in the discrete case, selects an action $a _ { t }$ from the set of valid actions. An agent is guided by policy $\\pi$ , a function mapping from states $s _ { t }$ to actions $a _ { t }$ . After each action, the agent observes the next state $s _ { t + 1 }$ and receives feedback in the form of a reward $r _ { t }$ . This process continues until the agent reaches a terminal state or time limit, after which the environment is reset and a new episode is played. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The goal of learning is to find a policy $\\pi$ that maximizes the expected reward. In policy-based modelfree methods, a function approximator such as a neural network computes the policy $\\pi ( { a } _ { t } | { s } _ { t } ; \\theta )$ , where $\\theta$ is the set of parameters of the function. There are many methods for updating $\\theta$ based on the rewarascent on $\\mathbb { E } [ R _ { t } ]$ eived fr, where $\\begin{array} { r } { R _ { t } = \\sum _ { i = 0 } ^ { \\infty } \\gamma ^ { i } r _ { t + i } } \\end{array}$ . REINFORCE methods (Williams, 1992) use grais the accumulated reward starting from time step $t$ ientand increasingly discounted at each subsequent step by factor $\\gamma \\in ( 0 , 1 ]$ . ",
+        "bbox": [
+            174,
+            747,
+            825,
+            832
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The standard REINFORCE method updates $\\theta$ using the gradient $\\nabla _ { \\theta } \\log \\pi ( a _ { t } | s _ { t } ; \\theta ) R _ { t }$ , which is an unbiased estimator of $\\nabla _ { \\boldsymbol { \\theta } } \\mathbb { E } [ R _ { t } ]$ . The variance of the estimator is reduced by subtracting a learned baseline (a function of the state $b _ { t } ( s _ { t } ) )$ and using the gradient $\\nabla _ { \\theta } \\log \\pi ( a _ { t } | s _ { t } ; \\theta ) \\big ( R _ { t } ~ - ~ b _ { t } ( s _ { t } ) \\big )$ instead. One common baseline is the value function defined as $V ^ { \\pi } ( s _ { t } ) = \\mathbb { E } [ R _ { t } | s _ { t } ]$ which is the expected return for following the policy $\\pi$ in state $s _ { t }$ . In this approach the policy $\\pi$ and the baseline $b _ { t }$ can be viewed as actor and critic in an actor-critic architecture (Sutton $\\&$ Barto, 1998). ",
+        "bbox": [
+            174,
+            838,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.2 ASYNCHRONOUS ADVANTAGE ACTOR CRITIC (A3C) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            583,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A3C (Mnih et al., 2016), which achieves state-of-the-art results on many gaming tasks including Atari 2600, uses a single DNN to approximate both the policy and value function. The DNN has two convolutional layers with $1 6 \\times 8 \\times 8$ filters with a stride of 4, and $3 2 \\times 4 \\times 4$ filters with a stride of 2, followed by a fully connected layer with 256 units; each hidden layer is followed by a rectifier nonlinearity. The two outputs are a softmax layer which approximates the policy function $\\pi \\left( a _ { t } | s _ { t } ; \\theta \\right)$ , and a linear layer to output an estimate of $V \\left( s _ { t } ; \\theta \\right)$ . Multiple agents play concurrently and optimize the DNN through asynchronous gradient descent. Similar to other asynchronous methods, the network weights are stored in a central parameter server (Figure 1a). Agents calculate gradients and send updates to the server after every $t _ { m a x } = 5$ actions, or when a terminal state is reached. After each update, the central server propagates new weights to the agents to guarantee they share a common policy. ",
+        "bbox": [
+            173,
+            128,
+            825,
+            282
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Two cost functions are associated with the two DNN outputs. For the policy function, this is: ",
+        "bbox": [
+            173,
+            289,
+            781,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/269d83e0c6cd2f4860a123f8002b9fbaa907e93421915d051fa17be880c42996.jpg",
+        "text": "$$\nf _ { \\pi } \\left( \\theta \\right) = \\log \\pi \\left( a _ { t } | s _ { t } ; \\theta \\right) \\left( R _ { t } - V \\left( s _ { t } ; \\theta _ { t } \\right) \\right) + \\beta H \\left( \\pi \\left( s _ { t } ; \\theta \\right) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            309,
+            697,
+            328
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where estima $\\theta _ { t }$ are the values of the parameters  discounted reward in the time i $\\theta$ at time erval fro $t$ , $\\begin{array} { r } { R _ { t } = \\sum _ { i = 0 } ^ { k - 1 } \\gamma ^ { i } r _ { t + i } + \\gamma ^ { k } V \\left( s _ { t + k } ; \\theta _ { t } \\right) } \\end{array}$ $t$ $t + k$ $k$ $t _ { m a x }$ while $H \\left( \\pi \\left( s _ { t } ; \\boldsymbol { \\theta } \\right) \\right)$ is an entropy term, used to favor exploration during the training process. The factor $\\beta$ controls the strength of the entropy regularization term. The cost function for the estimated value function is: ",
+        "bbox": [
+            174,
+            333,
+            825,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/48d34a41c633fb854454103f24a7b36f3be13e648faf8de79826e68045cb6348.jpg",
+        "text": "$$\nf _ { v } \\left( \\theta \\right) = \\left( R _ { t } - V \\left( s _ { t } ; \\theta \\right) \\right) ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            401,
+            593,
+            421
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Training is performed by collecting the gradients $\\nabla \\theta$ from both of the cost functions and using the standard non-centered RMSProp algorithm (Tieleman $\\&$ Hinton, 2012) as optimization: ",
+        "bbox": [
+            173,
+            431,
+            823,
+            459
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/503111ff20a43e4764f0b2e82b53537204c751b1726f609b2165ce1df12e1802.jpg",
+        "text": "$$\n\\begin{array} { l } { g = \\alpha g + ( 1 - \\alpha ) \\Delta \\theta ^ { 2 } } \\\\ { \\theta  \\theta - \\eta \\Delta \\theta / \\sqrt { g + \\epsilon } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            465,
+            580,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The gradients $g$ can be either shared or separated between agent threads but the shared implementation is known to be more robust (Mnih et al., 2016). ",
+        "bbox": [
+            171,
+            503,
+            823,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The original implementation of A3C (Mnih et al., 2016) uses 16 agents on a 16 core CPU and it takes about four days to learn how to play an Atari game (Brockman et al., 2016). The main reason for using CPU other than GPU, is the inherently sequential nature of RL in general, and A3C in particular. In RL, the training data are generated while learning, which means the training and inference batches are small and GPU is mostly idle during the training, waiting for new data to arrive. Since A3C does not utilize any replay memory, it is completely sequential and therefore a CPU implementation is as fast as a naive GPU implementation. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 HYBRID CPU/GPU A3C (GA3C) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            488,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose GA3C, an alternative architecture of A3C, with emphasize on an efficient GPU utilization to increase the number of training data generated and processed per second. We demonstrate that our implementation of GA3C effectively converges significantly faster than our CPU implementation of A3C, achieving the state-of-the-art performance in a shorter time. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 GA3C ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            761,
+            374,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The primary components of GA3C (Figure 1b) are a DNN with training and prediction on a GPU, as well as a multi-process, multi-thread CPU architecture with the following components: ",
+        "bbox": [
+            176,
+            786,
+            823,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Agent is a process interacting with the simulation environment: choosing actions according to the learned policy and gathering experiences for further training. Similar to A3C, multiple concurrent agents run independent instances of the environment. Unlike the original, each agent does not have its own copy of the model. Instead it queues policy requests in a Prediction Queue before each action, and periodically submits a batch of input/reward experiences to a Training Queue; the size of each training batch is typically equal to $t _ { m a x }$ experiences, though it is sometimes smaller for experiences collected at the end of an episode. ",
+        "bbox": [
+            173,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d529a55a2458aed93556db2b17245be6121593b3507fa86dc39534060ea4695e.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of A3C and GA3C architectures. Agents act concurrently both in A3C and GA3C. In A3C, however, each agent has a replica of the model, whereas in GA3C there is only one GPU instance of the model. In GA3C, agents utilize predictors to query the network for policies while trainers gather experiences for network updates. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            112,
+            821,
+            295
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Predictor is a thread which dequeues as many prediction requests as are immediately available and batches them into a single inference query to the DNN model on the GPU. When predictions are completed, the predictor returns the requested policy to each respective waiting agent. To hide latency, one or more predictors can act concurrently. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Trainer is a thread which dequeues training batches submitted by agents and submits them to the GPU for model updates. GPU utilization can be increased by grouping training batches among several agents; we found that this generally leads to a more stable convergence, but the convergence speed is reduced when the merged training batches are too large; a compromise is explored in Section 5.3. Multiple trainers may run in parallel to hide latency. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unlike A3C, GA3C maintains only one copy of the DNN model (Fig. 1a and 1b), centralizing predictions and training updates and removing the need for synchronization. Also, in comparison with A3C, agents in GA3C do not compute the gradients themselves. Instead, they send experiences to trainers that update the network on the GPU accordingly. This introduces a potential lag between the generation and consumption of experiences, which we analyze in detail in Sections 4.4 and 5.3. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 PERFORMANCE METRICS AND TRADE-OFFS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            626,
+            519,
+            640
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The GA3C architecture exposes numerous tradeoffs for tuning its computational efficiency. In general, it is most efficient to transfer data to a GPU in large enough blocks to maximize the usage of the bandwidth between the GPU and CPU. Application performance on the GPU is optimized when the application has large amounts of parallel computations that can hide the latency of fetching data from memory. Thus, we want to maximize the parallel computations the GPU is performing, maximize the size of data transfer to the GPU, and minimize the number of transfers to the GPU. Increasing the number of predictors, $N _ { P }$ , allows faster fetching prediction queries, but leads to smaller prediction batches, resulting in multiple data transfers and overall lower GPU utilization. A larger number of trainers, $N _ { T }$ , potentially leads to more frequent updates to the model, but an overhead is paid when too many trainers occupy the GPU while predictors cannot access it. Lastly, increasing the number of agents, $N _ { A }$ , ideally generates more training experiences while hiding prediction latency. However, we would expect diminishing returns from unnecessary context switching overheads after exceeding some threshold depending on the number of CPU cores. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "These aspects are well captured by a metric like the Trainings Per Second (TPS), which is the rate at which we remove batches from the training queue. It corresponds to the rate of model updates and it is approximately proportional to the overall learning speed, given a fixed learning rate and training batch size. Another metric is the Predictions Per Second (PPS), the rate of issuing prediction queries from prediction queue, which maps to the combined rate of gameplay among all agents. Notice that in A3C a model update occurs every time an agent plays $t _ { m a x } = 5$ actions (Mnih et al., 2016). ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8281b416d1f3ce3805668c76149925533dd6d5611570574cd211760bedb0fd40.jpg",
+        "image_caption": [
+            "Figure 2: Automatic dynamic adjustment of $N _ { T }$ , $N _ { P }$ , and $N _ { A }$ , to maximize TPS for BOXING (left) and PONG (right), starting from a sub-optimal configuration $( N _ { A } = N _ { T } = N _ { P } = 1 )$ ) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            826,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Hence, in a balanced configuration, $\\mathrm { P P S } \\approx \\mathrm { T P S } \\times t _ { m a x }$ . Since each action is repeated four times as in (Mnih et al., 2016), the number of frames per second is $4 \\times \\mathrm { P P S }$ . ",
+        "bbox": [
+            173,
+            318,
+            823,
+            345
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Computational aspects are not disconnected from the convergence of the learning algorithm. For instance, employing too many agents will tend to fill the training queue, introducing a significant time delay between agent experiences $( a _ { t } , ~ s _ { t }$ and $R _ { t }$ in Eq. (1)) and the corresponding model updates, possibly threatening model convergence (see Section 4.4). Another example is batching of training data: larger batches improves GPU occupancy by increasing the parallelism. They also decrease the TPS (i.e., the number of model updates per second), increasing the chance that the DNN model used in prediction and to compute the gradient in Eq. (4) are indeed the same model. The consequence (experimentally observed, see Section 5.3) is an increased stability of the learning process but, beyond a certain training batch size, this leads to a reduction in the convergence speed. In short, $N _ { T }$ , $N _ { P }$ , and $N _ { A }$ encapsulate many complex dynamics relating both computational and convergence aspects of the learning procedure. Their effect on the convergence of the learning process has to be measured by analyzing not only TPS but also the learning curves. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            520
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 DYNAMIC ADJUSTMENT OF TRADE-OFFS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            536,
+            500,
+            550
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The setting of $N _ { P }$ , $N _ { T }$ and $N _ { A }$ that maximizes the TPS depends on many aspects such as the computational load of the simulation environment, the size of the DNN, and the available hardware. As a rule of thumb, we found that the number of agents $N _ { A }$ should at least match the available CPU cores, with two predictors and two trainers $N _ { P } = N _ { T } = 2$ . However, this rule hardly generalizes to a large variety of different situations and only occasionally corresponds to the computationally most efficient configuration. Therefore, we propose an annealing process to configure the system dynamically. Every minute, we randomly change $N _ { P }$ , $N _ { T }$ , or $N _ { A }$ by $\\pm 1$ , monitoring alterations in TPS to accept or reject the new setting. The optimal configuration is then automatically identified in a reasonable time, for different environments or systems. Figure 2 shows the automatic adjustment procedure finding two different optimal settings for two different games, on the same real system. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.4 POLICY LAG IN GA3C ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            718,
+            370,
+            732
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "At a first sight, GA3C and A3C are different implementations of the same algorithm, but GA3C has a subtle difference which affects the stability of the algorithm. This problem is caused by the latency between the time $t - k$ , when a training example has been generated, and when it is consumed for training, $t$ , essentially changing the gradients to: ",
+        "bbox": [
+            174,
+            743,
+            825,
+            800
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38580875f71624e96a5733c74b6d1927596034e16fd85199696bf8006ecbd883.jpg",
+        "text": "$$\n\\nabla _ { \\theta } \\left[ \\log \\pi \\left( a _ { t - k } | s _ { t - k } ; \\theta \\right) \\left( R _ { t - k } - V \\left( s _ { t - k } ; \\theta _ { t } \\right) \\right) + \\beta H \\left( \\pi \\left( s _ { t - k } ; \\theta \\right) \\right) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            804,
+            730,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since the Training Queue is not blocking, the states it contains can be old. The value of the delay $k$ is bounded by the maximum size of the queue and influenced by how the system configuration balances training and prediction rates. In other words, the DNN controller selects the action $a _ { t - k }$ at time $t - k$ ; the corresponding experience lies in a training queue until time $t$ , when a trainer thread pops the element out of the queue to compute the gradient as in Eq. (4). The DNN controller at time $t$ generally differs from the one at time $t - k$ , since trainers can modify the DNN weights at any time. Therefore, the policy and value function $\\pi$ and $V$ used to compute the gradient at time $t$ will differ from those used at time $t - k$ to collect the experience, whereas the action used to compute the gradient in Eq. (4) remains $a _ { t - k }$ . ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This delay can lead to instabilities for two reasons. The first one is the possible generation of very large values in $\\log \\pi \\left( a _ { t - k } | s _ { t - k } ; \\theta _ { t } \\right)$ . In fact, $\\pi \\left( a _ { t - k } | s _ { t - k } ; \\theta _ { t - k } \\right)$ is generally large, since it is the probability of sampled action $a _ { t - k }$ , but over the course of lag $k$ new parameters $\\theta _ { t }$ can make $\\pi \\left( a _ { t - k } | s _ { t - k } ; \\theta _ { t } \\right)$ very small. In the worst case, the updated probability is zero, generating infinite values in the log and causing optimization to fail. To avoid this, we add a small term $\\epsilon > 0$ : ",
+        "bbox": [
+            174,
+            138,
+            825,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f5a231131a5f54fe969a6ccb8db1312066291b50261c1e1f192e72cfc272a938.jpg",
+        "text": "$$\n\\nabla _ { \\theta } \\left[ \\log \\left( \\pi \\left( a _ { t - k } \\middle | s _ { t - k } ; \\theta \\right) + \\epsilon \\right) \\left( R _ { t - k } - V \\left( s _ { t - k } ; \\theta _ { t } \\right) \\right) + \\beta H \\left( \\pi \\left( s _ { t - k } ; \\theta \\right) + \\epsilon \\right) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            215,
+            763,
+            234
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Beyond fixing the error in the case $\\pi = 0$ , this fix also improves the stability of the algorithm and removes the necessity of gradient clipping. In fact, as $\\bar { \\partial \\log ( \\pi + \\epsilon ) } / \\partial \\theta \\stackrel { - } { = } ( \\partial \\pi / \\partial \\theta ) \\bar { / } ( \\pi + \\epsilon ) ,$ $\\epsilon$ establishes an upper bound for the multiplicative factor in front of $\\partial \\pi / \\partial \\theta$ . A similar term is also added in the entropy computation to avoid a similar explosion. It is important to remember that even A3C suffers from a similar issue. In fact, as the action $a _ { t }$ in Eq. (1) is selected by sampling the output softmax, there is a chance that $\\pi ( { a } _ { t } )$ is very small and therefore $\\partial \\log ( \\pi ) / \\dot { \\partial } \\theta$ is large. However, gradient clipping prevents the usage of a gradient with large magnitude in A3C. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            338
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The second reason for introducing instabilities in GA3C is a generalization of the first one. Since training and predictions are computed with potentially different DNN parameters, the resulting gradient is noisy, and can therefore lead to unreliable updates of the DNN weights. This is different from A3C, where every agent has its own copy of the model and uses it to compute both $\\pi$ and $\\partial \\log ( \\pi ) / \\partial \\theta$ , before synchronizing the DNN model with the other agents. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            415
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            434,
+            290,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We profile the performance of GA3C and in the process seek to better understand the system dynamics of deep RL training on hybrid CPU/GPU systems. Experiments are conducted on the GPUenabled systems described in Table 1 and monitored with CUDA profilers and custom profiling code based on performance counter timing within Python. We present profiling and convergence experiments both with and without automatic adjustment of the number of agents $N _ { A }$ , trainers $N _ { T }$ , and predictors $N _ { P }$ , and without constraints on the size of the prediction and training queues. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            550
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/06e9c560da6d5f597629e0687072ccae3030c4959e8c93f01c05686c94f37056.jpg",
+        "image_caption": [
+            "Figure 3: TPS of the top three configurations of predictors $N _ { P }$ and trainers $N _ { T }$ for several settings of agents $N _ { A }$ , while learning PONG on System I from Table 1. TPS is normalized by best performance after 16 minutes. Larger DNN models are also shown, as described in the text. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            563,
+            753,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 EFFECT OF RESOURCE UTILIZATION ON TPS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            842,
+            526,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Maximizing training speed. To begin, consider raw training speed as expressed in model update frequency, or trainings per second (TPS). Figure 3 shows TPS on System I in Table 1 for the first 16 minutes of training on PONG. We consider numbers of agents $N _ { A } \\dot { \\in } \\{ 1 6 , 3 2 , 6 4 , 1 2 8 \\}$ and plot the top 3 combinations of $N _ { P } , N _ { T } \\in \\{ 1 , 2 , 4 , 8 , 1 6 \\}$ . On this system, increasing $N _ { A }$ yields a higher TPS up to $N _ { A } = 1 2 8$ where diminishing returns are observed, likely due to additional process overhead. The highest consistent TPS on this system is observed with $N _ { A } = 1 2 8$ and $N _ { P } = N _ { T } = 2$ with a speed-up of $\\sim 4 \\times$ relative to the CPU-only implementation (see Table 2). ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/526023fd63c04b3b1262fd781abadbb999851fc3930efcd55d5e279396a31e95.jpg",
+        "image_caption": [
+            "Figure 4: The average training queue size (left) and prediction batch size (right) of the top 3 performing configurations of $N _ { P }$ and $N _ { T }$ , for each $N _ { A }$ , with PONG and the System I in Table 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            112,
+            812,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            325,
+            826,
+            368
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9b5d28fb9bca48003cb1736c6907f32325393b4180eee06c41a46bb7e85e7f23.jpg",
+        "table_caption": [
+            "Table 1: Systems used for profiling and testing. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>System I</td><td>System II</td><td>System III</td><td>System IV</td></tr><tr><td>Processor (Intel)</td><td>Xeon E5-2640v3 2.60 GHz 16 cores,dual socket</td><td>Core i-3820 3.60 GHz 8cores</td><td>HaswellE5-2698v3 2.30 GHz 16 cores</td><td>Xeon E5-2680v2 2.80 GHz 10 cores</td></tr><tr><td>GPU (NVIDIA)</td><td>Geforce Titan X (Maxwell)</td><td>GeForce 980 (Maxwell)</td><td>Tesla K80 (Kepler)</td><td>Quadro M6000 (Maxwell)</td></tr><tr><td>Software / Profilers</td><td colspan=\"4\">Python 3.5,CUDA 7.5 (I-II)/CUDA 8 (IV), CUDNN v5.1,TensorFlow r0.11 nvprof, nvvp</td></tr></table>",
+        "bbox": [
+            240,
+            382,
+            756,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "GPU utilization and DNN size. The fastest configuration ( $N _ { A } = 1 2 8$ , $N _ { P } = N _ { T } = 2 $ ) for System I in Table 1 has an average GPU utilization time of only $5 6 \\%$ , with average and peak occupancy of $7 6 \\%$ and $9 8 \\%$ , respectively.1 This suggests there is computational capacity for a larger network model. Therefore we profile GA3C on a series of deeper DNN architectures2 to evaluate this hypothesis. Figure 3 shows that TPS drops by only $7 \\%$ with a one-layer deeper DNN controller; at the same time, the ",
+        "bbox": [
+            174,
+            542,
+            419,
+            736
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f62139e12cba216383cb6e716092a4afc36ca48dea210c3242bea03fc52ee423.jpg",
+        "table_caption": [
+            "Table 2: PPS on different systems (Table 1), for small and large DNNs, with CPU and GPU utilization for GA3C. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"3\">PPS</td><td colspan=\"2\">Utilization (%)</td></tr><tr><td>System</td><td>DNN</td><td>A3C</td><td>GA3C</td><td>Speed up</td><td>CPU</td><td>GPU</td></tr><tr><td rowspan=\"5\">System I</td><td>small</td><td>352</td><td>1361</td><td>4×</td><td>32</td><td>56</td></tr><tr><td>large, stride 4</td><td>113</td><td>1271</td><td>11×</td><td>27</td><td>68</td></tr><tr><td>large,stride 3</td><td>97</td><td>1206</td><td>12×</td><td>27</td><td>77</td></tr><tr><td>large, stride 2</td><td>43</td><td>874</td><td>20×</td><td>26</td><td>82</td></tr><tr><td>large, stride 1</td><td>11</td><td>490</td><td>45×</td><td>17</td><td>90</td></tr><tr><td rowspan=\"2\">System II</td><td>small</td><td>116</td><td>728</td><td>6×</td><td>62</td><td>33</td></tr><tr><td>large, stride 1</td><td>12</td><td>336</td><td>28×</td><td>49</td><td>78</td></tr><tr><td rowspan=\"2\">System III</td><td>small</td><td>300</td><td>1248</td><td>4×</td><td>31</td><td>60</td></tr><tr><td>large, stride 1</td><td>38</td><td>256</td><td>6×</td><td>17</td><td>82</td></tr></table>",
+        "bbox": [
+            434,
+            549,
+            821,
+            684
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "average GPU utilization and occupancy increase by approximately $1 2 \\%$ and $0 . 5 \\%$ , respectively. The $7 \\%$ drop in TPS is the consequence of the increased depth which forces an additional serial computational on the GPU (and therefore a $1 2 \\%$ increase in its utilization). The negligible $0 . 5 \\%$ increase in occupancy is likely explained by an efficient management of the computational resources by cuDNN; there is still room available to run additional parallel tasks (or, in other words, a wider DNN) at minimal cost. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ad0b179398676c633b7b47258fc7efaa5686750f4af3d0d5760ee3d128420c30.jpg",
+        "image_caption": [
+            "Figure 5: Effect of PPS on convergence speed. For each game, four different settings of GA3C are shown, all starting from the same DNN initialization. Numbers on the right show the cumulative number of frames played among all agents for each setting over the course of 3 hours. Configurations playing more frames converge faster. The dynamic configuration method is capable of catching up with the optimal configuration despite starting with a sub-optimal setting, $N _ { T } = N _ { P } = N _ { A } = 1$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            87,
+            821,
+            268
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "By reducing the stride of the first layer of the DNN (in addition to adding a convolutional layer), we scale DNN size with finer granularity, and we compare FPS between GA3C and our CPU implementation of A3C. Table 2 shows the speed up provided by GA3C increases as the DNN grows. This is mainly due to increasing GPU utilization, as reported in Table 2. With the largest DNN, our CPU implementation achieves $\\mathrm { T P S } \\approx 1 1$ , which is approximately $4 5 \\times$ slower than GA3C. This behavior is consistent across different systems, as shown in Table 2, where the CPU implementation of A3C using the largest DNN with stride 1 is $7 \\times$ (System III) to $3 2 \\times$ (System I) slower than the small network. Scaling with DNN size is more favorable on a GPU, with a slow down factor of $4 . 9 \\times$ in the worst case (System III) and $2 . 2 \\times$ in the best case (System II). Further, more recent GPUs (Maxwell architecture) scale better ( $2 . 2 \\times$ and $2 . 7 \\times$ slow down for Systems I and II) than older GPUs $( 4 . 8 \\times$ slow down for the Kepler architecture, System III). ",
+        "bbox": [
+            174,
+            376,
+            825,
+            530
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generally speaking, for large DNNs, maximum TPS and FPS are achieved by intensively using the GPU for prediction and training, while the CPU runs the simulation environment and remains mostly idle. In practice, this allows experimenting with larger architectures, which may be particularly important for real world problems, e.g. robotics or autonomous driving (Lillicrap et al., 2015). Moreover, the idle CPU represents an additional computational resource, but such investigation is beyond the scope of this paper. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            621
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Significant latency. Profiling on System I in Table 1 reveals that the average time spent by an agent waiting for a prediction call to be completed is $1 0 8 \\mathrm { m s }$ , only $1 0 \\%$ of which is taken by the GPU inference. The remaining $9 0 \\%$ is overhead spent accumulating the batch and calling the prediction function in Python. Similarly, for training we find that of the average 11.1ms spent performing a DNN update, $5 9 \\%$ is overhead. This seems to suggest that a more optimized implementation (possibly based on a low level language like $\\mathrm { C } { + + }$ ) may reduce these overheads, but this investigation remains for future work. ",
+        "bbox": [
+            173,
+            632,
+            825,
+            731
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Manually balancing components. Agents, predictors, and trainers all share the GPU as a resource; thus balance is important. Figure 3 shows the top three performing configurations of $N _ { P }$ and $N _ { T }$ for different numbers of agents, $N _ { A }$ , with System I in Table 1. A $1 4 \\%$ drop in TPS is exhibited between the best and worst depicted configuration, despite the exclusion of all but the top three performers for each number of agents. The best results have 4 or fewer predictor threads, seemingly preventing batches from becoming too small. The $N _ { P } : N _ { T }$ ratios for top performers tend to be $1 : 2 , 1 : 1$ , or $2 : 1$ , whereas higher ratios such as $1 : 8$ and $1 : 4$ are rarely successful, likely due to the implicit dependence of training on prediction speed. However, if the training queue is too full, training calls take more GPU time, thereby throttling prediction speed. This is further confirmed by our experimental finding that TPS and PPS plots track closely. Figure 4 shows training queue size and prediction batch size for the top configurations. In all cases, the training queue stabilizes well below its maximum capacity. Additionally, the fastest configuration has one of the largest average prediction batch sizes, yielding higher GPU utilization. ",
+        "bbox": [
+            173,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cac8ccf9790339313c09c129f613240d5461f5b12660fa7fa50589d1552661b3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"8\">Atari Game Scores</td><td colspan=\"2\">Attributes</td></tr><tr><td></td><td>AMIDAR BOXING CENTIPEDE</td><td></td><td></td><td>NAME THISGAME</td><td>PACMANPONG</td><td></td><td>QBERT SEAQUEST</td><td>UP-DOWN</td><td>Time</td><td>System</td></tr><tr><td>Human</td><td>1676</td><td>10</td><td>10322</td><td>6796</td><td>15375</td><td>16 12085</td><td>40426</td><td>9896</td><td></td><td>1</td></tr><tr><td>Random</td><td>6</td><td>-2</td><td>1926</td><td>198</td><td>1748</td><td>-18 272</td><td>216</td><td>533</td><td></td><td>1</td></tr><tr><td>A3C</td><td>264</td><td>60</td><td>3756</td><td>10476</td><td>654</td><td>6 15149</td><td>2355</td><td>74706</td><td>4 days</td><td>CPU</td></tr><tr><td>GA3C</td><td>218</td><td>92</td><td>7386</td><td>5643</td><td>1978</td><td>18 14966</td><td>1706</td><td>8623</td><td>1day</td><td>GPU</td></tr></table>",
+        "bbox": [
+            176,
+            102,
+            821,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Average scores on a subset of Atari games achieved by: a random player (Mnih et al., 2015); a human player (Mnih et al., 2015); A3C after four days of training on a CPU (Mnih et al., 2016); and GA3C after one day of training. For GA3C, we measured the average score on 30 games, each initialized with a random seed. ",
+        "bbox": [
+            173,
+            213,
+            825,
+            268
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 EFFECT OF TPS ON LEARNING SPEED ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            296,
+            478,
+            311
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The beneficial effect of an efficient configuration on the training speed is shown in Figure 5. Training with a suboptimal configuration (e.g. $N _ { P } = N _ { T } = N _ { A } = 1$ or $N _ { P } = N _ { T } = 1$ , $N _ { A } = 1 6$ ) leads to a severe underutilization of the GPU, a low TPS, and a slow training process. Using the optimal configuration achieves a much higher score in a shorter period of time, mainly driven by playing more frames, i.e. collecting more experiences, in the same amount of time. ",
+        "bbox": [
+            174,
+            323,
+            825,
+            392
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mnih et al. (2016) note that asynchronous methods generally achieve significant speedups from using a greater number of agents, and even report superlinear speedups for asynchronous one-step Q-learning. It is worth noting that optimal configurations for GA3C generally employ a much higher number of agents compared to the CPU counterpart, e.g. the optimal configuration for System I in Table 1 uses 128 agents. This suggests that GPU implementations of asynchronous learning methods may benefit from both a higher TPS and from collecting experiences from a wider number of agents. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            483
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The learning curve for GA3C with dynamic configuration (Figure 5) tracks closely with the learning curve of the optimal configuration. The total number of frames played is generally slightly lower over the same time due to the search procedure overhead: the configuration is changed once every minute, tending to oscillate around the optimal configuration. Notice also that, in Figure 5, the starting point of the dynamic configuration is $N _ { T } = N _ { P } = N _ { A } = 1$ , which is much slower than the optimal configuration. But scoring performance is nearly identical, indicating that the dynamic method may ease the burden of configuring GA3C on a new system. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3 compares scores achieved by A3C on the CPU (as reported in (Mnih et al., 2016)) with the best agent trained by our TensorFlow implementation of GA3C. Unfortunately, a direct speed comparison is infeasible without either the original source code or the average number of frames or training updates per second. However, results in this table do show that after one day of training our open-source implementation can achieve similar scores to A3C after four days of training. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows typical training curves for GA3C on several Atari games as a function of wallclock time. When compared to the training curves reported in Mnih et al. (2016), GA3C shows faster convergence toward the maximum score in a shorter time for certain games such as PONG, convergence towards a better score in a larger amount of time (e.g. QBERT) or, for other games, a slower convergence rate (e.g. BREAKOUT). It has to be noted, however, that data reported by Mnih et al. (2016) are the average learning curves of the top five learners in a set of fifty learners, each with a different learning rate. On the other hand, in Figure 6, we are reporting three different runs for two (not essentially optimal) learning rates, fixed for all the games. This demonstrates some robustness of GA3C with respect to the choice of the learning rate, whereas it is also likely that better learning curves can be obtained using optimized learning rates. A deeper investigation on a large amount of data, potentially facilitated by our release of the GA3C code, may also reveal how peculiarities of each game differently affect the convergence of A3C and GA3C, but this goes beyond the scope of this paper. ",
+        "bbox": [
+            173,
+            671,
+            825,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 POLICY LAG, LEARNING STABILITY AND CONVERGENCE SPEED ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            871,
+            651,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One of the main differences between GA3C and A3C is the asynchronous computation of the forward step (policy $\\pi$ ) and the gradients (Eq. (4)) used to update the DNN. Delays between these two operations may introduce noise in the gradients, making the learning process unstable. We experimentally investigated the impact of this asynchrony on the learning process to determine if a synchronization mechanism, which may negatively impact both PPS and TPS, can increase the stability of the algorithm. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c16b7d73245082b17a8e33dba0e2a6872587f179bdffd9c7e929b578017e41b.jpg",
+        "image_caption": [
+            "Figure 6: Training curves for GA3C on five Atari games. Each training has been performed three times for each of two learning rates (0.0003 and 0.0001) on System IV in Table 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            111,
+            810,
+            335
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/e18b30807e242a8195c95e4286f18a813a54e1147dbd6401fa2dfaaca1809132.jpg",
+        "image_caption": [
+            "Figure 7: Training GA3C with a range of minimum training batch sizes. Increasing the minimum training batch size from 1 to 40 reduces the effect of the policy lag (delay $k$ in Eq. (4)), leading to convergence that is faster and more stable. GA3C achieved the overall best results with a minimum batch size between 20 and 40. Increasing beyond this threshold dramatically reduces convergence speed for some games, especially those inclined to unstable learning curves. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            395,
+            821,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            623,
+            825,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In GA3C, each agent generally pushes $t _ { m a x }$ experiences in the training queue. By default, trainers collect a batch of experiences from a single agent from the training queue and send the batch to the GPU to compute gradients, as in Eq. (5). Each time a trainer updates the DNN weights, the remaining experiences in the training queue are no longer in sync with the DNN model. This situation becomes worse when the average length of the training queue is large. ",
+        "bbox": [
+            174,
+            686,
+            823,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "By allowing larger training batch sizes, we reduce the number of DNN updates per second (TPS), and consequently diminish the effect of the delay $k$ in Eq. (5). In this way we increase the chance that the collected experiences and the computed gradients are in sync, which improves the stability. Notice that, even if the TPS is lower, the average magnitude of the updates is indeed larger, since we sum the gradients computed over the training batch. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this setting, the optimal training batch size compromises among TPS, the average gradient step magnitude and the training stability. Another factor to be considered is that batching training data potentially leverages the GPU computational capability better by reducing the time devoted to compute the DNN updates while increasing the GPU occupancy during this phase. This gives more GPU time to the predictors, potentially increasing the PPS. However, this advantage tends to disappear when the training batch size is too large and predictors stay idle while the DNN update is computed. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 compares convergence curves when no minimum size for training batch is compulsory (the default GA3C implementation where gradient updates are computed on a single agent’s batch) and when a minimum training batch size is enforced (combining multiple agent batches into a single gradient update). In the latter case, trainers collect experiences from multiple agents at the same time from the training queue and send them to the GPU for computation of gradients as in Eq. (5). Up to a certain batch size (between 20 and 40, in our experiments), increasing the training batch size stabilizes the learning procedure and generally leads to faster convergence. Some games such as PONG indeed do not suffer from this instability, and the effect of the minimum batch size is less evident in this case. We speculate that a careful selection of the learning rate combined with the proper minimum training batch size may lead to even faster convergence. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            265,
+            318,
+            281
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "By investigating the computational aspects of our hybrid CPU/GPU implementation of GA3C, we achieve a significant speed up with respect to its CPU counter part. This comes as a result of a flexible system capable of finding a reasonable allocation of the available computational resources. Our approach allows producing and consuming training data at the maximum pace on different systems, or to adapt to temporal changes of the computational load on one system. Despite the fact that we analyze A3C only, most of our findings can be applied to similar RL asynchronous algorithms. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            396
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We believe that the analysis of the computational aspects of RL algorithms may be a consistent theme in RL in the future, motivating further studies such as this one. The potential benefits of such investigation goes well beyond the computational aspects. For instance, we demonstrate that GA3C scales with the size of the DNN much more efficiently than our CPU implementation of A3C, thus opening the possibility to explore the use of large DNN controllers to solve real world RL problems. ",
+        "bbox": [
+            176,
+            404,
+            825,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "By open sourcing GA3C (see https://github.com/NVlabs/GA3C), we allow other researchers to further explore this space, investigate in detail the computational aspects of deep RL algorithms, and test new algorithmic solutions, including strategies for the combined utilization of the CPU and GPU computational resources. ",
+        "bbox": [
+            176,
+            479,
+            823,
+            535
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            555,
+            326,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We thank Prof. Roy H. Campbell for partially supporting this work. ",
+        "bbox": [
+            174,
+            579,
+            616,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            617,
+            285,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´ Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´ berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org. ",
+        "bbox": [
+            176,
+            670,
+            825,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "M. G. Bellemare, S. Srinivasan, G. Ostrovski, T. Schaul, D. Saxton, and R. Munos. Unifying CountBased Exploration and Intrinsic Motivation. ArXiv e-prints, June 2016. ",
+        "bbox": [
+            173,
+            810,
+            821,
+            838
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016. ",
+        "bbox": [
+            171,
+            853,
+            825,
+            881
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "G. Lample and D. Singh Chaplot. Playing FPS Games with Deep Reinforcement Learning. ArXiv e-prints, September 2016. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "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. CoRR, abs/1509.02971, 2015. URL http://arxiv.org/abs/1509.02971. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "V. Mnih, A. Puigdomenech Badia, M. Mirza, A. Graves, T. P. Lillicrap, T. Harley, D. Silver, and K. Kavukcuoglu. Asynchronous Methods for Deep Reinforcement Learning. ArXiv preprint arXiv:1602.01783, 2016. ",
+        "bbox": [
+            176,
+            155,
+            821,
+            196
+        ],
+        "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, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 02 2015. URL http://dx.doi.org/10.1038/ nature14236. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            290
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arun Nair, Praveen Srinivasan, Sam Blackwell, Cagdas Alcicek, Rory Fearon, Alessandro De Maria, Vedavyas Panneershelvam, Mustafa Suleyman, Charles Beattie, Stig Petersen, Shane Legg, Volodymyr Mnih, Koray Kavukcuoglu, and David Silver. Massively parallel methods for deep reinforcement learning. CoRR, abs/1507.04296, 2015. URL http://arxiv.org/abs/ 1507.04296. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            369
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. CoRR, abs/1511.05952, 2015. URL http://arxiv.org/abs/1511.05952. ",
+        "bbox": [
+            171,
+            378,
+            823,
+            409
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Christopher J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with deep neural networks and tree search. Nature, 529:484–503, 2016. URL http: //www.nature.com/nature/journal/v529/n7587/full/nature16961.html. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            501
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, Cambridge, MA, USA, 1st edition, 1998. ISBN 0262193981. ",
+        "bbox": [
+            176,
+            510,
+            821,
+            539
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 4(2), 2012. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            589
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. CoRR, abs/1509.06461, 2015. URL http://arxiv.org/abs/1509.06461. ",
+        "bbox": [
+            173,
+            598,
+            823,
+            628
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Nando de Freitas, and Marc Lanctot. Dueling network architectures for deep reinforcement learning. CoRR, abs/1511.06581, 2015. URL http://arxiv.org/abs/1511. 06581. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            679
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            171,
+            689,
+            823,
+            717
+        ],
+        "page_idx": 11
+    }
+]

parse/train/rkjZ2Pcxe/rkjZ2Pcxe.md

@@ -0,0 +1,333 @@
+# ADDING GRADIENT NOISE IMPROVES LEARNING FOR VERY DEEP NETWORKS
+
+Arvind Neelakantan∗ †, Luke Vilnis∗ † College of Information and Computer Sciences University of Massachusetts Amherst {arvind,luke}@cs.umass.edu
+
+Quoc V. Le, Lukasz Kaiser, Karol Kurach Google Brain {qvl,lukaszkaiser,kkurach}@google.com
+
+Ilya Sutskever†   
+OpenAI   
+{ilyasu}@openai.com   
+James Martens   
+University of Toronto   
+{jmartens}@cs.toronto.edu
+
+# ABSTRACT
+
+Deep feedforward and recurrent networks have achieved impressive results in many perception and language processing applications. Recently, more complex architectures such as Neural Turing Machines and Memory Networks have been proposed for tasks including question answering and general computation, creating a new set of optimization challenges. In this paper, we explore the lowoverhead and easy-to-implement optimization technique of adding annealed Gaussian noise to the gradient, which we find surprisingly effective when training these very deep architectures. Unlike classical weight noise, gradient noise injection is complementary to advanced stochastic optimization algorithms such as Adam and AdaGrad. The technique not only helps to avoid overfitting, but also can result in lower training loss. We see consistent improvements in performance across an array of complex models, including state-of-the-art deep networks for question answering and algorithm learning. We observe that this optimization strategy allows a fully-connected 20-layer deep network to escape a bad initialization with standard stochastic gradient descent. We encourage further application of this technique to additional modern neural architectures.
+
+# 1 INTRODUCTION
+
+Deep neural networks have shown remarkable success in diverse domains including image recognition (Krizhevsky et al., 2012), speech recognition (Hinton et al., 2012) and language processing applications (Sutskever et al., 2014; Bahdanau et al., 2014). This broad success comes from a confluence of several factors. First, the creation of massive labeled datasets has allowed deep networks to demonstrate their advantages in expressiveness and scalability. The increase in computing power has also enabled training of far larger networks with more forgiving optimization dynamics (Choromanska et al., 2015). Additionally, architectures such as convolutional networks (LeCun et al., 1998) and long short-term memory networks (Hochreiter & Schmidhuber, 1997) have proven to be easier to optimize than classical feedforward and recurrent models. Finally, the success of deep networks is also a result of the development of simple and broadly applicable learning techniques such as dropout (Srivastava et al., 2014), ReLUs (Nair & Hinton, 2010), gradient clipping (Pascanu et al., 2013; Graves, 2013), optimization algorithms and weight initialization strategies (Glorot & Bengio, 2010; Sutskever et al., 2013; He et al., 2015).
+
+Recent work has aimed to push neural network learning into more challenging domains, such as question answering or program induction. These more complicated problems demand more complicated architectures (e.g. Graves et al. (2014); Sukhbaatar et al. (2015)), thereby posing new optimization challenges. While there is very active research in improving learning in deep feedforward and recurrent networks, such as layer-wise deep supervision (Lee et al., 2015), novel activation functions (Maas et al., 2013), initialization schemes (He et al., 2015), and cell architectures (Cho et al., 2014a; Yao et al., 2015), these are not always sufficient or applicable in networks with complex structure over the latent variables. In order to achieve good performance, researchers have reported the necessity of additional techniques such as explicit labeling of latent variables (Weston et al., 2014), relaxing weight-tying constraints (Kaiser & Sutskever, 2016), warmstarts (Peng et al., 2015), random restarts, and the removal of certain activation functions in early stages of training (Sukhbaatar et al., 2015).
+
+The recurring theme is that commonly-used optimization techniques are not always sufficient to robustly optimize the models of interest. In this work, we explore a simple technique of adding annealed Gaussian noise to the gradient, which we find to be surprisingly effective in training deep neural networks with stochastic gradient descent. While there is a long tradition of adding random weight noise in neural networks, it has been under-explored in the optimization of modern deep architectures. Furthermore, although weight and gradient noise are equivalent when using standard SGD updates, the use of adaptive and momentum based stochastic optimizers such as Adam and AdaGrad (Duchi et al., 2011; Kingma & Ba, 2014) breaks this equivalence, allowing the noise to effectively adapt to the curvature of the optimization landscape. We find this property to be important when optimizing the most complex models.
+
+While there exist theoretical and empirical results on the regularizing effects of conventional stochastic gradient descent, especially for the minimization of convex losses (Bousquet & Bottou, 2008), we find that in practice the added noise can actually help us achieve lower training loss by encouraging active exploration of parameter space. This exploration proves especially necessary and fruitful when optimizing neural network models containing many layers or complex latent structures. For neural network learning, it has long been known that the noise in the stochastic gradient can help to escape saddle points and local optima (Bottou, 1992). For this reason, neural network practitioners sometimes avoid overly-large mini-batch sizes to achieve the best results. We find that the Gaussian noise added in our technique is complementary to the noisy stochastic gradient, and a combination of Gaussian noise and tuned mini-batch sizes is necessary for the most complex models.
+
+The main contribution of this work is to demonstrate the broad applicability of this simple method to the training of many complex modern neural architectures. To our knowledge, neither the exponentially decayed noise schedule nor the black box combination of injected gradient noise with adaptive optimizers have been used before in the training of deep networks. We consistently see improvements from Gaussian gradient noise when optimizing a wide variety of models, including very deep fully-connected networks, and special-purpose architectures for question answering and algorithm learning. For example, this method allows us to escape a poor initialization and successfully train a 20-layer rectifier network on MNIST with standard gradient descent. It also enables a $72 \%$ relative reduction in error in question answering, and doubles the number of accurate binary multiplication models learned across 7,000 random restarts. Gradient noise also possesses attractive robustness properties. We examine only two distinct settings of the noise variance hyperparameter in total across all experiments. We additionally observe that in cases where gradient noise fails to improve over other learning techniques, it rarely significantly hurts a models ability to generalize.
+
+We hope that practitioners will see similar improvements in their own research by adding this simple technique, implementable in a single line of code, to their repertoire.
+
+# 2 RELATED WORK
+
+Adding random noise to the weights, inputs, or hidden units has been a known technique amongst neural network practitioners for many years (e.g. Murray & Edwards; An (1996)). However, the benefits of gradient noise have not been fully explored with modern deep networks nor combined with advanced stochastic optimization techniques, which allow the noise to take into account the geometry of the optimization problem and the statistical manifold.
+
+Weight noise (Steijvers, 1996) and adaptive weight noise (Graves, 2011; Blundell et al., 2015), which usually maintains a Gaussian variational posterior over network weights, similarly aim to improve learning by added noise during training. In adaptive weight noise, an extra set of parameters for the variance must be maintained. This adaptation is different than our use of an adaptive optimizer, as it aims to capture an accurate estimate of uncertainty in the weights and not guide the exploration of parameter space. They differ from our proposed method in that the noise is not annealed and at convergence will be non-zero.
+
+Similarly, the technique of dropout (Srivastava et al., 2014) randomly sets groups of hidden units to zero at train time to improve generalization in a manner similar to ensembling.
+
+An annealed Gaussian gradient noise schedule was used to train the highly non-convex Stochastic Neighbor Embedding model in Hinton & Roweis (2002). The gradient noise schedule that we found to be most effective is very similar to the Stochastic Gradient Langevin Dynamics (SGLD) algorithm of Welling & Teh (2011), who use gradients with added noise to accelerate MCMC inference for logistic regression and independent component analysis models. This use of gradient information in MCMC sampling for machine learning to allow faster exploration of state space was previously proposed by Neal (2011). However, standard SGLD analysis does not allow for the use of adaptive optimizers or momentum, limiting the efficiency for very pathological optimization landscapes. Stochastic Gradient Riemannian Langevin Dynamics (Patterson & Teh, 2013) adapts the gradient and noise using the Fisher information matrix, effectively following trajectories along the same manifold as the natural gradient (Amari, 1998), but is applied only to models for which that matrix is tractable to estimate in closed form.
+
+Various optimization techniques have been proposed to improve the training of neural networks. Most notable is the use of momentum (Polyak, 1964; Sutskever et al., 2013; Kingma & Ba, 2014) or adaptive learning rates (Duchi et al., 2011; Dean et al., 2012; Zeiler, 2012). These methods are normally developed to provide good convergence rates for the convex setting, and then heuristically applied to nonconvex problems. Similarly, batch normalization and related methods (Ioffe & Szegedy, 2015; Arpit et al., 2016; Salimans & Kingma, 2016), natural gradient descent (Amari, 1998; Desjardins et al., 2015), and K-FAC (Martens & Grosse, 2015) can all be seen as various preconditioning methods using approximations to the inverse Fisher information of the neural network. While there has been some difficulty in combining batch normalization-type algorithms with recurrent networks (Laurent et al., 2015), recent work has had success in this area (Cooijmans et al., 2016; Ba et al., 2016).
+
+Injecting noise in the gradient can be combined with any of the above methods, and can be seen as a complementary technique especially suitable for nonconvex problems. By adding additional artificial stochasticity to the gradient, this technique allows the model more chances to escape local minima or saddle-points (see a similar argument in Bottou (1992)), or to traverse quickly through the “transient” plateau phase of early learning (see a similar analysis for momentum in Sutskever et al. (2013)). This is born out empirically in our observation that adding gradient noise can actually result in lower training loss. In this sense, we suspect adding gradient noise is similar to simulated annealing (Kirkpatrick et al., 1983) which exploits random noise to explore complex optimization landscapes. This can be contrasted with well-known benefits of stochastic gradient descent as a learning algorithm (Robbins & Monro, 1951; Bousquet & Bottou, 2008), where both theory and practice have shown that the noise induced by the stochastic process aids generalization by reducing overfitting.
+
+Recently, there has been a surge in research examining the use of gradient and weight noise when training deep neural networks. Mobahi (2016) present an optimization technique for recurrent networks that applies an annealed Gaussian kernel smoothing method to the loss function, of which annealed weight noise is a Monte Carlo estimator. Li et al. (2016) present a version of SGLD that incorporates both Gaussian noise and adaptively estimated learning rates (but no momentum term). Though significantly more complex than our proposed method, the most similar work is the Santa algorithm of Chen et al. (2016). Santa combines SGLD with adaptive learning rates and adaptive per-coordinate momentum parameters, and shows that the scheme can approach global optima of the objective function under certain assumptions.
+
+# 3 METHOD
+
+We consider a simple technique of adding time-dependent Gaussian noise to the gradient $g$ at every training step $t$ :
+
+$$
+g _ { t } \gets g _ { t } + N ( 0 , \sigma _ { t } ^ { 2 } )
+$$
+
+The gradient $g _ { t }$ is then used to update the weights $\theta _ { t }$ as if it were the original gradient of the loss function, and can be used with any stochastic optimization algorithm. Our experiments indicate that adding annealed Gaussian noise by decaying the variance often works better and more robustly than using fixed Gaussian noise (see Section 4.6). We use a schedule inspired from Welling & Teh (2011) in our experiments and take:
+
+$$
+\sigma _ { t } ^ { 2 } = \frac { \eta } { ( 1 + t ) ^ { \gamma } }
+$$
+
+We examine only 2 distinct noise hyperparameter configurations in our experiments, selecting $\eta$ from $\{ 0 . 0 1 , 1 . 0 \}$ and setting $\gamma = 0 . 5 5$ in all experiments. We believe this shows that annealed gradient noise is robust to minimal tuning. For example, in the experiments on Neural Programmer and Neural GPUs, we tried only a single configuration of noise parameters, simply setting $\eta = 1 . 0$ and tuning only the model hyperparameters as normal.
+
+# 4 EXPERIMENTS
+
+In the following experiments, we examine the effect of gradient noise on deep networks for MNIST digit classification, and consider a variety of complex neural network architectures: EndTo-End Memory Networks (Sukhbaatar et al., 2015) and Neural Programmer (Neelakantan et al., 2016) for question answering, Neural Random Access Machines (Kurach et al., 2016) and Neural GPUs (Kaiser & Sutskever, 2016) for algorithm learning. The models and results are described as follows.
+
+# 4.1 DEEP FULLY-CONNECTED NETWORKS
+
+For our first set of experiments, we examine the impact of adding gradient noise when training a very deep fully-connected network on the MNIST handwritten digit classification dataset (LeCun et al., 1998). Our network is deep: it has 20 hidden layers, with each layer containing 50 hidden units, posing a significant optimization and generalization problem. We use the ReLU activation function (Nair & Hinton, 2010).
+
+In this experiment, we train with SGD without momentum, using the fixed learning rates of 0.1 and 0.01. Unless otherwise specified, the weights of the network are initialized from a Gaussian with mean zero, and standard deviation of 0.1, which we call Simple Init. When adding gradient noise, we tried both settings of the variance detailed in Section 3, and found that decaying variance according to the schedule in Equation (1) with $\eta = 0 . 0 1$ worked best.
+
+The results of our experiment are in Table 1. When trained from Simple Init we can see that adding noise to the gradient helps in achieving higher average and best accuracy over 20 runs using each learning rate for a total of 40 runs (Table 1, Experiment 1). We note that the average is closer to $50 \%$ because the small learning rate of 0.01 usually gives very slow convergence. We also try our approach on a more shallow network of 5 layers, but adding noise does not improve the training in that case.
+
+Next, we experiment with clipping the gradients with two threshold values: 100 and 10 (Table 1, Experiment 2, and 3). Here, we find training with gradient noise is insensitive to the gradient clipping values. By tuning the clipping threshold, it is possible to get comparable accuracy without noise for this problem.
+
+In our fourth and fifth experiments (Table 1, Experiment 4), we use two analytically-derived ReLU initialization techniques (which we term Good Init 1 and 2) recently-proposed by Sussillo (2014) and He et al. (2015), and find that adding gradient noise does not help. Previous work has found that stochastic gradient descent with carefully tuned initialization, momentum, learning rate, and learning rate decay can optimize such extremely deep fully-connected ReLU networks (Srivastava et al., 2015). It would be harder to find such a robust initialization technique for the more complex heterogeneous architectures considered in later sections. Accordingly, we find in later experiments (e.g., Section 4.3) that random restarts and the use of a momentum-based optimizer like Adam are not sufficient to achieve the best results in the absence of added gradient noise.
+
+To test how sensitive the methods are to poor initialization, in addition to the sub-optimal Simple Init, we run an experiment where all the weights in the neural network are initialized at zero. The results (Table 1, Experiment 5) show that if we do not add noise to the gradient, the networks fail to learn. If we add some noise, the networks can learn and reach $9 4 . 5 \%$ accuracy. While the pessimal performance of the noiseless model is unsurprising (initializing weights at 0 introduces symmetries that make gradient-descent impossible), it is interesting to note that gradient noise can overcome what is perhaps the canonical “bad initialization.”
+
+Experiment 1: Simple Init, No Gradient Clip   
+
+<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>Best Test Acc.</td><td rowspan=1 colspan=1>Avg. Test Acc.</td></tr><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>89.9%</td><td rowspan=1 colspan=1>43.1%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>52.7%</td></tr><tr><td rowspan=1 colspan=1>No Noise + Dropout</td><td rowspan=1 colspan=1>11.3%</td><td rowspan=1 colspan=1>10.8%</td></tr></table>
+
+Experiment 2: Simple Init, Gradient ${ \mathrm { C l i p } } = 1 0 0$   
+
+<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>90.0%</td><td rowspan=1 colspan=1>46.3%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>52.3%</td></tr></table>
+
+Experiment 3: Simple Init, Gradient ${ \mathrm { C l i p } } = 1 0$   
+
+<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>95.7%</td><td rowspan=1 colspan=1>51.6%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>97.0%</td><td rowspan=1 colspan=1>53.6%</td></tr></table>
+
+Experiment 4: Good Init $1 +$ Gradient Clip = 10   
+
+<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>97.4%</td><td rowspan=1 colspan=1>92.1%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>97.5%</td><td rowspan=1 colspan=1>92.2%</td></tr></table>
+
+Experiment 5: Good Init $^ { 2 + }$ Gradient Clip = 10   
+
+<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>97.4%</td><td rowspan=1 colspan=1>91.7%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>97.2%</td><td rowspan=1 colspan=1>91.7%</td></tr></table>
+
+Experiment 6: Bad Init (Zero Init) $^ +$ Gradient Clip = 10   
+Table 1: Average and best test accuracy on MNIST over 40 runs. Higher values are better.   
+
+<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>11.4%</td><td rowspan=1 colspan=1>10.1%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>94.5%</td><td rowspan=1 colspan=1>49.7%</td></tr></table>
+
+In summary, these experiments show that if we are careful with initialization and gradient clipping values, it is possible to train a very deep fully-connected network without adding gradient noise. However, if the initialization is poor, optimization can be difficult, and adding noise to the gradient is a good mechanism to overcome the optimization difficulty. Additionally, the noise need not be heavily tuned and rarely decreases performance.
+
+This set of results suggests that added gradient noise can be an effective mechanism for training complex networks. This is because it is more difficult to initialize the weights properly for these architectures. In the following, we explore the training of more complex models such as End-ToEnd Memory Networks and Neural Programmer, whose initialization is less well studied.
+
+# 4.2 END-TO-END MEMORY NETWORKS
+
+We test added gradient noise for training End-To-End Memory Networks (Sukhbaatar et al., 2015), an approach for question answering using deep networks. Memory Networks have been demonstrated to perform well on a relatively challenging toy question answering problem (Weston et al., 2015).
+
+In Memory Networks, the model has access to a context, a question, and is asked to predict an answer. Internally, the model has an attention mechanism which focuses on the right clue to answer the question. In the original formulation (Weston et al., 2015), Memory Networks were provided with additional supervision as to what pieces of context were necessary to answer the question. This was replaced in the End-To-End formulation by a latent attention mechanism implemented by a softmax over contexts. As this greatly complicates the learning problem, the authors implement a two-stage training procedure: First train the networks with a linear attention, then use those weights to warmstart the model with softmax attention.
+
+In our experiments with Memory Networks, we use the same model hyperparameter settings as Sukhbaatar et al. (2015), and we try both settings of the variance detailed in Section 3, finding $\eta = 0 . 0 1$ worked best for this task. This noise is added to the gradient after clipping.
+
+We set the number of training epochs to 200 because we would like to understand the behaviors of Memory Networks near convergence. We test the effect of gradient noise with the published two-stage training approach, and additionally with a one-stage approach where we train the networks with softmax attention and without warmstarting. Following the experimental protocol of Sukhbaatar et al. (2015), we take the model with lowest training error out of 10 random restarts. Results are reported in Table 2. We find some fluctuations during each run of the training, but the reported results reflect the typical gains obtained by adding random noise.
+
+We find that warmstarting does indeed help the networks. In all cases, adding random noise to the gradient also helps the network both in terms of training errors and validation errors, and never hurts. Added noise, however, is especially helpful for the training of End-To-End Memory Networks without the warmstarting stage.
+
+One-Stage Training   
+
+<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>With Noise</td></tr><tr><td rowspan=1 colspan=1>Train error:</td><td rowspan=1 colspan=1>10.5%</td><td rowspan=1 colspan=1>9.6%</td></tr><tr><td rowspan=1 colspan=1>Validation error:</td><td rowspan=1 colspan=1>19.5%</td><td rowspan=1 colspan=1>16.6%</td></tr></table>
+
+Two-Stage Training   
+Table 2: The effects of adding gradient noise to End-to-End Memory Networks. Lower values are better.   
+
+<table><tr><td rowspan=1 colspan=1>Train error:</td><td rowspan=1 colspan=1>6.2%</td><td rowspan=1 colspan=1>5.9%</td></tr><tr><td rowspan=1 colspan=1>Validation error:</td><td rowspan=1 colspan=1>10.9%</td><td rowspan=1 colspan=1>10.8%</td></tr></table>
+
+# 4.3 NEURAL PROGRAMMER
+
+Neural Programmer is a neural network architecture augmented with a small set of built-in arithmetic and logic operations that learns to induce latent programs. It is proposed for the task of question answering from tables (Neelakantan et al., 2016). Examples of operations on a table include the sum of a set of numbers, or the list of numbers greater than a particular value. Key to Neural Programmer is the use of “soft selection” to assign a probability distribution over the list of operations. This probability distribution weighs the result of each operation, and the cost function compares this weighted result to the ground truth. This soft selection, inspired by the soft attention mechanism of Bahdanau et al. (2014), allows for full differentiability of the model. Running the model for several steps of selection allows the model to induce a complex program by chaining the operations, one after the other. At convergence, the soft selection tends to become peaky (hard selection). Figure 1 shows the architecture of Neural Programmer at a high level.
+
+![](images/103af5e9384f10e63f4ef6686fe5aa03b123e3553d6760d47ab8ea34ba802dbb.jpg)  
+Figure 1: Neural Programmer, a neural network with built-in arithmetic and logic operations. At every time step, the controller selectes an operation and a data segment. Figure reproduced with permission from Neelakantan et al. (2016).
+
+In a synthetic table comprehension task, Neural Programmer takes a question and a table (or database) as input and the goal is to predict the correct answer. To solve this task, the model has to induce a program and execute it on the table. A major challenge is that the supervision signal is in the form of the correct answer and not the program itself. The model runs for a fixed number of steps, and at each step selects a data segment and an operation to apply to the selected data segment. Soft selection is performed at training time so that the model is differentiable, while at test time hard selection is employed.
+
+We examine only the noise configuration with $\eta = 1 . 0$ , and add noise to the gradient after clipping, optimizing all other hyperparameters of the model. The model is optimized with Adam (Kingma & Ba, 2014), which combines momentum and adaptive learning rates.
+
+For our first experiment, we train Neural Programmer to answer questions involving a single column of numbers. We use 72 different hyper-parameter configurations with and without adding annealed random noise to the gradients. We also run each of these experiments for 3 different random initializations of the model parameters and we find that only $1 / 2 1 6$ runs achieve $1 0 0 \%$ test accuracy without adding noise while $9 / 2 1 6$ runs achieve $1 0 0 \%$ accuracy when random noise is added. The 9 successful runs consisted of models initialized with all the three different random seeds, demonstrating robustness to initialization. We find that when using dropout (Srivastava et al., 2014) none of the 216 runs give $100 \%$ accuracy.
+
+We consider a more difficult question answering task where tables have up to five columns containing numbers. We also experiment on a task containing one column of numbers and another column of text entries. Table 3 shows the performance of adding noise vs. no noise on Neural Programmer.
+
+Question Answering Accuracy   
+
+<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>Dropout</td><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>With Noise</td></tr><tr><td rowspan=1 colspan=1>Five columns</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>95.3%</td><td rowspan=1 colspan=1>98.7%</td></tr><tr><td rowspan=1 colspan=1>Text entries</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>97.6%</td><td rowspan=1 colspan=1>98.8%</td></tr><tr><td rowspan=1 colspan=1>Five columns</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>97.4%</td><td rowspan=1 colspan=1>99.2%</td></tr><tr><td rowspan=1 colspan=1>Text entries</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>99.1%</td><td rowspan=1 colspan=1>97.3%</td></tr></table>
+
+Table 3: The effects of adding random noise to the gradient on Neural Programmer. Higher values are better. Adding random noise to the gradient always helps the model. When the models are applied to these more complicated tasks than the single column experiment, using dropout and noise together seems to be beneficial in one case while using only one of them achieves the best result in the other case.
+
+Figure 2 shows an example of the effect of adding random noise to the gradients in our experiment with 5 columns. The differences between the two models are much more pronounced than Table 3 indicates because that table reflects the results from the best hyperparameters. Figure 2 indicates a more typical training run.
+
+![](images/0a1e50a67d834ff2dfdac9f418a072266c4e7a59d8bd015eb741c661ea8cd996.jpg)  
+Figure 2: Noise Vs. No Noise in our experiment with 5 columns. The models trained with noise generalizes almost always better.
+
+In all cases, we see that added gradient noise improves performance of Neural Programmer. Its performance when combined with or used instead of dropout is mixed depending on the problem, but the positive results indicate that it is worth attempting on a case-by-case basis.
+
+# 4.4 NEURAL RANDOM ACCESS MACHINES
+
+We now conduct experiments with Neural Random-Access Machines (NRAM) (Kurach et al., 2016). NRAM is a model for algorithm learning that can store data, and explicitly manipulate and dereference pointers. NRAM consists of a neural network controller, memory, registers and a set of built-in operations. This is similar to the Neural Programmer in that it uses a controller network to compose built-in operations, but both reads and writes to an external memory. An operation can either read (a subset of) contents from the memory, write content to the memory or perform an arithmetic operation on either input registers or outputs from other operations. The controller runs for a fixed number of time steps. At every step, the model selects a “circuit” to be executed: both the operations and its inputs.
+
+These selections are made using soft attention (Bahdanau et al., 2014) making the model end-to-end differentiable. NRAM uses an LSTM (Hochreiter & Schmidhuber, 1997) controller. Figure 3 gives an overview of the model.
+
+![](images/94341ba07767fbb398d37953fef5a9fe3f4a1ce8f10de8bdda526db81385e635.jpg)  
+Figure 3: One timestep of the NRAM architecture with $R = 4$ registers and a memory tape. $m _ { 1 }$ , $m _ { 2 }$ and $m _ { 3 }$ are example operations built-in to the model. The operations can read and write from memory. At every time step, the LSTM controller softly selects the operation and its inputs. Figure reproduced with permission from Kurach et al. (2016).
+
+For our experiment, we consider a problem of finding the $k$ -th element’s value in a linked list. The network is given a pointer to the head of the linked list, and has to find the value of the $k$ -th element. Note that this is highly nontrivial because pointers and their values are stored at random locations in memory, so the model must learn to traverse a complex graph for $k$ steps.
+
+Because of this complexity, training the NRAM architecture can be unstable, especially when the number of steps and operations is large. We once again experiment with the decaying noise schedule from Equation (1), setting $\eta = 0 . 0 1$ . We run a large grid search over the model hyperparameters (detailed in Kurach et al. (2016)), and find the top 3 parameter settings separately for both noised and un-noised models. For each model, for each of these 3 settings, we try 100 different random initializations and look at the percentage of runs that give $1 0 0 \%$ accuracy across each one for training both with and without noise.
+
+As in our experiments with Neural Programmer, we find that adding the noise after gradient clipping is crucial. This is likely because the effect of random noise is washed away when gradients become too large. For models trained with noise we observed much better reproduce rates, which are presented in Table 4. Although it is possible to train the model to achieve $\bar { 1 } 0 0 \%$ accuracy without noise, it is less robust across multiple random restarts, with over $1 0 \mathrm { x }$ as many initializations leading to a correct answer when using noise.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>With Noise</td></tr><tr><td rowspan=1 colspan=1>Hyperparameter-1</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>5%</td></tr><tr><td rowspan=1 colspan=1>Hyperparameter-2</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>22%</td></tr><tr><td rowspan=1 colspan=1>Hyperparameter-3</td><td rowspan=1 colspan=1>3%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>Average</td><td rowspan=1 colspan=1>1.3%</td><td rowspan=1 colspan=1>11.3%</td></tr></table>
+
+Table 4: Percentage of successful runs on the $k$ -th element task. All tests were performed with the same set of 100 random initializations (seeds). Higher values are better.
+
+# 4.5 CONVOLUTIONAL GATED RECURRENT NETWORKS (NEURAL GPUS)
+
+Convolutional Gated Recurrent Networks (CGRN) or Neural GPUs (Kaiser & Sutskever, 2016) are a recently proposed model that is capable of learning arbitrary algorithms. CGRNs use a stack of convolution layers, unfolded with tied parameters like a recurrent network. The input data (usually a list of symbols) is first converted to a three dimensional tensor representation containing a sequence of embedded symbols in the first two dimensions, and zeros padding the next dimension. Then, multiple layers of modified convolution kernels are applied at each step. The modified kernel is a combination of convolution and Gated Recurrent Units (GRU) (Cho et al., 2014b). The use of convolution kernels allows computation to be applied in parallel across the input data, while the gating mechanism helps the gradient flow. The additional dimension of the tensor serves as a working memory while the repeated operations are applied at each layer. The output at the final layer is the predicted answer.
+
+The key difference between Neural GPUs and other architectures for algorithmic tasks (e.g., Neural Turing Machines (Graves et al., 2014)) is that instead of using sequential data access, convolution kernels are applied in parallel across the input, enabling the use of very deep and wide models. The model is referred to as Neural GPU because the input data is accessed in parallel. Neural GPUs were shown to outperform previous sequential architectures for algorithm learning on tasks such as binary addition and multiplication, by being able to generalize from much shorter to longer data cases.
+
+In our experiments, we use Neural GPUs for the task of binary multiplication. The input consists two concatenated sequences of binary digits separated by an operator token, and the goal is to multiply the given numbers. During training, the model is trained on 20-digit binary numbers while at test time, the task is to multiply 200-digit numbers. We add Gaussian noise with decaying variance according to the schedule in Equation (1) with $\eta = 1 . 0$ , to the gradient after clipping. The model is optimized using Adam (Kingma & Ba, 2014).
+
+Table 5 gives the results of a large-scale experiment using Neural GPUs with a 7290 grid search. The experiment shows that models trained with added gradient noise are more robust across many random initializations and parameter settings. As you can see, adding gradient noise both allows us to achieve the best performance, with the number of models with $< 1 \%$ error over twice as large as without noise. But it also helps throughout, improving the robustness of training, with more models training to higher error rates as well. This experiment shows that the simple technique of added gradient noise is effective even in regimes where we can afford a very large numbers of random restarts.
+
+Table 5: Number of successful runs on 7290 random trials. Higher values are better. The models are trained on length 20 and tested on length 200.   
+
+<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>Error&lt;1%</td><td rowspan=1 colspan=1>&lt;2%</td><td rowspan=1 colspan=1>&lt;3%</td><td rowspan=1 colspan=1>&lt;5%</td></tr><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>28</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>172</td><td rowspan=1 colspan=1>387</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>58</td><td rowspan=1 colspan=1>159</td><td rowspan=1 colspan=1>282</td><td rowspan=1 colspan=1>570</td></tr></table>
+
+# 4.6 DISCUSSION
+
+In this work we propose an annealed Gaussian gradient noise scheme for the optimization of complex neural networks. Our experiments show improvement from gradient noise on a variety of models. We conduct a small set of additional experiments below to examine the factors that make this technique successful, and report a failure mode.
+
+Annealed vs. fixed noise We use a single fixed decay value $\gamma = 0 . 5 5$ when applying Equation (1) in our experiments, inspired by Stochastic Gradient Langevin Dynamics, and recommend it as a default. We conduct several experiments to determine the importance of annealed vs. fixed noise added to the gradient. We find that for the End2End model, similar results can be achieved with fixed noise values, however requiring significantly more tuning (compared to trying only two different values of $\eta$ in our experiments with annealed noise). We achieve nearly identical results on the End2End experiment using a fixed noise value of $\eta = 0 . 0 0 1$ . We also experiment with fixed noise on the Neural Programmer and NRAM models, and find that they make a larger difference. For both models, we select fixed noise values log-uniformly from between $1 \mathrm { e } { - 4 }$ and 0.1 and optimize the other hyperparameters. Using 216 runs per variance setting, the best Neural Programmer models without annealing can achieve equivalent errors to the annealed models. However, only 5/216 achieve the best error compared to 9/216 for the model using annealing. For NRAM, using 180 runs per setting, fixed noise never achieves the perfect error of 0 that is achieved by the annealed model. While annealing shows the most benefit with the most complex models, we generally recommend it as a robust default that requires less hyperparameter tuning than fixed noise.
+
+Gaussian noise vs. gradient stochasticity We assert that gradient noise helps the model explore the optimization landscape, escaping saddle points and local minima. Analysis of SGD for neural networks suggests that the stochasticity of the gradient serves much the same purpose (Bottou, 1992). This suggests a strategy: add noise to the gradient by simply reducing the minibatch size, increasing the variance of the gradient estimator. While arguments based on SGLD and kernel smoothing provide evidence that the specific form of the Gaussian noise is important, we run a pair of small experiments. For both Neural Programmer and NRAM, we tried batch sizes of 10, 25, and 50 (50 being the value used in the best results). For NRAM, after 100 tasks at each batch size and no gradient noise, 2 tasks at batch size 50 converged to 0 error, 1 task at batch size 10, and none at batch size 25. For Neural Programmer, over 216 experiments at each batch size we see none of the models without gradient noise converge to the best error. These results are far worse than our results using added noise, indicating that merely lowering the batch size does not introduce the same sort of helpful stochasticity.
+
+Gradient noise vs. weight noise While weight noise is relatively well-known, it is not equivalent to gradient noise in the case of adaptive or momentum-based optimizers, which effectively adapt the noise to the curvature of the optimization landscape. Both Neural Programmer and NRAM are greatly helped in training by the use of the Adam algorithm for optimization. We find here, using the same experimental setup as when examining annealed vs. fixed noise, that the models fail to learn when adding noise directly to the weights. Even when using starting noise rates as low as $1 \mathrm { e } { - 6 }$ , with the usual annealing schedule, the models fail to train significantly, achieving $57 \%$ error for NRAM and $68 \%$ for Neural Programmer at the lowest. Importantly, these noise rates are on the same order as the adaptive learning rates. This indicates that the issue is not just the noise scale, but that the very poor conditioning of the loss functions makes it necessary to adapt the noise. Similar concerns motivated the development of very recent algorithms for preconditioned SGLD in the Bayesian setting (Li et al., 2016).
+
+Negative results While we see improvements on a large number of neural network architectures, we note a case where gradient noise does not improve over standard SGD. We conduct language modeling experiments on the Penn Treebank (Marcus et al., 1993), using the experimental setup and architecture from Zaremba et al. (2014). We report results using a 200-unit LSTM with dropout, but observe a similar lack of improvement from gradient noise when using models without dropout. We try the two proposed noise rates from Section (method) and find the best results using $\eta = 0 . 0 1$ are slightly worse than the noiseless model, achieving a perplexity of 98 rather than 95. By further lowering the noise parameter to $\eta = 0 . 0 0 1$ we are able to achieve the same perplexity as the baseline, but do not see improvement. While adding gradient noise does not help in this case, it is simple to try and does not significantly hurt the results.
+
+# 5 CONCLUSION
+
+In this paper, we demonstrate the effectiveness of adding noise to the gradient when training deep neural networks. We find that adding noise to the gradient helps optimization and generalization of complicated neural networks and is compatible with and complementary to other stochastic optimization methods. We suspect that the effects are pronounced for complex models because they have many saddle points.
+
+We believe that this surprisingly simple yet effective idea, essentially a single line of code, should be in the toolset of neural network practitioners when facing issues with training neural networks.
+
+# REFERENCES
+
+Shun-Ichi Amari. Natural gradient works efficiently in learning. Neural computation, 1998.
+
+Guozhong An. The effects of adding noise during backpropagation training on a generalization performance. Neural Computation, 1996.
+
+Devansh Arpit, Yingbo Zhou, Bhargava U Kota, and Venu Govindaraju. Normalization propagation: A parametric technique for removing internal covariate shift in deep networks. ICML, 2016.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. ICLR, 2014.
+
+Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. ICML, 2015.
+
+Leon Bottou. Stochastic gradient learning in neural networks. In ´ Neuro-N¨ımes, 1992.
+
+Olivier Bousquet and Leon Bottou. The tradeoffs of large scale learning. In ´ NIPS, 2008.
+
+Changyou Chen, David Carlson, Zhe Gan, Chunyuan Li, and Lawrence Carin. Bridging the gap between stochastic gradient mcmc and stochastic optimization, 2016.
+
+Kyunghyun Cho, Bart van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014a.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder-decoder for statistical machine translation. In EMNLP, 2014b.
+
+Anna Choromanska, Mikael Henaff, Michael Mathieu, G ¨ erard Ben Arous, and Yann LeCun. The ´ loss surfaces of multilayer networks. In AISTATS, 2015.
+
+Tim Cooijmans, Nicolas Ballas, Cesar Laurent, and Aaron Courville. Recurrent batch normalization. ´ arXiv preprint arXiv:1603.09025, 2016.
+
+Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In NIPS, 2012.
+
+Guillaume Desjardins, Karen Simonyan, Razvan Pascanu, and koray kavukcuoglu. Natural neural networks. In NIPS. 2015.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. JMLR, 2011.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proc. AISTATS, pp. 249–256, 2010.
+
+Alex Graves. Practical variational inference for neural networks. In NIPS, 2011.
+
+Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arxiv:1308.0850, 2013.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural Turing Machines. arXiv preprint arXiv:1410.5401, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. ICCV, 2015.
+
+Geoffrey Hinton and Sam Roweis. Stochastic neighbor embedding. In NIPS, 2002.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George Dahl, Abdel rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara Sainath, and Brian Kingsbury. Deep neural networks for acoustic modeling in speech recognition. Signal Processing Magazine, 2012.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 1997.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
+
+Lukasz Kaiser and Ilya Sutskever. Neural GPUs learn algorithms. In ICLR, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Scott Kirkpatrick, Mario P Vecchi, et al. Optimization by simulated annealing. Science, 1983.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, 2012.
+
+Karol Kurach, Marcin Andrychowicz, and Ilya Sutskever. Neural random-access machines. In ICLR, 2016.
+
+Cesar Laurent, Gabriel Pereyra, Phil ´ emon Brakel, Ying Zhang, and Yoshua Bengio. Batch normal- ´ ized recurrent neural networks. arXiv preprint arXiv:1510.01378, 2015.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 1998.
+
+Chen-Yu Lee, Saining Xie, Patrick W. Gallagher, Zhengyou Zhang, and Zhuowen Tu. Deeplysupervised nets. AISTATS, 2015.
+
+Chunyuan Li, Changyou Chen, David Carlson, and Lawrence Carin. Preconditioned stochastic gradient langevin dynamics for deep neural networks, 2016.
+
+Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. ICML, 2013.
+
+Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 1993.
+
+James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. arXiv preprint arXiv:1503.05671, 2015.
+
+Hossein Mobahi. Training recurrent neural networks by diffusion, 2016.
+
+Alan F Murray and Peter J Edwards. Synaptic weight noise during mlp learning enhances faulttolerance, generalization and learning trajectory.
+
+Vinod Nair and Geoffrey Hinton. Rectified linear units improve Restricted Boltzmann Machines. In ICML, 2010.
+
+Radford M Neal. MCMC using Hamiltonian dynamics. Handbook of Markov Chain Monte Carlo, 2011.
+
+Arvind Neelakantan, Quoc V. Le, and Ilya Sutskever. Neural Programmer: Inducing latent programs with gradient descent. In ICLR, 2016.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. Proc. ICML, 2013.
+
+Sam Patterson and Yee Whye Teh. Stochastic gradient riemannian langevin dynamics on the probability simplex. In NIPS, 2013.
+
+Baolin Peng, Zhengdong Lu, Hang Li, and Kam-Fai Wong. Towards neural network-based reasoning. arXiv preprint arxiv:1508.05508, 2015.
+
+Boris Teodorovich Polyak. Some methods of speeding up the convergence of iteration methods. USSR Computational Mathematics and Mathematical Physics, 1964.
+
+Herbert Robbins and Sutton Monro. A stochastic approximation method. The annals of mathematical statistics, 1951.
+
+Tim Salimans and Diederik P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. 2016.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014.
+
+Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Training very deep networks. ¨ NIPS, 2015.
+
+Mark Steijvers. A recurrent network that performs a context-sensitive prediction task. In CogSci, 1996.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. In NIPS, 2015.
+
+David Sussillo. Random walks: Training very deep nonlinear feed-forward networks with smart initialization. CoRR, 2014.
+
+Ilya Sutskever, James Martens, George Dahl, and Geoffrey Hinton. On the importance of initialization and momentum in deep learning. In ICML, 2013.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In NIPS, 2014.
+
+Max Welling and Yee Whye Teh. Bayesian learning via stochastic gradient Langevin dynamics. In ICML, 2011.
+
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint arXiv:1410.3916, 2014.
+
+Jason Weston, Antoine Bordes, Sumit Chopra, and Tomas Mikolov. Towards AI-complete question answering: a set of prerequisite toy tasks. In ICML, 2015.
+
+Kaisheng Yao, Trevor Cohn, Katerina Vylomova, Kevin Duh, and Chris Dyer. Depth-gated recurrent neural networks. arXiv preprint arXiv:1508.03790, 2015.
+
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. CoRR, 2014.
+
+Matthew D Zeiler. Adadelta: An adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012.

parse/train/rkjZ2Pcxe/rkjZ2Pcxe_content_list.json

@@ -0,0 +1,1814 @@
+[
+    {
+        "type": "text",
+        "text": "ADDING GRADIENT NOISE IMPROVES LEARNING FOR VERY DEEP NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            767,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Arvind Neelakantan∗ †, Luke Vilnis∗ † College of Information and Computer Sciences University of Massachusetts Amherst {arvind,luke}@cs.umass.edu ",
+        "bbox": [
+            183,
+            170,
+            495,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Quoc V. Le, Lukasz Kaiser, Karol Kurach Google Brain {qvl,lukaszkaiser,kkurach}@google.com ",
+        "bbox": [
+            183,
+            247,
+            545,
+            290
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever†   \nOpenAI   \n{ilyasu}@openai.com   \nJames Martens   \nUniversity of Toronto   \n{jmartens}@cs.toronto.edu ",
+        "bbox": [
+            184,
+            309,
+            370,
+            353
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            375,
+            428,
+            416
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            452,
+            544,
+            468
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep feedforward and recurrent networks have achieved impressive results in many perception and language processing applications. Recently, more complex architectures such as Neural Turing Machines and Memory Networks have been proposed for tasks including question answering and general computation, creating a new set of optimization challenges. In this paper, we explore the lowoverhead and easy-to-implement optimization technique of adding annealed Gaussian noise to the gradient, which we find surprisingly effective when training these very deep architectures. Unlike classical weight noise, gradient noise injection is complementary to advanced stochastic optimization algorithms such as Adam and AdaGrad. The technique not only helps to avoid overfitting, but also can result in lower training loss. We see consistent improvements in performance across an array of complex models, including state-of-the-art deep networks for question answering and algorithm learning. We observe that this optimization strategy allows a fully-connected 20-layer deep network to escape a bad initialization with standard stochastic gradient descent. We encourage further application of this technique to additional modern neural architectures. ",
+        "bbox": [
+            233,
+            484,
+            764,
+            704
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            731,
+            334,
+            747
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks have shown remarkable success in diverse domains including image recognition (Krizhevsky et al., 2012), speech recognition (Hinton et al., 2012) and language processing applications (Sutskever et al., 2014; Bahdanau et al., 2014). This broad success comes from a confluence of several factors. First, the creation of massive labeled datasets has allowed deep networks to demonstrate their advantages in expressiveness and scalability. The increase in computing power has also enabled training of far larger networks with more forgiving optimization dynamics (Choromanska et al., 2015). Additionally, architectures such as convolutional networks (LeCun et al., 1998) and long short-term memory networks (Hochreiter & Schmidhuber, 1997) have proven to be easier to optimize than classical feedforward and recurrent models. Finally, the success of deep networks is also a result of the development of simple and broadly applicable learning techniques such as dropout (Srivastava et al., 2014), ReLUs (Nair & Hinton, 2010), gradient clipping (Pascanu et al., 2013; Graves, 2013), optimization algorithms and weight initialization strategies (Glorot & Bengio, 2010; Sutskever et al., 2013; He et al., 2015). ",
+        "bbox": [
+            174,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent work has aimed to push neural network learning into more challenging domains, such as question answering or program induction. These more complicated problems demand more complicated architectures (e.g. Graves et al. (2014); Sukhbaatar et al. (2015)), thereby posing new optimization challenges. While there is very active research in improving learning in deep feedforward and recurrent networks, such as layer-wise deep supervision (Lee et al., 2015), novel activation functions (Maas et al., 2013), initialization schemes (He et al., 2015), and cell architectures (Cho et al., 2014a; Yao et al., 2015), these are not always sufficient or applicable in networks with complex structure over the latent variables. In order to achieve good performance, researchers have reported the necessity of additional techniques such as explicit labeling of latent variables (Weston et al., 2014), relaxing weight-tying constraints (Kaiser & Sutskever, 2016), warmstarts (Peng et al., 2015), random restarts, and the removal of certain activation functions in early stages of training (Sukhbaatar et al., 2015). ",
+        "bbox": [
+            173,
+            166,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The recurring theme is that commonly-used optimization techniques are not always sufficient to robustly optimize the models of interest. In this work, we explore a simple technique of adding annealed Gaussian noise to the gradient, which we find to be surprisingly effective in training deep neural networks with stochastic gradient descent. While there is a long tradition of adding random weight noise in neural networks, it has been under-explored in the optimization of modern deep architectures. Furthermore, although weight and gradient noise are equivalent when using standard SGD updates, the use of adaptive and momentum based stochastic optimizers such as Adam and AdaGrad (Duchi et al., 2011; Kingma & Ba, 2014) breaks this equivalence, allowing the noise to effectively adapt to the curvature of the optimization landscape. We find this property to be important when optimizing the most complex models. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While there exist theoretical and empirical results on the regularizing effects of conventional stochastic gradient descent, especially for the minimization of convex losses (Bousquet & Bottou, 2008), we find that in practice the added noise can actually help us achieve lower training loss by encouraging active exploration of parameter space. This exploration proves especially necessary and fruitful when optimizing neural network models containing many layers or complex latent structures. For neural network learning, it has long been known that the noise in the stochastic gradient can help to escape saddle points and local optima (Bottou, 1992). For this reason, neural network practitioners sometimes avoid overly-large mini-batch sizes to achieve the best results. We find that the Gaussian noise added in our technique is complementary to the noisy stochastic gradient, and a combination of Gaussian noise and tuned mini-batch sizes is necessary for the most complex models. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contribution of this work is to demonstrate the broad applicability of this simple method to the training of many complex modern neural architectures. To our knowledge, neither the exponentially decayed noise schedule nor the black box combination of injected gradient noise with adaptive optimizers have been used before in the training of deep networks. We consistently see improvements from Gaussian gradient noise when optimizing a wide variety of models, including very deep fully-connected networks, and special-purpose architectures for question answering and algorithm learning. For example, this method allows us to escape a poor initialization and successfully train a 20-layer rectifier network on MNIST with standard gradient descent. It also enables a $72 \\%$ relative reduction in error in question answering, and doubles the number of accurate binary multiplication models learned across 7,000 random restarts. Gradient noise also possesses attractive robustness properties. We examine only two distinct settings of the noise variance hyperparameter in total across all experiments. We additionally observe that in cases where gradient noise fails to improve over other learning techniques, it rarely significantly hurts a models ability to generalize. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We hope that practitioners will see similar improvements in their own research by adding this simple technique, implementable in a single line of code, to their repertoire. ",
+        "bbox": [
+            174,
+            819,
+            821,
+            848
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            343,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adding random noise to the weights, inputs, or hidden units has been a known technique amongst neural network practitioners for many years (e.g. Murray & Edwards; An (1996)). However, the benefits of gradient noise have not been fully explored with modern deep networks nor combined with advanced stochastic optimization techniques, which allow the noise to take into account the geometry of the optimization problem and the statistical manifold. ",
+        "bbox": [
+            174,
+            145,
+            825,
+            214
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Weight noise (Steijvers, 1996) and adaptive weight noise (Graves, 2011; Blundell et al., 2015), which usually maintains a Gaussian variational posterior over network weights, similarly aim to improve learning by added noise during training. In adaptive weight noise, an extra set of parameters for the variance must be maintained. This adaptation is different than our use of an adaptive optimizer, as it aims to capture an accurate estimate of uncertainty in the weights and not guide the exploration of parameter space. They differ from our proposed method in that the noise is not annealed and at convergence will be non-zero. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Similarly, the technique of dropout (Srivastava et al., 2014) randomly sets groups of hidden units to zero at train time to improve generalization in a manner similar to ensembling. ",
+        "bbox": [
+            176,
+            325,
+            821,
+            353
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An annealed Gaussian gradient noise schedule was used to train the highly non-convex Stochastic Neighbor Embedding model in Hinton & Roweis (2002). The gradient noise schedule that we found to be most effective is very similar to the Stochastic Gradient Langevin Dynamics (SGLD) algorithm of Welling & Teh (2011), who use gradients with added noise to accelerate MCMC inference for logistic regression and independent component analysis models. This use of gradient information in MCMC sampling for machine learning to allow faster exploration of state space was previously proposed by Neal (2011). However, standard SGLD analysis does not allow for the use of adaptive optimizers or momentum, limiting the efficiency for very pathological optimization landscapes. Stochastic Gradient Riemannian Langevin Dynamics (Patterson & Teh, 2013) adapts the gradient and noise using the Fisher information matrix, effectively following trajectories along the same manifold as the natural gradient (Amari, 1998), but is applied only to models for which that matrix is tractable to estimate in closed form. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Various optimization techniques have been proposed to improve the training of neural networks. Most notable is the use of momentum (Polyak, 1964; Sutskever et al., 2013; Kingma & Ba, 2014) or adaptive learning rates (Duchi et al., 2011; Dean et al., 2012; Zeiler, 2012). These methods are normally developed to provide good convergence rates for the convex setting, and then heuristically applied to nonconvex problems. Similarly, batch normalization and related methods (Ioffe & Szegedy, 2015; Arpit et al., 2016; Salimans & Kingma, 2016), natural gradient descent (Amari, 1998; Desjardins et al., 2015), and K-FAC (Martens & Grosse, 2015) can all be seen as various preconditioning methods using approximations to the inverse Fisher information of the neural network. While there has been some difficulty in combining batch normalization-type algorithms with recurrent networks (Laurent et al., 2015), recent work has had success in this area (Cooijmans et al., 2016; Ba et al., 2016). ",
+        "bbox": [
+            174,
+            535,
+            825,
+            686
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Injecting noise in the gradient can be combined with any of the above methods, and can be seen as a complementary technique especially suitable for nonconvex problems. By adding additional artificial stochasticity to the gradient, this technique allows the model more chances to escape local minima or saddle-points (see a similar argument in Bottou (1992)), or to traverse quickly through the “transient” plateau phase of early learning (see a similar analysis for momentum in Sutskever et al. (2013)). This is born out empirically in our observation that adding gradient noise can actually result in lower training loss. In this sense, we suspect adding gradient noise is similar to simulated annealing (Kirkpatrick et al., 1983) which exploits random noise to explore complex optimization landscapes. This can be contrasted with well-known benefits of stochastic gradient descent as a learning algorithm (Robbins & Monro, 1951; Bousquet & Bottou, 2008), where both theory and practice have shown that the noise induced by the stochastic process aids generalization by reducing overfitting. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, there has been a surge in research examining the use of gradient and weight noise when training deep neural networks. Mobahi (2016) present an optimization technique for recurrent networks that applies an annealed Gaussian kernel smoothing method to the loss function, of which annealed weight noise is a Monte Carlo estimator. Li et al. (2016) present a version of SGLD that incorporates both Gaussian noise and adaptively estimated learning rates (but no momentum term). Though significantly more complex than our proposed method, the most similar work is the Santa algorithm of Chen et al. (2016). Santa combines SGLD with adaptive learning rates and adaptive per-coordinate momentum parameters, and shows that the scheme can approach global optima of the objective function under certain assumptions. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            282,
+            210
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider a simple technique of adding time-dependent Gaussian noise to the gradient $g$ at every training step $t$ : ",
+        "bbox": [
+            174,
+            226,
+            825,
+            255
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d3fe086c35a798fe649d5eab999d6ecaf87facd9e5ca9b84d35fae5d1eecae8.jpg",
+        "text": "$$\ng _ { t } \\gets g _ { t } + N ( 0 , \\sigma _ { t } ^ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            261,
+            566,
+            280
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The gradient $g _ { t }$ is then used to update the weights $\\theta _ { t }$ as if it were the original gradient of the loss function, and can be used with any stochastic optimization algorithm. Our experiments indicate that adding annealed Gaussian noise by decaying the variance often works better and more robustly than using fixed Gaussian noise (see Section 4.6). We use a schedule inspired from Welling & Teh (2011) in our experiments and take: ",
+        "bbox": [
+            174,
+            286,
+            823,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/417b3d3f6b0dff59009ac85e6c5094f12357ad192c460f5e7e77836907369d62.jpg",
+        "text": "$$\n\\sigma _ { t } ^ { 2 } = \\frac { \\eta } { ( 1 + t ) ^ { \\gamma } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            447,
+            363,
+            549,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We examine only 2 distinct noise hyperparameter configurations in our experiments, selecting $\\eta$ from $\\{ 0 . 0 1 , 1 . 0 \\}$ and setting $\\gamma = 0 . 5 5$ in all experiments. We believe this shows that annealed gradient noise is robust to minimal tuning. For example, in the experiments on Neural Programmer and Neural GPUs, we tried only a single configuration of noise parameters, simply setting $\\eta = 1 . 0$ and tuning only the model hyperparameters as normal. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            470
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            326,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following experiments, we examine the effect of gradient noise on deep networks for MNIST digit classification, and consider a variety of complex neural network architectures: EndTo-End Memory Networks (Sukhbaatar et al., 2015) and Neural Programmer (Neelakantan et al., 2016) for question answering, Neural Random Access Machines (Kurach et al., 2016) and Neural GPUs (Kaiser & Sutskever, 2016) for algorithm learning. The models and results are described as follows. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 DEEP FULLY-CONNECTED NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            480,
+            638
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For our first set of experiments, we examine the impact of adding gradient noise when training a very deep fully-connected network on the MNIST handwritten digit classification dataset (LeCun et al., 1998). Our network is deep: it has 20 hidden layers, with each layer containing 50 hidden units, posing a significant optimization and generalization problem. We use the ReLU activation function (Nair & Hinton, 2010). ",
+        "bbox": [
+            174,
+            651,
+            825,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we train with SGD without momentum, using the fixed learning rates of 0.1 and 0.01. Unless otherwise specified, the weights of the network are initialized from a Gaussian with mean zero, and standard deviation of 0.1, which we call Simple Init. When adding gradient noise, we tried both settings of the variance detailed in Section 3, and found that decaying variance according to the schedule in Equation (1) with $\\eta = 0 . 0 1$ worked best. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The results of our experiment are in Table 1. When trained from Simple Init we can see that adding noise to the gradient helps in achieving higher average and best accuracy over 20 runs using each learning rate for a total of 40 runs (Table 1, Experiment 1). We note that the average is closer to $50 \\%$ because the small learning rate of 0.01 usually gives very slow convergence. We also try our approach on a more shallow network of 5 layers, but adding noise does not improve the training in that case. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, we experiment with clipping the gradients with two threshold values: 100 and 10 (Table 1, Experiment 2, and 3). Here, we find training with gradient noise is insensitive to the gradient clipping values. By tuning the clipping threshold, it is possible to get comparable accuracy without noise for this problem. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our fourth and fifth experiments (Table 1, Experiment 4), we use two analytically-derived ReLU initialization techniques (which we term Good Init 1 and 2) recently-proposed by Sussillo (2014) and He et al. (2015), and find that adding gradient noise does not help. Previous work has found that stochastic gradient descent with carefully tuned initialization, momentum, learning rate, and learning rate decay can optimize such extremely deep fully-connected ReLU networks (Srivastava et al., 2015). It would be harder to find such a robust initialization technique for the more complex heterogeneous architectures considered in later sections. Accordingly, we find in later experiments (e.g., Section 4.3) that random restarts and the use of a momentum-based optimizer like Adam are not sufficient to achieve the best results in the absence of added gradient noise. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To test how sensitive the methods are to poor initialization, in addition to the sub-optimal Simple Init, we run an experiment where all the weights in the neural network are initialized at zero. The results (Table 1, Experiment 5) show that if we do not add noise to the gradient, the networks fail to learn. If we add some noise, the networks can learn and reach $9 4 . 5 \\%$ accuracy. While the pessimal performance of the noiseless model is unsurprising (initializing weights at 0 introduces symmetries that make gradient-descent impossible), it is interesting to note that gradient noise can overcome what is perhaps the canonical “bad initialization.” ",
+        "bbox": [
+            173,
+            270,
+            825,
+            368
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/403c3a9d66c084cbba14e83f99955a44835374315282f6d7ca33fa2eb6345a37.jpg",
+        "table_caption": [
+            "Experiment 1: Simple Init, No Gradient Clip "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>Best Test Acc.</td><td rowspan=1 colspan=1>Avg. Test Acc.</td></tr><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>89.9%</td><td rowspan=1 colspan=1>43.1%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>52.7%</td></tr><tr><td rowspan=1 colspan=1>No Noise + Dropout</td><td rowspan=1 colspan=1>11.3%</td><td rowspan=1 colspan=1>10.8%</td></tr></table>",
+        "bbox": [
+            303,
+            404,
+            692,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/d172ed64bdb29fdec53b362710e5ed0707bd53dfe2015932b56875c3d80abbc6.jpg",
+        "table_caption": [
+            "Experiment 2: Simple Init, Gradient ${ \\mathrm { C l i p } } = 1 0 0$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>90.0%</td><td rowspan=1 colspan=1>46.3%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>52.3%</td></tr></table>",
+        "bbox": [
+            303,
+            491,
+            692,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/e21e10ea69a4dc2081b91fb1bad469aa6ffda75d319c2d01e06430d46d1f75a4.jpg",
+        "table_caption": [
+            "Experiment 3: Simple Init, Gradient ${ \\mathrm { C l i p } } = 1 0$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>95.7%</td><td rowspan=1 colspan=1>51.6%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>97.0%</td><td rowspan=1 colspan=1>53.6%</td></tr></table>",
+        "bbox": [
+            303,
+            549,
+            694,
+            579
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/4168a534d031b5a25056efb20a3a47afecb947e058b060e8c2c7290251f2344a.jpg",
+        "table_caption": [
+            "Experiment 4: Good Init $1 +$ Gradient Clip = 10 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>97.4%</td><td rowspan=1 colspan=1>92.1%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>97.5%</td><td rowspan=1 colspan=1>92.2%</td></tr></table>",
+        "bbox": [
+            303,
+            606,
+            694,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/6112ef92921eac96c039214606d2566d110a065671df4fabe1546bd3f0ed0e2c.jpg",
+        "table_caption": [
+            "Experiment 5: Good Init $^ { 2 + }$ Gradient Clip = 10 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>97.4%</td><td rowspan=1 colspan=1>91.7%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>97.2%</td><td rowspan=1 colspan=1>91.7%</td></tr></table>",
+        "bbox": [
+            305,
+            661,
+            694,
+            693
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/8c70b1fbae3142d6d35a208a5ced44471a6c86948f565145d28f17b6efdb52c0.jpg",
+        "table_caption": [
+            "Experiment 6: Bad Init (Zero Init) $^ +$ Gradient Clip = 10 ",
+            "Table 1: Average and best test accuracy on MNIST over 40 runs. Higher values are better. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>11.4%</td><td rowspan=1 colspan=1>10.1%</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>94.5%</td><td rowspan=1 colspan=1>49.7%</td></tr></table>",
+        "bbox": [
+            302,
+            718,
+            694,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In summary, these experiments show that if we are careful with initialization and gradient clipping values, it is possible to train a very deep fully-connected network without adding gradient noise. However, if the initialization is poor, optimization can be difficult, and adding noise to the gradient is a good mechanism to overcome the optimization difficulty. Additionally, the noise need not be heavily tuned and rarely decreases performance. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This set of results suggests that added gradient noise can be an effective mechanism for training complex networks. This is because it is more difficult to initialize the weights properly for these architectures. In the following, we explore the training of more complex models such as End-ToEnd Memory Networks and Neural Programmer, whose initialization is less well studied. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 END-TO-END MEMORY NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            464,
+            162
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We test added gradient noise for training End-To-End Memory Networks (Sukhbaatar et al., 2015), an approach for question answering using deep networks. Memory Networks have been demonstrated to perform well on a relatively challenging toy question answering problem (Weston et al., 2015). ",
+        "bbox": [
+            174,
+            174,
+            825,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Memory Networks, the model has access to a context, a question, and is asked to predict an answer. Internally, the model has an attention mechanism which focuses on the right clue to answer the question. In the original formulation (Weston et al., 2015), Memory Networks were provided with additional supervision as to what pieces of context were necessary to answer the question. This was replaced in the End-To-End formulation by a latent attention mechanism implemented by a softmax over contexts. As this greatly complicates the learning problem, the authors implement a two-stage training procedure: First train the networks with a linear attention, then use those weights to warmstart the model with softmax attention. ",
+        "bbox": [
+            173,
+            237,
+            825,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our experiments with Memory Networks, we use the same model hyperparameter settings as Sukhbaatar et al. (2015), and we try both settings of the variance detailed in Section 3, finding $\\eta = 0 . 0 1$ worked best for this task. This noise is added to the gradient after clipping. ",
+        "bbox": [
+            176,
+            356,
+            821,
+            397
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We set the number of training epochs to 200 because we would like to understand the behaviors of Memory Networks near convergence. We test the effect of gradient noise with the published two-stage training approach, and additionally with a one-stage approach where we train the networks with softmax attention and without warmstarting. Following the experimental protocol of Sukhbaatar et al. (2015), we take the model with lowest training error out of 10 random restarts. Results are reported in Table 2. We find some fluctuations during each run of the training, but the reported results reflect the typical gains obtained by adding random noise. ",
+        "bbox": [
+            173,
+            404,
+            825,
+            502
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We find that warmstarting does indeed help the networks. In all cases, adding random noise to the gradient also helps the network both in terms of training errors and validation errors, and never hurts. Added noise, however, is especially helpful for the training of End-To-End Memory Networks without the warmstarting stage. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e665ab3c53aa73e73f6bc05ebea42392eb2d406ace8edafcbae3372fa170654b.jpg",
+        "table_caption": [
+            "One-Stage Training "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>With Noise</td></tr><tr><td rowspan=1 colspan=1>Train error:</td><td rowspan=1 colspan=1>10.5%</td><td rowspan=1 colspan=1>9.6%</td></tr><tr><td rowspan=1 colspan=1>Validation error:</td><td rowspan=1 colspan=1>19.5%</td><td rowspan=1 colspan=1>16.6%</td></tr></table>",
+        "bbox": [
+            344,
+            597,
+            651,
+            645
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e2c4ad4306e8f24c7a79fea9f8530e16b450a3cf536f6d7940925b2254b15bf3.jpg",
+        "table_caption": [
+            "Two-Stage Training ",
+            "Table 2: The effects of adding gradient noise to End-to-End Memory Networks. Lower values are better. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Train error:</td><td rowspan=1 colspan=1>6.2%</td><td rowspan=1 colspan=1>5.9%</td></tr><tr><td rowspan=1 colspan=1>Validation error:</td><td rowspan=1 colspan=1>10.9%</td><td rowspan=1 colspan=1>10.8%</td></tr></table>",
+        "bbox": [
+            344,
+            671,
+            650,
+            702
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 NEURAL PROGRAMMER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            380,
+            800
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Neural Programmer is a neural network architecture augmented with a small set of built-in arithmetic and logic operations that learns to induce latent programs. It is proposed for the task of question answering from tables (Neelakantan et al., 2016). Examples of operations on a table include the sum of a set of numbers, or the list of numbers greater than a particular value. Key to Neural Programmer is the use of “soft selection” to assign a probability distribution over the list of operations. This probability distribution weighs the result of each operation, and the cost function compares this weighted result to the ground truth. This soft selection, inspired by the soft attention mechanism of Bahdanau et al. (2014), allows for full differentiability of the model. Running the model for several steps of selection allows the model to induce a complex program by chaining the operations, one after the other. At convergence, the soft selection tends to become peaky (hard selection). Figure 1 shows the architecture of Neural Programmer at a high level. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/103af5e9384f10e63f4ef6686fe5aa03b123e3553d6760d47ab8ea34ba802dbb.jpg",
+        "image_caption": [
+            "Figure 1: Neural Programmer, a neural network with built-in arithmetic and logic operations. At every time step, the controller selectes an operation and a data segment. Figure reproduced with permission from Neelakantan et al. (2016). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            159,
+            686,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In a synthetic table comprehension task, Neural Programmer takes a question and a table (or database) as input and the goal is to predict the correct answer. To solve this task, the model has to induce a program and execute it on the table. A major challenge is that the supervision signal is in the form of the correct answer and not the program itself. The model runs for a fixed number of steps, and at each step selects a data segment and an operation to apply to the selected data segment. Soft selection is performed at training time so that the model is differentiable, while at test time hard selection is employed. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We examine only the noise configuration with $\\eta = 1 . 0$ , and add noise to the gradient after clipping, optimizing all other hyperparameters of the model. The model is optimized with Adam (Kingma & Ba, 2014), which combines momentum and adaptive learning rates. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For our first experiment, we train Neural Programmer to answer questions involving a single column of numbers. We use 72 different hyper-parameter configurations with and without adding annealed random noise to the gradients. We also run each of these experiments for 3 different random initializations of the model parameters and we find that only $1 / 2 1 6$ runs achieve $1 0 0 \\%$ test accuracy without adding noise while $9 / 2 1 6$ runs achieve $1 0 0 \\%$ accuracy when random noise is added. The 9 successful runs consisted of models initialized with all the three different random seeds, demonstrating robustness to initialization. We find that when using dropout (Srivastava et al., 2014) none of the 216 runs give $100 \\%$ accuracy. ",
+        "bbox": [
+            173,
+            506,
+            825,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We consider a more difficult question answering task where tables have up to five columns containing numbers. We also experiment on a task containing one column of numbers and another column of text entries. Table 3 shows the performance of adding noise vs. no noise on Neural Programmer. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            667
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d74b3cb500da82e26bac08273035740b18a487616560cc20ecd9a304725d119e.jpg",
+        "table_caption": [
+            "Question Answering Accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>Dropout</td><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>With Noise</td></tr><tr><td rowspan=1 colspan=1>Five columns</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>95.3%</td><td rowspan=1 colspan=1>98.7%</td></tr><tr><td rowspan=1 colspan=1>Text entries</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>97.6%</td><td rowspan=1 colspan=1>98.8%</td></tr><tr><td rowspan=1 colspan=1>Five columns</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>97.4%</td><td rowspan=1 colspan=1>99.2%</td></tr><tr><td rowspan=1 colspan=1>Text entries</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>99.1%</td><td rowspan=1 colspan=1>97.3%</td></tr></table>",
+        "bbox": [
+            318,
+            694,
+            679,
+            771
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: The effects of adding random noise to the gradient on Neural Programmer. Higher values are better. Adding random noise to the gradient always helps the model. When the models are applied to these more complicated tasks than the single column experiment, using dropout and noise together seems to be beneficial in one case while using only one of them achieves the best result in the other case. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            852
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows an example of the effect of adding random noise to the gradients in our experiment with 5 columns. The differences between the two models are much more pronounced than Table 3 indicates because that table reflects the results from the best hyperparameters. Figure 2 indicates a more typical training run. ",
+        "bbox": [
+            173,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a1e50a67d834ff2dfdac9f418a072266c4e7a59d8bd015eb741c661ea8cd996.jpg",
+        "image_caption": [
+            "Figure 2: Noise Vs. No Noise in our experiment with 5 columns. The models trained with noise generalizes almost always better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            333,
+            104,
+            656,
+            224
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In all cases, we see that added gradient noise improves performance of Neural Programmer. Its performance when combined with or used instead of dropout is mixed depending on the problem, but the positive results indicate that it is worth attempting on a case-by-case basis. ",
+        "bbox": [
+            174,
+            290,
+            823,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 NEURAL RANDOM ACCESS MACHINES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            349,
+            485,
+            363
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now conduct experiments with Neural Random-Access Machines (NRAM) (Kurach et al., 2016). NRAM is a model for algorithm learning that can store data, and explicitly manipulate and dereference pointers. NRAM consists of a neural network controller, memory, registers and a set of built-in operations. This is similar to the Neural Programmer in that it uses a controller network to compose built-in operations, but both reads and writes to an external memory. An operation can either read (a subset of) contents from the memory, write content to the memory or perform an arithmetic operation on either input registers or outputs from other operations. The controller runs for a fixed number of time steps. At every step, the model selects a “circuit” to be executed: both the operations and its inputs. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            501
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "These selections are made using soft attention (Bahdanau et al., 2014) making the model end-to-end differentiable. NRAM uses an LSTM (Hochreiter & Schmidhuber, 1997) controller. Figure 3 gives an overview of the model. ",
+        "bbox": [
+            176,
+            507,
+            825,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/94341ba07767fbb398d37953fef5a9fe3f4a1ce8f10de8bdda526db81385e635.jpg",
+        "image_caption": [
+            "Figure 3: One timestep of the NRAM architecture with $R = 4$ registers and a memory tape. $m _ { 1 }$ , $m _ { 2 }$ and $m _ { 3 }$ are example operations built-in to the model. The operations can read and write from memory. At every time step, the LSTM controller softly selects the operation and its inputs. Figure reproduced with permission from Kurach et al. (2016). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            316,
+            574,
+            679,
+            718
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For our experiment, we consider a problem of finding the $k$ -th element’s value in a linked list. The network is given a pointer to the head of the linked list, and has to find the value of the $k$ -th element. Note that this is highly nontrivial because pointers and their values are stored at random locations in memory, so the model must learn to traverse a complex graph for $k$ steps. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Because of this complexity, training the NRAM architecture can be unstable, especially when the number of steps and operations is large. We once again experiment with the decaying noise schedule from Equation (1), setting $\\eta = 0 . 0 1$ . We run a large grid search over the model hyperparameters (detailed in Kurach et al. (2016)), and find the top 3 parameter settings separately for both noised and un-noised models. For each model, for each of these 3 settings, we try 100 different random initializations and look at the percentage of runs that give $1 0 0 \\%$ accuracy across each one for training both with and without noise. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As in our experiments with Neural Programmer, we find that adding the noise after gradient clipping is crucial. This is likely because the effect of random noise is washed away when gradients become too large. For models trained with noise we observed much better reproduce rates, which are presented in Table 4. Although it is possible to train the model to achieve $\\bar { 1 } 0 0 \\%$ accuracy without noise, it is less robust across multiple random restarts, with over $1 0 \\mathrm { x }$ as many initializations leading to a correct answer when using noise. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/7a62a8f2657ed093a1e59a734321b83bc5daee105aa68d81cf97e965a286aec6.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>With Noise</td></tr><tr><td rowspan=1 colspan=1>Hyperparameter-1</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>5%</td></tr><tr><td rowspan=1 colspan=1>Hyperparameter-2</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>22%</td></tr><tr><td rowspan=1 colspan=1>Hyperparameter-3</td><td rowspan=1 colspan=1>3%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>Average</td><td rowspan=1 colspan=1>1.3%</td><td rowspan=1 colspan=1>11.3%</td></tr></table>",
+        "bbox": [
+            339,
+            255,
+            656,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Percentage of successful runs on the $k$ -th element task. All tests were performed with the same set of 100 random initializations (seeds). Higher values are better. ",
+        "bbox": [
+            171,
+            343,
+            825,
+            372
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 CONVOLUTIONAL GATED RECURRENT NETWORKS (NEURAL GPUS) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            417,
+            692,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Gated Recurrent Networks (CGRN) or Neural GPUs (Kaiser & Sutskever, 2016) are a recently proposed model that is capable of learning arbitrary algorithms. CGRNs use a stack of convolution layers, unfolded with tied parameters like a recurrent network. The input data (usually a list of symbols) is first converted to a three dimensional tensor representation containing a sequence of embedded symbols in the first two dimensions, and zeros padding the next dimension. Then, multiple layers of modified convolution kernels are applied at each step. The modified kernel is a combination of convolution and Gated Recurrent Units (GRU) (Cho et al., 2014b). The use of convolution kernels allows computation to be applied in parallel across the input data, while the gating mechanism helps the gradient flow. The additional dimension of the tensor serves as a working memory while the repeated operations are applied at each layer. The output at the final layer is the predicted answer. ",
+        "bbox": [
+            173,
+            443,
+            825,
+            597
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The key difference between Neural GPUs and other architectures for algorithmic tasks (e.g., Neural Turing Machines (Graves et al., 2014)) is that instead of using sequential data access, convolution kernels are applied in parallel across the input, enabling the use of very deep and wide models. The model is referred to as Neural GPU because the input data is accessed in parallel. Neural GPUs were shown to outperform previous sequential architectures for algorithm learning on tasks such as binary addition and multiplication, by being able to generalize from much shorter to longer data cases. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            688
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we use Neural GPUs for the task of binary multiplication. The input consists two concatenated sequences of binary digits separated by an operator token, and the goal is to multiply the given numbers. During training, the model is trained on 20-digit binary numbers while at test time, the task is to multiply 200-digit numbers. We add Gaussian noise with decaying variance according to the schedule in Equation (1) with $\\eta = 1 . 0$ , to the gradient after clipping. The model is optimized using Adam (Kingma & Ba, 2014). ",
+        "bbox": [
+            174,
+            694,
+            825,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 5 gives the results of a large-scale experiment using Neural GPUs with a 7290 grid search. The experiment shows that models trained with added gradient noise are more robust across many random initializations and parameter settings. As you can see, adding gradient noise both allows us to achieve the best performance, with the number of models with $< 1 \\%$ error over twice as large as without noise. But it also helps throughout, improving the robustness of training, with more models training to higher error rates as well. This experiment shows that the simple technique of added gradient noise is effective even in regimes where we can afford a very large numbers of random restarts. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            897
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ebdf70485c39ee4797088273058bc6c15c040b12ba8e93e419284f4fbb3774b2.jpg",
+        "table_caption": [
+            "Table 5: Number of successful runs on 7290 random trials. Higher values are better. The models are trained on length 20 and tested on length 200. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>Error&lt;1%</td><td rowspan=1 colspan=1>&lt;2%</td><td rowspan=1 colspan=1>&lt;3%</td><td rowspan=1 colspan=1>&lt;5%</td></tr><tr><td rowspan=1 colspan=1>No Noise</td><td rowspan=1 colspan=1>28</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>172</td><td rowspan=1 colspan=1>387</td></tr><tr><td rowspan=1 colspan=1>With Noise</td><td rowspan=1 colspan=1>58</td><td rowspan=1 colspan=1>159</td><td rowspan=1 colspan=1>282</td><td rowspan=1 colspan=1>570</td></tr></table>",
+        "bbox": [
+            312,
+            101,
+            684,
+            150
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            220,
+            302,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work we propose an annealed Gaussian gradient noise scheme for the optimization of complex neural networks. Our experiments show improvement from gradient noise on a variety of models. We conduct a small set of additional experiments below to examine the factors that make this technique successful, and report a failure mode. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            304
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Annealed vs. fixed noise We use a single fixed decay value $\\gamma = 0 . 5 5$ when applying Equation (1) in our experiments, inspired by Stochastic Gradient Langevin Dynamics, and recommend it as a default. We conduct several experiments to determine the importance of annealed vs. fixed noise added to the gradient. We find that for the End2End model, similar results can be achieved with fixed noise values, however requiring significantly more tuning (compared to trying only two different values of $\\eta$ in our experiments with annealed noise). We achieve nearly identical results on the End2End experiment using a fixed noise value of $\\eta = 0 . 0 0 1$ . We also experiment with fixed noise on the Neural Programmer and NRAM models, and find that they make a larger difference. For both models, we select fixed noise values log-uniformly from between $1 \\mathrm { e } { - 4 }$ and 0.1 and optimize the other hyperparameters. Using 216 runs per variance setting, the best Neural Programmer models without annealing can achieve equivalent errors to the annealed models. However, only 5/216 achieve the best error compared to 9/216 for the model using annealing. For NRAM, using 180 runs per setting, fixed noise never achieves the perfect error of 0 that is achieved by the annealed model. While annealing shows the most benefit with the most complex models, we generally recommend it as a robust default that requires less hyperparameter tuning than fixed noise. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gaussian noise vs. gradient stochasticity We assert that gradient noise helps the model explore the optimization landscape, escaping saddle points and local minima. Analysis of SGD for neural networks suggests that the stochasticity of the gradient serves much the same purpose (Bottou, 1992). This suggests a strategy: add noise to the gradient by simply reducing the minibatch size, increasing the variance of the gradient estimator. While arguments based on SGLD and kernel smoothing provide evidence that the specific form of the Gaussian noise is important, we run a pair of small experiments. For both Neural Programmer and NRAM, we tried batch sizes of 10, 25, and 50 (50 being the value used in the best results). For NRAM, after 100 tasks at each batch size and no gradient noise, 2 tasks at batch size 50 converged to 0 error, 1 task at batch size 10, and none at batch size 25. For Neural Programmer, over 216 experiments at each batch size we see none of the models without gradient noise converge to the best error. These results are far worse than our results using added noise, indicating that merely lowering the batch size does not introduce the same sort of helpful stochasticity. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gradient noise vs. weight noise While weight noise is relatively well-known, it is not equivalent to gradient noise in the case of adaptive or momentum-based optimizers, which effectively adapt the noise to the curvature of the optimization landscape. Both Neural Programmer and NRAM are greatly helped in training by the use of the Adam algorithm for optimization. We find here, using the same experimental setup as when examining annealed vs. fixed noise, that the models fail to learn when adding noise directly to the weights. Even when using starting noise rates as low as $1 \\mathrm { e } { - 6 }$ , with the usual annealing schedule, the models fail to train significantly, achieving $57 \\%$ error for NRAM and $68 \\%$ for Neural Programmer at the lowest. Importantly, these noise rates are on the same order as the adaptive learning rates. This indicates that the issue is not just the noise scale, but that the very poor conditioning of the loss functions makes it necessary to adapt the noise. Similar concerns motivated the development of very recent algorithms for preconditioned SGLD in the Bayesian setting (Li et al., 2016). ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Negative results While we see improvements on a large number of neural network architectures, we note a case where gradient noise does not improve over standard SGD. We conduct language modeling experiments on the Penn Treebank (Marcus et al., 1993), using the experimental setup and architecture from Zaremba et al. (2014). We report results using a 200-unit LSTM with dropout, but observe a similar lack of improvement from gradient noise when using models without dropout. We try the two proposed noise rates from Section (method) and find the best results using $\\eta = 0 . 0 1$ are slightly worse than the noiseless model, achieving a perplexity of 98 rather than 95. By further lowering the noise parameter to $\\eta = 0 . 0 0 1$ we are able to achieve the same perplexity as the baseline, but do not see improvement. While adding gradient noise does not help in this case, it is simple to try and does not significantly hurt the results. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            262,
+            318,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we demonstrate the effectiveness of adding noise to the gradient when training deep neural networks. We find that adding noise to the gradient helps optimization and generalization of complicated neural networks and is compatible with and complementary to other stochastic optimization methods. We suspect that the effects are pronounced for complex models because they have many saddle points. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We believe that this surprisingly simple yet effective idea, essentially a single line of code, should be in the toolset of neural network practitioners when facing issues with training neural networks. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            421,
+            287,
+            436
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shun-Ichi Amari. Natural gradient works efficiently in learning. Neural computation, 1998. ",
+        "bbox": [
+            173,
+            445,
+            774,
+            460
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guozhong An. The effects of adding noise during backpropagation training on a generalization performance. Neural Computation, 1996. ",
+        "bbox": [
+            173,
+            469,
+            820,
+            500
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Devansh Arpit, Yingbo Zhou, Bhargava U Kota, and Venu Govindaraju. Normalization propagation: A parametric technique for removing internal covariate shift in deep networks. ICML, 2016. ",
+        "bbox": [
+            174,
+            508,
+            821,
+            537
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. ",
+        "bbox": [
+            174,
+            546,
+            823,
+            575
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. ICLR, 2014. ",
+        "bbox": [
+            174,
+            585,
+            823,
+            614
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. ICML, 2015. ",
+        "bbox": [
+            173,
+            625,
+            823,
+            654
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Leon Bottou. Stochastic gradient learning in neural networks. In ´ Neuro-N¨ımes, 1992. ",
+        "bbox": [
+            174,
+            662,
+            735,
+            679
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olivier Bousquet and Leon Bottou. The tradeoffs of large scale learning. In ´ NIPS, 2008. ",
+        "bbox": [
+            169,
+            688,
+            751,
+            703
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Changyou Chen, David Carlson, Zhe Gan, Chunyuan Li, and Lawrence Carin. Bridging the gap between stochastic gradient mcmc and stochastic optimization, 2016. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            742
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014a. ",
+        "bbox": [
+            173,
+            751,
+            823,
+            794
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder-decoder for statistical machine translation. In EMNLP, 2014b. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anna Choromanska, Mikael Henaff, Michael Mathieu, G ¨ erard Ben Arous, and Yann LeCun. The ´ loss surfaces of multilayer networks. In AISTATS, 2015. ",
+        "bbox": [
+            169,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Cooijmans, Nicolas Ballas, Cesar Laurent, and Aaron Courville. Recurrent batch normalization. ´ arXiv preprint arXiv:1603.09025, 2016. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In NIPS, 2012. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Desjardins, Karen Simonyan, Razvan Pascanu, and koray kavukcuoglu. Natural neural networks. In NIPS. 2015. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. JMLR, 2011. ",
+        "bbox": [
+            171,
+            179,
+            823,
+            209
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proc. AISTATS, pp. 249–256, 2010. ",
+        "bbox": [
+            174,
+            218,
+            823,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Practical variational inference for neural networks. In NIPS, 2011. ",
+        "bbox": [
+            173,
+            257,
+            702,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arxiv:1308.0850, 2013. ",
+        "bbox": [
+            173,
+            281,
+            820,
+            311
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural Turing Machines. arXiv preprint arXiv:1410.5401, 2014. ",
+        "bbox": [
+            174,
+            320,
+            823,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. ICCV, 2015. ",
+        "bbox": [
+            173,
+            358,
+            823,
+            388
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton and Sam Roweis. Stochastic neighbor embedding. In NIPS, 2002. ",
+        "bbox": [
+            173,
+            397,
+            722,
+            412
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Li Deng, Dong Yu, George Dahl, Abdel rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara Sainath, and Brian Kingsbury. Deep neural networks for acoustic modeling in speech recognition. Signal Processing Magazine, 2012. ",
+        "bbox": [
+            176,
+            421,
+            821,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 1997. ",
+        "bbox": [
+            174,
+            474,
+            810,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: accelerating deep network training by reducing internal covariate shift. In ICML, 2015. ",
+        "bbox": [
+            173,
+            500,
+            820,
+            529
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lukasz Kaiser and Ilya Sutskever. Neural GPUs learn algorithms. In ICLR, 2016. ",
+        "bbox": [
+            174,
+            537,
+            710,
+            553
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            592
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Scott Kirkpatrick, Mario P Vecchi, et al. Optimization by simulated annealing. Science, 1983. ",
+        "bbox": [
+            174,
+            601,
+            790,
+            617
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            173,
+            625,
+            823,
+            655
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karol Kurach, Marcin Andrychowicz, and Ilya Sutskever. Neural random-access machines. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            664,
+            825,
+            694
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Cesar Laurent, Gabriel Pereyra, Phil ´ emon Brakel, Ying Zhang, and Yoshua Bengio. Batch normal- ´ ized recurrent neural networks. arXiv preprint arXiv:1510.01378, 2015. ",
+        "bbox": [
+            173,
+            702,
+            823,
+            732
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 1998. ",
+        "bbox": [
+            171,
+            741,
+            823,
+            771
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chen-Yu Lee, Saining Xie, Patrick W. Gallagher, Zhengyou Zhang, and Zhuowen Tu. Deeplysupervised nets. AISTATS, 2015. ",
+        "bbox": [
+            173,
+            779,
+            823,
+            809
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chunyuan Li, Changyou Chen, David Carlson, and Lawrence Carin. Preconditioned stochastic gradient langevin dynamics for deep neural networks, 2016. ",
+        "bbox": [
+            169,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. ICML, 2013. ",
+        "bbox": [
+            173,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 1993. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. arXiv preprint arXiv:1503.05671, 2015. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hossein Mobahi. Training recurrent neural networks by diffusion, 2016. ",
+        "bbox": [
+            174,
+            141,
+            648,
+            156
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alan F Murray and Peter J Edwards. Synaptic weight noise during mlp learning enhances faulttolerance, generalization and learning trajectory. ",
+        "bbox": [
+            173,
+            166,
+            823,
+            195
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey Hinton. Rectified linear units improve Restricted Boltzmann Machines. In ICML, 2010. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            233
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Radford M Neal. MCMC using Hamiltonian dynamics. Handbook of Markov Chain Monte Carlo, 2011. ",
+        "bbox": [
+            171,
+            242,
+            825,
+            272
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Arvind Neelakantan, Quoc V. Le, and Ilya Sutskever. Neural Programmer: Inducing latent programs with gradient descent. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            310
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. Proc. ICML, 2013. ",
+        "bbox": [
+            174,
+            319,
+            823,
+            348
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sam Patterson and Yee Whye Teh. Stochastic gradient riemannian langevin dynamics on the probability simplex. In NIPS, 2013. ",
+        "bbox": [
+            174,
+            357,
+            821,
+            387
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Baolin Peng, Zhengdong Lu, Hang Li, and Kam-Fai Wong. Towards neural network-based reasoning. arXiv preprint arxiv:1508.05508, 2015. ",
+        "bbox": [
+            173,
+            396,
+            821,
+            425
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Boris Teodorovich Polyak. Some methods of speeding up the convergence of iteration methods. USSR Computational Mathematics and Mathematical Physics, 1964. ",
+        "bbox": [
+            173,
+            434,
+            821,
+            464
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Herbert Robbins and Sutton Monro. A stochastic approximation method. The annals of mathematical statistics, 1951. ",
+        "bbox": [
+            174,
+            473,
+            821,
+            502
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans and Diederik P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. 2016. ",
+        "bbox": [
+            173,
+            511,
+            821,
+            540
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014. ",
+        "bbox": [
+            176,
+            549,
+            821,
+            579
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Training very deep networks. ¨ NIPS, 2015. ",
+        "bbox": [
+            173,
+            588,
+            823,
+            617
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mark Steijvers. A recurrent network that performs a context-sensitive prediction task. In CogSci, 1996. ",
+        "bbox": [
+            171,
+            626,
+            825,
+            656
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. In NIPS, 2015. ",
+        "bbox": [
+            173,
+            664,
+            823,
+            694
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Sussillo. Random walks: Training very deep nonlinear feed-forward networks with smart initialization. CoRR, 2014. ",
+        "bbox": [
+            171,
+            703,
+            825,
+            733
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, James Martens, George Dahl, and Geoffrey Hinton. On the importance of initialization and momentum in deep learning. In ICML, 2013. ",
+        "bbox": [
+            171,
+            741,
+            823,
+            771
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In NIPS, 2014. ",
+        "bbox": [
+            173,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Max Welling and Yee Whye Teh. Bayesian learning via stochastic gradient Langevin dynamics. In ICML, 2011. ",
+        "bbox": [
+            171,
+            818,
+            825,
+            848
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint arXiv:1410.3916, 2014. ",
+        "bbox": [
+            173,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Antoine Bordes, Sumit Chopra, and Tomas Mikolov. Towards AI-complete question answering: a set of prerequisite toy tasks. In ICML, 2015. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kaisheng Yao, Trevor Cohn, Katerina Vylomova, Kevin Duh, and Chris Dyer. Depth-gated recurrent neural networks. arXiv preprint arXiv:1508.03790, 2015. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. CoRR, 2014. ",
+        "bbox": [
+            174,
+            140,
+            821,
+            170
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler. Adadelta: An adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012. ",
+        "bbox": [
+            173,
+            179,
+            825,
+            208
+        ],
+        "page_idx": 13
+    }
+]

parse/train/ry2YOrcge/ry2YOrcge.md

@@ -0,0 +1,270 @@
+# LEARNING A NATURAL LANGUAGE INTERFACE WITH NEURAL PROGRAMMER
+
+Arvind Neelakantan∗ University of Massachusetts Amherst arvind@cs.umass.edu
+
+Quoc V. Le Google Brain qvl@google.com
+
+Mart´ın Abadi   
+Google Brain   
+abadi@google.com
+
+# Andrew McCallum∗
+
+University of Massachusetts Amherst mccallum@cs.umass.edu
+
+Dario Amodei∗   
+OpenAI   
+damodei@openai.com
+
+# ABSTRACT
+
+Learning a natural language interface for database tables is a challenging task that involves deep language understanding and multi-step reasoning. The task is often approached by mapping natural language queries to logical forms or programs that provide the desired response when executed on the database. To our knowledge, this paper presents the first weakly supervised, end-to-end neural network model to induce such programs on a real-world dataset. We enhance the objective function of Neural Programmer, a neural network with built-in discrete operations, and apply it on WikiTableQuestions, a natural language question-answering dataset. The model is trained end-to-end with weak supervision of question-answer pairs, and does not require domain-specific grammars, rules, or annotations that are key elements in previous approaches to program induction. The main experimental result in this paper is that a single Neural Programmer model achieves $3 4 . 2 \%$ accuracy using only 10,000 examples with weak supervision. An ensemble of 15 models, with a trivial combination technique, achieves $3 7 . 7 \%$ accuracy, which is competitive to the current state-of-the-art accuracy of $3 7 . 1 \%$ obtained by a traditional natural language semantic parser.
+
+# 1 BACKGROUND AND INTRODUCTION
+
+Databases are a pervasive way to store and access knowledge. However, it is not straightforward for users to interact with databases since it often requires programming skills and knowledge about database schemas. Overcoming this difficulty by allowing users to communicate with databases via natural language is an active research area. The common approach to this task is by semantic parsing, which is the process of mapping natural language to symbolic representations of meaning. In this context, semantic parsing yields logical forms or programs that provide the desired response when executed on the databases (Zelle & Mooney, 1996). Semantic parsing is a challenging problem that involves deep language understanding and reasoning with discrete operations such as counting and row selection (Liang, 2016).
+
+The first learning methods for semantic parsing require expensive annotation of question-program pairs (Zelle & Mooney, 1996; Zettlemoyer & Collins, 2005). This annotation process is no longer necessary in the current state-of-the-art semantic parsers that are trained using only question-answer pairs (Liang et al., 2011; Kwiatkowski et al., 2013; Krishnamurthy & Kollar, 2013; Pasupat & Liang, 2015). However, the performance of these methods still heavily depends on domain-specific grammar or pruning strategies to ease program search. For example, in a recent work on building semantic parsers for various domains, the authors hand-engineer a separate grammar for each domain (Wang et al., 2015).
+
+Recently, many neural network models have been developed for program induction (Andreas et al., 2016; Jia & Liang, 2016; Reed & Freitas, 2016; Zaremba et al., 2016; Yin et al., 2015), despite the notorious difficulty of handling discrete operations in neural networks (Joulin & Mikolov, 2015; Kaiser & Sutskever, 2016). Most of these approaches rely on complete programs as supervision (Jia & Liang, 2016; Reed & Freitas, 2016) while others (Zaremba et al., 2016; Yin et al., 2015) have been tried only on synthetic tasks. The work that is most similar to ours is that of Andreas et al. (2016) on the dynamic neural module network. However, in their method, the neural network is employed only to search over a small set of candidate layouts provided by the syntactic parse of the question, and is trained using the REINFORCE algorithm (Williams, 1992). Hence, their method cannot recover from parser errors, and it is not trivial to adapt the parser to the task at hand. Additionally, all their modules or operations are parametrized by a neural network, so it is difficult to apply their method on tasks that require discrete arithmetic operations. Finally, their experiments concern a simpler dataset that requires fewer operations, and therefore a smaller search space, than WikiTableQuestions which we consider in our work. We discuss other related work in Section 4.
+
+![](images/c3fbf422d12a94e9e469c4d9edd7cabf43b9708d865779a1944e2cfd424cee5d.jpg)  
+Figure 1: Neural Programmer is a neural network augmented with a set of discrete operations. The model runs for a fixed number of time steps, selecting an operation and a column from the table at every time step. The induced program transfers information across timesteps using the row selector variable while the output of the model is stored in the scalar answer and lookup answer variables.
+
+Neural Programmer (Neelakantan et al., 2016) is a neural network augmented with a set of discrete operations. It produces both a program, made up of those operations, and the result of running the program against a given table. The operations make use of three variables: row selector, scalar answer, and lookup answer, which are updated at every timestep. lookup answer and scalar answer store answers while row selector is used to propagate information across time steps. As input, a model receives a question along with a table (Figure 1). The model runs for a fixed number of time steps, selecting an operation and a column from the table as the argument to the operation at each time step. During training, soft selection (Bahdanau et al., 2014) is performed so that the model can be trained end-to-end using backpropagation. This approach allows Neural Programmer to explore the search space with better sample complexity than hard selection with the REINFORCE algorithm (Williams, 1992) would provide. All the parameters of the model are learned from a weak supervision signal that consists of only the final answer; the underlying program, which consists of a sequence of operations and of selected columns, is latent.
+
+In this work, we develop an approach to semantic parsing based on Neural Programmer. We show how to learn a natural language interface for answering questions using database tables, thus integrating differentiable operations that are typical of neural networks with the declarative knowledge contained in the tables and with discrete operations on tables and entries. For this purpose, we make several improvements and adjustments to Neural Programmer, in particular adapting its objective function to make it more broadly applicable.
+
+In earlier work, Neural Programmer is applied only on a synthetic dataset. In that dataset, when the expected answer is an entry in the given table, its position is explicitly marked in the table. However, real-world datasets certainly do not include those markers, and lead to many ambiguities (e.g., (Pasupat & Liang, 2015)). In particular, when the answer is a number that occurs literally in the table, it is not known, a priori, whether the answer should be generated by an operation or selected from the table. Similarly, when the answer is a natural language phrase that occurs in multiple positions in the table, it is not known which entry (or entries) in the table is actually responsible for the answer. We extend Neural Programmer to handle the weaker supervision signal by backpropagating through decisions that concern how the answer is generated when there is an ambiguity.
+
+Our main experimental results concern WikiTableQuestions (Pasupat & Liang, 2015), a real-world question-answering dataset on database tables, with only 10,000 examples for weak supervision. This dataset is particularly challenging because of its small size and the lack of strong supervision, and also because the tables provided at test time are never seen during training, so learning requires adaptation at test time to unseen column names. A state-of-the-art, traditional semantic parser that relies on pruning strategies to ease program search achieves $3 7 . 1 \%$ accuracy. Standard neural network models like sequence-to-sequence and pointer networks do not appear to be promising for this dataset, as confirmed in our experiments below, which yield single-digit accuracies. In comparison, a single Neural Programmer model using minimal text pre-processing, and trained end-to-end, achieves $3 4 . 2 \%$ accuracy. This surprising result is enabled primarily by the sample efficiency of Neural Programmer, by the enhanced objective function, and by reducing overfitting via strong regularization with dropout (Srivastava et al., 2014; Iyyer et al., 2015; Gal & Ghahramani, 2016) and weight decay. An ensemble of 15 models, even with a trivial combination technique, achieves $3 7 . 7 \%$ accuracy.
+
+# 2 NEURAL PROGRAMMER
+
+In this section we describe in greater detail the Neural Programmer model and the modifications we made to the model. Neural Programmer is a neural network augmented with a set of discrete operations. The model consists of four modules:
+
+• Question RNN that processes the question and converts the tokens to a distributed representation. We use an LSTM network (Hochreiter & Schmidhuber, 1997) as the question RNN.   
+• A list of discrete operations such as counting and entry selection that are manually defined. Each operation is parameterized by a real-valued vector that is learned during training.   
+• A selector module that induces two probability distributions at every time step, one over the set of operations and another over the set of columns. The input to the selector is obtained by concatenating the last hidden state of the question RNN, the hidden state of the history RNN from the current timestep, and the attention vector obtained by performing soft attention (Bahdanau et al., 2014) on the question using the history vector. Following Neelakantan et al. (2016), we employ hard selection at test time. History RNN modeled by a simple RNN (Werbos, 1990) with tanh activations which remembers the previous operations and columns selected by the model. The input to the history RNN at each timestep is the result of concatenating the weighted representations of operations and columns with their corresponding probability distributions produced by the selector at the previous timestep.
+
+A more detailed description of the basic model can be found in Neelakantan et al. (2016). The model runs for fixed total of $T$ timesteps. The parameters of the operations, selector module, question and history RNNs are all learned with backpropagation using a weak supervision signal that consists of the final answer. Below, we discuss several modifications to the model to make it more broadly applicable, and easier to train.
+
+# 2.1 OPERATIONS
+
+We use 15 operations in the model that were chosen to closely match the set of operations used in the baseline model (Pasupat & Liang, 2015). All the operations except select and most frequent entry operate only on the set of selected rows which is given by the row selector variable. Before the first timestep, all the rows in the table are set to be selected. The built-in operations are:
+
+• count returns the number of selected rows in row selector.   
+• select and most frequent entry are operations which are computed only once for every question and output a boolean tensor with size same as the size of the input table. An entry in the output of the select operation is set to 1 if the entry matches some phrase in the question. The matched phrases in the question are anonymized to prevent overfitting. Similarly, for most frequent entry, it is set to 1 if the entry is the most frequently occurring one in its column.   
+• argmax, argmin, greater than, less than, greater than or equal to, less than or equal to are all operations that output a tensor with size same as the size of the input table.   
+• first, last, previous and next modify the row selector.   
+• print operation assigns row selector on the selected column of lookup answer.   
+• reset resets row selector to its initial value. This operation also serves as no-op when the model needs to induce programs whose complexity is less than $T$ .
+
+All the operations are defined to work with soft selection so that the model can be trained with backpropagation. The operations along with their definitions are discussed in the Appendix.
+
+# 2.2 OUTPUT AND ROW SELECTOR
+
+Neural programmer makes use of three variables: row selector, scalar answer and lookup answer which are updated at every timestep. The variable lookup answer stores answers that are selected from the table while scalar answer stores numeric answers that are not provided in the table.1 The induced program transfers information across timesteps using the row selector variable which contains rows that are selected by the model.
+
+Given an input table $\Pi$ , containing $M$ rows and $C$ columns ( $M$ and $C$ can vary across examples), the output variables at timestep $t$ are given by:
+
+sc $\begin{array} { r l } & { \times a l a r \ a n s w e r _ { t } = \alpha _ { t } ^ { o p } ( c o u n t ) o u t p u t _ { t } ( c o u n t ) , } \\ & { o k u p \ a n s w e r _ { t } [ i ] [ j ] = \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( p r i n t ) r o w \ s e l e c t _ { t - t } [ i ] , \forall ( i , j ) i = 1 , 2 , . . . , M , j = 1 , 2 , . . . , C } \end{array}$ lo where $\alpha _ { t } ^ { o p } ( o p )$ and $\alpha _ { t } ^ { c o l } ( j )$ are the probabilities assigned by the selector to operation $o p$ and column $j$ at timestep $t$ respectively and $o u t p u t _ { t } ( c o u n t )$ is the output of the count operation at timestep $t$ . The row selector variable at timestep $t$ is obtained by taking the weighted average of the outputs of the remaining operations and is discussed in the Appendix. lookup answerT $[ i ] [ j ]$ is the probability that the element $( i , j )$ in the input table is in the final answer predicted by the model.
+
+# 2.3 TRAINING OBJECTIVE
+
+We modify the training objective of Neural Programmer to handle the supervision signal available in real-world settings. In previous work, the position of the answers are explicitly marked in the table when the answer is an entry from the table. However, as discussed in Section 1, in real-world datasets (e.g., (Pasupat & Liang, 2015)) the answer is simply written down introducing two kinds of ambiguities. First, when the answer is a number and if the number is in the table, it is not known whether the loss should be computed using the scalar answer variable or the lookup answer variable. Second, when the answer is a natural language phrase and if the phrase occurs in multiple positions in the table, we again do not know which entry (or entries) in the table is actually responsible for generating the answer. We extend Neural Programmer to handle this weaker supervision signal during training by computing the loss only on the prediction that is closest to the desired response.
+
+For scalar answers we compute the square loss:
+
+$$
+L _ { s c a l a r } ( s c a l a r ~ a n s w e r _ { T } , y ) = \frac { 1 } { 2 } ( s c a l a r ~ a n s w e r _ { T } - y ) ^ { 2 }
+$$
+
+where $y$ is the ground truth answer. We divide $L _ { s c a l a r }$ by the number of rows in the input table and do not backpropagate on examples for which the loss is greater than a threshold since it leads to instabilities in training.
+
+When the answer is a list of items $y \ = \ ( a _ { 1 } , a _ { 2 } , . . . , a _ { N } )$ , for each element in the list $( a _ { i } , i { \ = }$ $1 , 2 , \ldots , N )$ we compute all the entries in the table that match that element, given by $S _ { i } ~ =$ $\{ ( r , c ) , \forall ( r , c ) \Pi [ r ] [ { \bar { c } } ] = a _ { i } \}$ . We tackle the ambiguity introduced when an answer item occurs at multiple entries in the table by computing the loss only on the entry which is assigned the highest probability by the model. We construct $g \in \{ 0 , 1 \} ^ { M \times C }$ , where $g [ i , j ]$ indicates whether the element $( i , j )$ in the input table is part of the output. We compute log-loss for each entry and the final loss is given by:
+
+$$
+\begin{array} { l } { { \displaystyle { \cal L } _ { l o o k u p } ( l o o k u p ~ a n s w e r _ { T } , y ) = \sum _ { i = 1 } ^ { N } m i n _ { ( r , c ) \in S _ { i } } ( - \log ( l o o k u p ~ a n s w e r _ { T } [ r , c ] ) ) } \ ~ } \\ { { \displaystyle ~ - \ \frac { 1 } { M C } \sum _ { i = 1 } ^ { M } \sum _ { j = 1 } ^ { C } [ g [ i , j ] ~ = = \ 0 ] \log ( 1 - l o o k u p ~ a n s w e r _ { T } [ i , j ] ) } } \end{array}
+$$
+
+where $[ c o n d ]$ is 1 when cond is True, and 0 otherwise.
+
+We deal with the ambiguity that occurs when the ground truth is a number and if the number also occurs in the table, by computing the final loss as the soft minimum of $L _ { s c a l a r }$ and $L _ { l o o k u p }$ . Otherwise, the loss for an example is $L _ { s c a l a r }$ when the ground truth is a number and $L _ { l o o k u p }$ when the ground truth matches some entries in the table. The two loss functions $L _ { s c a l a r }$ and $L _ { l o o k u p }$ are in different scales, so we multiply $L _ { l o o k u p }$ by a constant factor which we set to 50.0 after a small exploration in our experiments.
+
+Since we employ hard selection at test time, only one among scalar answer and lookup answer is modified at the last timestep. We use the variable that is set at the last timestep as the final output of the model.
+
+# 3 EXPERIMENTS
+
+We apply Neural Programmer on the WikiTableQuestions dataset (Pasupat & Liang, 2015) and compare it to different non-neural baselines including a natural language semantic parser developed by Pasupat & Liang (2015). Further, we also report results from training the sequence-tosequence model (Sutskever et al., 2014) and a modified version of the pointer networks (Vinyals et al., 2015). Our model is implemented in TensorFlow (Abadi et al., 2016) and the model takes approximately a day to train on a single Tesla K80 GPU. We use double-precision format to store the model parameters since the gradients become undefined values in single-precision format. Our code is available at https://github.com/tensorflow/models/tree/master/neural_ programmer.
+
+# 3.1 DATA
+
+We use the train, development, and test split given by Pasupat & Liang (2015). The dataset contains 11321, 2831, and 4344 examples for training, development, and testing respectively. We use their tokenization, number and date pre-processing. There are examples with answers that are neither number answers nor phrases selected from the table. We ignore these questions during training but the model is penalized during evaluation following Pasupat & Liang (2015). The tables provided in the test set are unseen at training, hence requiring the model to adapt to unseen column names at test time. We train only on examples for which the provided table has less than 100 rows since we run out of GPU memory otherwise, but consider all examples at test time.
+
+Table 1: Performance of Neural Programmer compared to baselines from (Pasupat & Liang, 2015). The performance of an ensemble of 15 models is competitive to the current state-of-the-art natural language semantic parser.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Dev Accuracy</td><td rowspan=1 colspan=1>Test Accuracy</td></tr><tr><td rowspan=1 colspan=3>Baselines from Pasupat &amp; Liang (2015)</td></tr><tr><td rowspan=1 colspan=1>InformationRetrieval System</td><td rowspan=1 colspan=1>13.4</td><td rowspan=1 colspan=1>12.7</td></tr><tr><td rowspan=1 colspan=1>Simple Semantic Parser</td><td rowspan=1 colspan=1>23.6</td><td rowspan=1 colspan=1>24.3</td></tr><tr><td rowspan=1 colspan=1>Semantic Parser</td><td rowspan=1 colspan=1>37.0</td><td rowspan=1 colspan=1>37.1</td></tr><tr><td rowspan=1 colspan=3>Neural Programmer</td></tr><tr><td rowspan=1 colspan=1>Neural Programmer</td><td rowspan=1 colspan=1>34.1</td><td rowspan=1 colspan=1>34.2</td></tr><tr><td rowspan=1 colspan=1>Ensemble of 15 Neural Programmer models</td><td rowspan=1 colspan=1>37.5</td><td rowspan=1 colspan=1>37.7</td></tr><tr><td rowspan=1 colspan=1>Oracle Score with 15 Neural Programmer models</td><td rowspan=1 colspan=1>50.5</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+# 3.2 TRAINING DETAILS
+
+We use $T = 4$ timesteps in our experiments. Words and operations are represented as 256 dimensional vectors, and the hidden vectors of the question and the history RNN are also 256 dimensional. The parameters are initialized uniformly randomly within the range [-0.1, 0.1]. We train the model using the Adam optimizer (Kingma & Ba, 2014) with mini-batches of size 20. The $\epsilon$ hyperparameter in Adam is set to 1e-6 while others are set to the default values. Since the training set is small compared to other datasets in which neural network models are usually applied, we rely on strong regularization:
+
+• We clip the gradients to norm 1 and employ early-stopping.   
+• The occurrences of words that appear less than 10 times in the training set are replaced by a single unknown word token.   
+• We add a weight decay penalty with strength 0.0001.   
+• We use dropout with a keep probability of 0.8 on input and output vectors of the RNN, and selector, operation and column name representations (Srivastava et al., 2014). We use dropout with keep probability of 0.9 on the recurrent connections of the question RNN and history RNN using the technique from Gal & Ghahramani (2016). We use word-dropout (Iyyer et al., 2015) with keep probability of 0.9. Here, words in the question are randomly replaced with the unknown word token while training.
+
+We tune the dropout rates, regularization strength, and the $\epsilon$ hyperparameter using grid search on the development data, we fix the other hyperparameters after a small exploration during initial experiments.
+
+# 3.3 RESULTS
+
+Table 1 shows the performance of our model in comparison to baselines from Pasupat & Liang (2015). The best result from Neural Programmer is achieved by an ensemble of 15 models. The only difference among these models is that the parameters of each model is initialized with a different random seed. We combine the models by averaging the predicted softmax distributions of the models at every timestep. While it is generally believed that neural network models require a large number of training examples compared to simpler linear models to get good performance, our model
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Dev Accuracy</td></tr><tr><td rowspan=1 colspan=1>NeuralProgrammer</td><td rowspan=1 colspan=1>34.1</td></tr><tr><td rowspan=1 colspan=1>NeuralProgrammer-anonymization</td><td rowspan=1 colspan=1>33.7</td></tr><tr><td rowspan=1 colspan=1>Neural Programmer - match feature</td><td rowspan=1 colspan=1>31.1</td></tr><tr><td rowspan=1 colspan=1>Neural Programmer - {dropout,weight decay}</td><td rowspan=1 colspan=1>30.3</td></tr></table>
+
+Table 2: Model ablation studies. We find that dropout and weight decay, along with the boolean feature indicating a matched table entry for column selection, have a significant effect on the performance of the model.
+
+achieves competitive performance on this small dataset containing only 10,000 examples with weak supervision.
+
+We did not get better results either by using pre-trained word vectors (Mikolov et al., 2013) or by pre-training the question RNN with a language modeling objective (Dai & Le, 2015). A possible explanation is that the word vectors obtained from unsupervised learning may not be suitable to the task under consideration. For example, the learned representations of words like maximum and minimum from unsupervised learning are usually close to each other but for our task it is counterproductive. We consider replacing soft selection with hard selection and training the model with the REINFORCE algorithm (Williams, 1992). The model fails to learn in this experiment, probably because the model has to search over millions of symbolic programs for every input question making it highly unlikely to find a program that gives a reward. Hence, the parameters of the model are not updated frequently enough.
+
+# 3.3.1 NEURAL NETWORK BASELINES
+
+To understand the difficulty of the task for neural network models, we experiment with two neural network baselines: the sequence-to-sequence model (Sutskever et al., 2014) and a modified version of the pointer networks (Vinyals et al., 2015). The input to the sequence-to-sequence model is a concatenation of the table and the question, and the decoder produces the output one token at a time. We consider only examples whose input length is less than 400 to make the running time reasonable. The resulting dataset has 8, 857 and 1, 623 training and development examples respectively. The accuracy of the best model on this development set after hyperparameter tuning is only $8 . 9 \%$ . Next, we experiment with pointer networks to select entries in the table as the final answer. We modify pointer networks to have two-attention heads: one to select the column and the other to select entries within a column. Additionally, the model performs multiple pondering steps on the table before returning the final answer. We train this model only on lookup questions, since the model does not have a decoder to generate answers. We consider only examples whose tables have less than 100 rows resulting in training and development set consisting of 7, 534 and 1, 829 examples respectively. The accuracy of the best model on this development set after hyperparameter tuning is only $4 . 0 \dot { \% }$ . These results confirm our intuition that discrete operations are hard to learn for neural networks particularly with small datasets in real-world settings.
+
+# 3.4 ANALYSIS
+
+# 3.4.1 MODEL ABLATION
+
+Table 2 shows the impact of different model design choices on the final performance. While anonymizing phrases in the question that match some table entry seems to have a small positive effect, regularization has a much larger effect on the performance. Column selection is performed in Neelakantan et al. (2016) using only the name of a column; however, this selection procedure is insufficient in real-world settings. For example the column selected in question 3 in Table 3 does not have a corresponding phrase in the question. Hence, to select a column we additionally use a boolean feature that indicates whether an entry in that column matches some phrase in the question. Table 2 shows that the addition of this boolean feature has a significant effect on performance.
+
+<table><tr><td rowspan=1 colspan=1>ID</td><td rowspan=1 colspan=1>Question</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Step 1</td><td rowspan=1 colspan=1>Step 2</td><td rowspan=1 colspan=1>Step 3</td><td rowspan=1 colspan=1>Step 4</td></tr><tr><td rowspan=2 colspan=1>1</td><td rowspan=2 colspan=1>what is the total number ofteams?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>count</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=2 colspan=1>2</td><td rowspan=2 colspan=1>how many games had morethan 1,5oO in attendance?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>&gt;=</td><td rowspan=1 colspan=1>count</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>attendance</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=2 colspan=1>what is the total numberof runner-ups listed on thechart?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>count</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>outcome</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=2 colspan=1>4</td><td rowspan=2 colspan=1>which year held the mostcompetitions?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>mfe</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>year</td><td rowspan=1 colspan=1>year</td></tr><tr><td rowspan=2 colspan=1>5</td><td rowspan=2 colspan=1>what opponent is listed laston the table?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>last</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>last</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>opponent</td></tr><tr><td rowspan=2 colspan=1>6</td><td rowspan=2 colspan=1>which section is longest??</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>argmax</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>kilometers</td><td rowspan=1 colspan=1>name</td></tr><tr><td rowspan=2 colspan=1>7</td><td rowspan=2 colspan=1>which engine(s) has the leastamount of power?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>argmin</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>power</td><td rowspan=1 colspan=1>engine</td></tr><tr><td rowspan=2 colspan=1>8</td><td rowspan=2 colspan=1>whatwas claudia roll&#x27;stime?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>swimmer</td><td rowspan=1 colspan=1>time</td></tr><tr><td rowspan=2 colspan=1>9</td><td rowspan=2 colspan=1>who had more silver medals,cuba or brazil?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>argmax</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>argmax</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>nation</td><td rowspan=1 colspan=1>nation</td><td rowspan=1 colspan=1>silver</td><td rowspan=1 colspan=1>nation</td></tr><tr><td rowspan=2 colspan=1>10</td><td rowspan=2 colspan=1>who was the next appointeddirector after lee p. brown?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>next</td><td rowspan=1 colspan=1>last</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>name</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>name</td></tr><tr><td rowspan=2 colspan=1>11</td><td rowspan=2 colspan=1>what team is listed previousto belgium?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>previous</td><td rowspan=1 colspan=1>first</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>team</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>team</td></tr></table>
+
+Table 3: A few examples of programs induced by Neural Programmer that generate the correct answer in the development set. mfe is abbreviation for the operation most frequent entry. The model runs for 4 timesteps selecting an operation and a column at every step. The model employs hard selection during evaluation. The column name is displayed in the table only when the operation picked at that step takes in a column as input while the operation is displayed only when it is other than the reset operation. Programs that choose count as the final operation produce a number as the final answer while programs that select print as the final operation produce entries selected from the table as the final answer.
+
+<table><tr><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>Program in Table 3Amount (%)</td><td rowspan=1 colspan=1>Amount (%)</td></tr><tr><td rowspan=1 colspan=3>Scalar Answer</td></tr><tr><td rowspan=1 colspan=1>Only Count</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>6.5</td></tr><tr><td rowspan=1 colspan=1>Comparison+ Count</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2.1</td></tr><tr><td rowspan=1 colspan=1>Select + Count</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>22.1</td></tr><tr><td rowspan=1 colspan=1>Scalar Answer</td><td rowspan=1 colspan=1>1,2,3</td><td rowspan=1 colspan=1>30.7</td></tr><tr><td rowspan=1 colspan=3>Lookup Answer</td></tr><tr><td rowspan=1 colspan=1>Most Frequent Entry + Print</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1.7</td></tr><tr><td rowspan=1 colspan=1>First/Last+Print</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>9.5</td></tr><tr><td rowspan=1 colspan=1>Superlative+Print</td><td rowspan=1 colspan=1>6.7</td><td rowspan=1 colspan=1>13.5</td></tr><tr><td rowspan=1 colspan=1>Select+Print</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>17.5</td></tr><tr><td rowspan=1 colspan=1>Select + {first, last, previous, next, superlative} + Print</td><td rowspan=1 colspan=1>9-11</td><td rowspan=1 colspan=1>27.1</td></tr><tr><td rowspan=1 colspan=1>Lookup Answer</td><td rowspan=1 colspan=1>4-11</td><td rowspan=1 colspan=1>69.3</td></tr></table>
+
+Table 4: Statistics of the different sequence of operations among the examples answered correctly by the model in the development set. For each sequence of operations in the table, we also point to corresponding example programs in Table 3. Superlative operations include argmax and argmin, while comparison operations include greater than, less than, greater than or equal to and less than or equal to. The model induces a program that results in a scalar answer $3 0 . 7 \%$ of the time while the induced program is a table lookup for the remaining questions. print and select are the two most common operations used $6 9 . 3 \%$ and $6 6 . 7 \%$ of the time respectively.
+
+# 3.4.2 INDUCED PROGRAMS
+
+Table 3 shows few examples of programs induced by Neural Programmer that yield the correct answer in the development set. The programs given in Table 3 show a few characteristics of the learned model. First, our analysis indicates that the model can adapt to unseen column names at test time. For example in Question 3, the word outcome occurs only 8 times in the training set and is replaced with the unknown word token. Second, the model does not always induce the most efficient (with respect to number of operations other than the reset operation that are picked) program to solve a task. The last 3 questions in the table can be solved using simpler programs. Finally, the model does not always induce the correct program to get the ground truth answer. For example, the last 2 programs will not result in the correct response for all input database tables. The programs would produce the correct response only when the select operation matches one entry in the table.
+
+# 3.4.3 CONTRIBUTION OF DIFFERENT OPERATIONS
+
+Table 4 shows the contribution of the different operations. The model induces a program that results in a scalar answer $3 0 . 7 \%$ of the time while the induced program is a table lookup for the remaining questions. The two most commonly used operations by the model are print and select.
+
+# 3.4.4 ERROR ANALYSIS
+
+To conclude this section, we suggest ideas to potentially improve the performance of the model. First, the oracle performance with 15 Neural Programmer models is $5 0 . 5 \%$ on the development set while averaging achieves only $3 7 . 5 \%$ implying that there is still room for improvement. Next, the accuracy of a single model on the training set is $5 3 \%$ which is about $20 \%$ higher than the accuracy in both the development set and the test set. This difference in performance indicates that the model suffers from significant overfitting even after employing strong regularization. It also suggests that the performance of the model could be greatly improved by obtaining more training data. Nevertheless, there are limits to the performance improvements we may reasonably expect: in particular, as shown in previous work (Pasupat & Liang, 2015), $21 \%$ of questions on a random set of 200 examples in the considered dataset are not answerable because of various issues such as annotation errors and tables requiring advanced normalization.
+
+# 4 OTHER RELATED WORK
+
+While we discuss in detail various semantic parsing and neural program induction techniques in Section 1, here we briefly describe other relevant work. Recently, Kocisky et al. (2016) develop a semi-supervised semantic parsing method that uses question-program pairs as supervision. Concurrently to our work, Liang et al. (2016) propose neural symbolic machine, a model very similar to Neural Programmer but trained using the REINFORCE algorithm (Williams, 1992). They use only 2 discrete operations and run for a total of 3 timesteps, hence inducing programs that are much simpler than ours. Neural networks have also been applied on question-answering datasets that do not require much arithmetic reasoning (Bordes et al., 2014; Iyyer et al., 2014; Sukhbaatar et al., 2015; Peng et al., 2015; Hermann et al., 2015; Kumar et al., 2016). Wang & Jiang (2016) use a neural network model to get state-of-the-art results on a reading comprehension task (Rajpurkar et al., 2016).
+
+# 5 CONCLUSION
+
+In this paper, we enhance Neural Programmer to work with weaker supervision signals to make it more broadly applicable. Soft selection during training enables the model to actively explore the space of programs by backpropagation with superior sample complexity. In our experiments, we show that the model achieves performance comparable to a state-of-the-art traditional semantic parser even though the training set contains only 10,000 examples. To our knowledge, this is the first instance of a weakly supervised, end-to-end neural network model that induces programs on a real-world dataset.
+
+Acknowledgements We are grateful to Panupong Pasupat for answering numerous questions about the dataset, and providing pre-processed version of the dataset and the output of the semantic parser. We thank David Belanger, Samy Bengio, Greg Corrado, Andrew Dai, Jeff Dean, Nando de Freitas, Shixiang Gu, Navdeep Jaitly, Rafal Jozefowicz, Ashish Vaswani, Luke Vilnis, Yuan Yu and Barret Zoph for their suggestions and the Google Brain team for the support. Arvind Neelakantan is supported by a Google PhD fellowship in machine learning.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz ´ Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Gor- ´ don Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul A. Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viegas, Oriol Vinyals, ´ Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. ArXiv, 2016.
+
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Learning to compose neural networks for question answering. NAACL, 2016.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. ICLR, 2014.
+
+Antoine Bordes, Sumit Chopra, and Jason Weston. Question answering with subgraph embeddings. EMNLP, 2014.
+
+Andrew M Dai and Quoc V Le. Semi-supervised sequence learning. NIPS, 2015.
+
+Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. NIPS, 2016.
+
+Karl Moritz Hermann, Tomas Kocisk ´ y, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa ´ Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. NIPS, 2015.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 1997.
+
+Mohit Iyyer, Jordan L. Boyd-Graber, Leonardo Max Batista Claudino, Richard Socher, and Hal Daume III. A neural network for factoid question answering over paragraphs. ´ EMNLP, 2014.
+
+Mohit Iyyer, Varun Manjunatha, Jordan Boyd-Graber, and Hal Daume III. Deep unordered compo- ´ sition rivals syntactic methods for text classification. ACL, 2015.
+
+Robin Jia and Percy Liang. Data recombination for neural semantic parsing. ACL, 2016.
+
+Armand Joulin and Tomas Mikolov. Inferring algorithmic patterns with stack-augmented recurrent nets. NIPS, 2015.
+
+Lukasz Kaiser and Ilya Sutskever. Neural gpus learn algorithms. ICLR, 2016.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2014.
+
+Tomas Kocisky, Gabor Melis, Edward Grefenstette, Chris Dyer, Wang Ling, Phil Blunsom, and Karl Moritz Hermann. Semantic parsing with semi-supervised sequential autoencoders. ArXiv, 2016.
+
+Jayant Krishnamurthy and Thomas Kollar. Jointly learning to parse and perceive: Connecting natural language to the physical world. TACL, 2013.
+
+Ankit Kumar, Ozan Irsoy, Jonathan Su, James Bradbury, Robert English, Brian Pierce, Peter Ondruska, Ishaan Gulrajani, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. ICML, 2016.
+
+Tom Kwiatkowski, Eunsol Choi, Yoav Artzi, and Luke Zettlemoyer. Scaling semantic parsers with on-the-fly ontology matching. EMNLP, 2013.
+
+Chen Liang, Jonathan Berant, Quoc Le, Kenneth Forbus, and Ni Lao. Neural symbolic machines: Learning semantic parsers on freebase with weak supervision. NAMPI Workshop, NIPS, 2016.
+
+Percy Liang. Learning executable semantic parsers for natural language understanding. ACM, 2016.
+
+Percy Liang, Michael I. Jordan, and Dan Klein. Learning dependency-based compositional semantics. ACL, 2011.
+
+Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. ArXiv, 2013.
+
+Arvind Neelakantan, Quoc V. Le, and Ilya Sutskever. Neural programmer: Neural programmer: Inducing latent programs with gradient descent. ICLR, 2016.
+
+Panupong Pasupat and Percy Liang. Compositional semantic parsing on semi-structured tables. ACL, 2015.
+
+Baolin Peng, Zhengdong Lu, Hang Li, and Kam-Fai Wong. Towards neural network-based reasoning. ArXiv, 2015.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: 100, $0 0 0 +$ questions for machine comprehension of text. ArXiv, 2016.
+
+Scott Reed and Nando De Freitas. Neural programmer-interpreters. ICLR, 2016.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. NIPS, 2015.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. NIPS, 2014.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. NIPS, 2015.
+
+Shuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. ArXiv, 2016.
+
+Yushi Wang, Jonathan Berant, and Percy Liang. Building a semantic parser overnight. ACL, 2015.
+
+P. Werbos. Backpropagation through time: what does it do and how to do it. Proceedings of IEEE, 1990.
+
+Ronald Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 1992.
+
+Pengcheng Yin, Zhengdong Lu, Hang Li, and Ben Kao. Neural enquirer: Learning to query tables with natural language. ArXiv, 2015.
+
+Wojciech Zaremba, Tomas Mikolov, Armand Joulin, and Rob Fergus. Learning simple algorithms from examples. ICML, 2016.
+
+John M. Zelle and Raymond J. Mooney. Learning to parse database queries using inductive logic programming. AAAI/IAAI, 1996.
+
+Luke S. Zettlemoyer and Michael Collins. Learning to map sentences to logical form: Structured classification with probabilistic categorial grammars. UAI, 2005.
+
+<table><tr><td rowspan=1 colspan=1>Type</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=3>Definition</td></tr><tr><td rowspan=1 colspan=1>Aggregate</td><td rowspan=1 colspan=1>count</td><td rowspan=1 colspan=3>Mcountt =∑ row_selectt-1[i]i=1</td></tr><tr><td rowspan=2 colspan=1>Superlative</td><td rowspan=1 colspan=1>argmax</td><td rowspan=1 colspan=3>maxt[i][j]=max(O.0,row_selectt-1[i]-C([[[i][]]&lt;I[k][j]] × row_selectt-1[k])),i=1,...,M,j=1,...,C</td></tr><tr><td rowspan=1 colspan=1>argmin</td><td rowspan=1 colspan=3>mint[i][j]=max(O.0,row_selectt-1[i]-M([[i][j] &gt; I[k][j]] × row_select-1[k])),i=1,...,M,j =1,...,C</td></tr><tr><td rowspan=4 colspan=1>Comparison</td><td rowspan=1 colspan=1>&gt;</td><td rowspan=1 colspan=1>gi][i]=II</td><td rowspan=1 colspan=1>illi</td><td rowspan=1 colspan=1>g[i][j]= I[i][] &gt; pivotg,V(i,j),i= 1,...,M,j = 1,...,C</td></tr><tr><td rowspan=1 colspan=1>&lt;</td><td rowspan=1 colspan=1>[i][=II</td><td rowspan=1 colspan=1>i]i</td><td rowspan=1 colspan=1>li][j]=I[i][]&lt; pivot,V(i,j),i =1,...,M,j=1,...,C</td></tr><tr><td rowspan=1 colspan=1>M</td><td rowspan=1 colspan=1>geii=II</td><td rowspan=1 colspan=1>il</td><td rowspan=1 colspan=1>geli]l]= I[𝑖]j]≥ pivotge,∀(i,j),i = 1,...,M,j = 1,...,C</td></tr><tr><td rowspan=1 colspan=1>≤</td><td rowspan=1 colspan=2>leij=Iij</td><td rowspan=1 colspan=1>le[i][j]=II[i][j]≤ pivote,V(i,j),i=1,...,M,j=1,...,C</td></tr><tr><td rowspan=6 colspan=1>Table Ops</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=3>s[i][j]= 1.O if II[i]lj] appears in question else 0.0,∀(i,j),i=1,...,M,j =1,...,C</td></tr><tr><td rowspan=1 colspan=1>mfe</td><td rowspan=1 colspan=3>mfe[i][j]=1.O if I[i]lj] is the most common entry in column j else 0.0,∀(i,j),i =1,...,M,j=1,.,C</td></tr><tr><td rowspan=1 colspan=1>first</td><td rowspan=1 colspan=3>i=1,...,M</td></tr><tr><td rowspan=1 colspan=1>last</td><td rowspan=1 colspan=3>i=1,...,M</td></tr><tr><td rowspan=1 colspan=1>previous</td><td rowspan=1 colspan=3>Pt[]= row_selectt-1[i+ 1],i=1,...,M-1;pt[M]=0</td></tr><tr><td rowspan=1 colspan=1>next</td><td rowspan=1 colspan=3>nt[i]=row_selectt-1[i-1],i=2,...,M;nt[1]=0</td></tr><tr><td rowspan=1 colspan=1>Print</td><td rowspan=1 colspan=1>print</td><td rowspan=1 colspan=3>lookup answert[il[i]= row_selectt-1[i],∀(i,j)i=1,...,M,j =1,...,C</td></tr><tr><td rowspan=1 colspan=1>Reset</td><td rowspan=1 colspan=1>reset</td><td rowspan=1 colspan=3>rt[]=1,Vi =1,2,...,M</td></tr></table>
+
+Table 5: List of all operations provided to the model along with their definitions. mfe is abbreviation for the operation most frequent entry. [cond] is 1 when cond is True, and 0 otherwise. Comparison, select, reset and mfe operations are independent of the timestep while all the other operations are computed at every time step. Superlative operations and most frequent entry are computed within a column. The operations calculate the expected output with the respect to the membership probabilities given by the row selector so that they can work with probabilistic selection.
+
+# APPENDIX
+
+# OPERATIONS
+
+Table 5 shows the list of operations built into the model along with their definitions.
+
+ROW SELECTOR
+
+As discussed in Section 2.3, the output variables scalar answer and lookup answer are calculated using the output of the count operations and print operation respectively. The row selector is computed using the output of the remaining operations and is given by,
+
+$$
+\begin{array} { l } { { r o w ~ s e l e c t o r } [ \hat { l } ] = \displaystyle \sum _ { j = 1 } ^ { C } \{ \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( > ) g [ \hat { l } ] [ j ] + \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( < ) l [ \hat { l } ] [ j ] }  \\ { ~ + ~ \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( \ge ) g [ \hat { l } ] [ j ] + \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( \le ) l [ \hat { l } ] [ j ] , }  \\ { { ~ + ~ \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( a r g m a x ) m a x [ \hat { l } ] j ] + \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( a r g m i n _ { t } ) m i n [ \hat { l } ] [ j ] , } } \\ { { ~ + ~ \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( s e l e c t ) s [ i ] [ j ] + \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( m f e ) m f e [ \hat { l } ] [ j ] ] } } \\ { { ~ + ~ \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( s e l e c t ) s [ i ] [ j ] + \alpha _ { t } ^ { c o l } ( j ) \alpha _ { t } ^ { o p } ( m f e ) m f e [ \hat { l } ] [ j ] ] } } \\ { { ~ + ~ \alpha _ { t } ^ { o p } ( p r e v i o u s ) p _ { t } [ \hat { l } ] + \alpha _ { t } ^ { o p } ( m e x t ) n _ { t } [ \hat { l } ] + \alpha _ { t } ^ { o p } ( r e s e t ) r _ { t } [ \hat { l } ] } } \\ { { ~ + ~ \alpha _ { t } ^ { e o p } ( f i r s t ) f [ \hat { l } ] + \alpha _ { t } ^ { o p } ( l a s t ) l a _ { t } [ \hat { l } ] } } \\ { { ~ \forall i , i = 1 , 2 , . . . , ~ M } } \end{array}
+$$
+
+where $\alpha _ { t } ^ { o p } ( o p )$ and $\alpha _ { t } ^ { c o l } ( j )$ are the probabilities assigned by the selector to operation $o p$ and column $j$ at timestep $t$ respectively.

parse/train/ry2YOrcge/ry2YOrcge_content_list.json

@@ -0,0 +1,1460 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING A NATURAL LANGUAGE INTERFACE WITH NEURAL PROGRAMMER ",
+        "text_level": 1,
+        "bbox": [
+            215,
+            98,
+            784,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Arvind Neelakantan∗ University of Massachusetts Amherst arvind@cs.umass.edu ",
+        "bbox": [
+            184,
+            170,
+            431,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Quoc V. Le Google Brain qvl@google.com ",
+        "bbox": [
+            473,
+            170,
+            612,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi   \nGoogle Brain   \nabadi@google.com ",
+        "bbox": [
+            655,
+            170,
+            813,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Andrew McCallum∗ ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            234,
+            325,
+            246
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "University of Massachusetts Amherst mccallum@cs.umass.edu ",
+        "bbox": [
+            184,
+            248,
+            431,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dario Amodei∗   \nOpenAI   \ndamodei@openai.com ",
+        "bbox": [
+            540,
+            233,
+            720,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            313,
+            544,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning a natural language interface for database tables is a challenging task that involves deep language understanding and multi-step reasoning. The task is often approached by mapping natural language queries to logical forms or programs that provide the desired response when executed on the database. To our knowledge, this paper presents the first weakly supervised, end-to-end neural network model to induce such programs on a real-world dataset. We enhance the objective function of Neural Programmer, a neural network with built-in discrete operations, and apply it on WikiTableQuestions, a natural language question-answering dataset. The model is trained end-to-end with weak supervision of question-answer pairs, and does not require domain-specific grammars, rules, or annotations that are key elements in previous approaches to program induction. The main experimental result in this paper is that a single Neural Programmer model achieves $3 4 . 2 \\%$ accuracy using only 10,000 examples with weak supervision. An ensemble of 15 models, with a trivial combination technique, achieves $3 7 . 7 \\%$ accuracy, which is competitive to the current state-of-the-art accuracy of $3 7 . 1 \\%$ obtained by a traditional natural language semantic parser. ",
+        "bbox": [
+            233,
+            343,
+            764,
+            565
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 BACKGROUND AND INTRODUCTION",
+        "text_level": 1,
+        "bbox": [
+            178,
+            592,
+            503,
+            607
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Databases are a pervasive way to store and access knowledge. However, it is not straightforward for users to interact with databases since it often requires programming skills and knowledge about database schemas. Overcoming this difficulty by allowing users to communicate with databases via natural language is an active research area. The common approach to this task is by semantic parsing, which is the process of mapping natural language to symbolic representations of meaning. In this context, semantic parsing yields logical forms or programs that provide the desired response when executed on the databases (Zelle & Mooney, 1996). Semantic parsing is a challenging problem that involves deep language understanding and reasoning with discrete operations such as counting and row selection (Liang, 2016). ",
+        "bbox": [
+            173,
+            622,
+            825,
+            748
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The first learning methods for semantic parsing require expensive annotation of question-program pairs (Zelle & Mooney, 1996; Zettlemoyer & Collins, 2005). This annotation process is no longer necessary in the current state-of-the-art semantic parsers that are trained using only question-answer pairs (Liang et al., 2011; Kwiatkowski et al., 2013; Krishnamurthy & Kollar, 2013; Pasupat & Liang, 2015). However, the performance of these methods still heavily depends on domain-specific grammar or pruning strategies to ease program search. For example, in a recent work on building semantic parsers for various domains, the authors hand-engineer a separate grammar for each domain (Wang et al., 2015). ",
+        "bbox": [
+            173,
+            755,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, many neural network models have been developed for program induction (Andreas et al., 2016; Jia & Liang, 2016; Reed & Freitas, 2016; Zaremba et al., 2016; Yin et al., 2015), despite the notorious difficulty of handling discrete operations in neural networks (Joulin & Mikolov, 2015; Kaiser & Sutskever, 2016). Most of these approaches rely on complete programs as supervision (Jia & Liang, 2016; Reed & Freitas, 2016) while others (Zaremba et al., 2016; Yin et al., 2015) have been tried only on synthetic tasks. The work that is most similar to ours is that of Andreas et al. (2016) on the dynamic neural module network. However, in their method, the neural network is employed only to search over a small set of candidate layouts provided by the syntactic parse of the question, and is trained using the REINFORCE algorithm (Williams, 1992). Hence, their method cannot recover from parser errors, and it is not trivial to adapt the parser to the task at hand. Additionally, all their modules or operations are parametrized by a neural network, so it is difficult to apply their method on tasks that require discrete arithmetic operations. Finally, their experiments concern a simpler dataset that requires fewer operations, and therefore a smaller search space, than WikiTableQuestions which we consider in our work. We discuss other related work in Section 4. ",
+        "bbox": [
+            176,
+            873,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c3fbf422d12a94e9e469c4d9edd7cabf43b9708d865779a1944e2cfd424cee5d.jpg",
+        "image_caption": [
+            "Figure 1: Neural Programmer is a neural network augmented with a set of discrete operations. The model runs for a fixed number of time steps, selecting an operation and a column from the table at every time step. The induced program transfers information across timesteps using the row selector variable while the output of the model is stored in the scalar answer and lookup answer variables. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            284,
+            150,
+            743,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            569,
+            825,
+            736
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neural Programmer (Neelakantan et al., 2016) is a neural network augmented with a set of discrete operations. It produces both a program, made up of those operations, and the result of running the program against a given table. The operations make use of three variables: row selector, scalar answer, and lookup answer, which are updated at every timestep. lookup answer and scalar answer store answers while row selector is used to propagate information across time steps. As input, a model receives a question along with a table (Figure 1). The model runs for a fixed number of time steps, selecting an operation and a column from the table as the argument to the operation at each time step. During training, soft selection (Bahdanau et al., 2014) is performed so that the model can be trained end-to-end using backpropagation. This approach allows Neural Programmer to explore the search space with better sample complexity than hard selection with the REINFORCE algorithm (Williams, 1992) would provide. All the parameters of the model are learned from a weak supervision signal that consists of only the final answer; the underlying program, which consists of a sequence of operations and of selected columns, is latent. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we develop an approach to semantic parsing based on Neural Programmer. We show how to learn a natural language interface for answering questions using database tables, thus integrating differentiable operations that are typical of neural networks with the declarative knowledge contained in the tables and with discrete operations on tables and entries. For this purpose, we make several improvements and adjustments to Neural Programmer, in particular adapting its objective function to make it more broadly applicable. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In earlier work, Neural Programmer is applied only on a synthetic dataset. In that dataset, when the expected answer is an entry in the given table, its position is explicitly marked in the table. However, real-world datasets certainly do not include those markers, and lead to many ambiguities (e.g., (Pasupat & Liang, 2015)). In particular, when the answer is a number that occurs literally in the table, it is not known, a priori, whether the answer should be generated by an operation or selected from the table. Similarly, when the answer is a natural language phrase that occurs in multiple positions in the table, it is not known which entry (or entries) in the table is actually responsible for the answer. We extend Neural Programmer to handle the weaker supervision signal by backpropagating through decisions that concern how the answer is generated when there is an ambiguity. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our main experimental results concern WikiTableQuestions (Pasupat & Liang, 2015), a real-world question-answering dataset on database tables, with only 10,000 examples for weak supervision. This dataset is particularly challenging because of its small size and the lack of strong supervision, and also because the tables provided at test time are never seen during training, so learning requires adaptation at test time to unseen column names. A state-of-the-art, traditional semantic parser that relies on pruning strategies to ease program search achieves $3 7 . 1 \\%$ accuracy. Standard neural network models like sequence-to-sequence and pointer networks do not appear to be promising for this dataset, as confirmed in our experiments below, which yield single-digit accuracies. In comparison, a single Neural Programmer model using minimal text pre-processing, and trained end-to-end, achieves $3 4 . 2 \\%$ accuracy. This surprising result is enabled primarily by the sample efficiency of Neural Programmer, by the enhanced objective function, and by reducing overfitting via strong regularization with dropout (Srivastava et al., 2014; Iyyer et al., 2015; Gal & Ghahramani, 2016) and weight decay. An ensemble of 15 models, even with a trivial combination technique, achieves $3 7 . 7 \\%$ accuracy. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 NEURAL PROGRAMMER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            405,
+            571
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we describe in greater detail the Neural Programmer model and the modifications we made to the model. Neural Programmer is a neural network augmented with a set of discrete operations. The model consists of four modules: ",
+        "bbox": [
+            176,
+            588,
+            825,
+            630
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Question RNN that processes the question and converts the tokens to a distributed representation. We use an LSTM network (Hochreiter & Schmidhuber, 1997) as the question RNN.   \n• A list of discrete operations such as counting and entry selection that are manually defined. Each operation is parameterized by a real-valued vector that is learned during training.   \n• A selector module that induces two probability distributions at every time step, one over the set of operations and another over the set of columns. The input to the selector is obtained by concatenating the last hidden state of the question RNN, the hidden state of the history RNN from the current timestep, and the attention vector obtained by performing soft attention (Bahdanau et al., 2014) on the question using the history vector. Following Neelakantan et al. (2016), we employ hard selection at test time. History RNN modeled by a simple RNN (Werbos, 1990) with tanh activations which remembers the previous operations and columns selected by the model. The input to the history RNN at each timestep is the result of concatenating the weighted representations of operations and columns with their corresponding probability distributions produced by the selector at the previous timestep. ",
+        "bbox": [
+            215,
+            641,
+            825,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A more detailed description of the basic model can be found in Neelakantan et al. (2016). The model runs for fixed total of $T$ timesteps. The parameters of the operations, selector module, question and history RNNs are all learned with backpropagation using a weak supervision signal that consists of the final answer. Below, we discuss several modifications to the model to make it more broadly applicable, and easier to train. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 OPERATIONS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            162,
+            305,
+            176
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use 15 operations in the model that were chosen to closely match the set of operations used in the baseline model (Pasupat & Liang, 2015). All the operations except select and most frequent entry operate only on the set of selected rows which is given by the row selector variable. Before the first timestep, all the rows in the table are set to be selected. The built-in operations are: ",
+        "bbox": [
+            174,
+            189,
+            825,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• count returns the number of selected rows in row selector.   \n• select and most frequent entry are operations which are computed only once for every question and output a boolean tensor with size same as the size of the input table. An entry in the output of the select operation is set to 1 if the entry matches some phrase in the question. The matched phrases in the question are anonymized to prevent overfitting. Similarly, for most frequent entry, it is set to 1 if the entry is the most frequently occurring one in its column.   \n• argmax, argmin, greater than, less than, greater than or equal to, less than or equal to are all operations that output a tensor with size same as the size of the input table.   \n• first, last, previous and next modify the row selector.   \n• print operation assigns row selector on the selected column of lookup answer.   \n• reset resets row selector to its initial value. This operation also serves as no-op when the model needs to induce programs whose complexity is less than $T$ . ",
+        "bbox": [
+            215,
+            257,
+            825,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "All the operations are defined to work with soft selection so that the model can be trained with backpropagation. The operations along with their definitions are discussed in the Appendix. ",
+        "bbox": [
+            176,
+            474,
+            823,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 OUTPUT AND ROW SELECTOR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            520,
+            423,
+            534
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Neural programmer makes use of three variables: row selector, scalar answer and lookup answer which are updated at every timestep. The variable lookup answer stores answers that are selected from the table while scalar answer stores numeric answers that are not provided in the table.1 The induced program transfers information across timesteps using the row selector variable which contains rows that are selected by the model. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            616
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given an input table $\\Pi$ , containing $M$ rows and $C$ columns ( $M$ and $C$ can vary across examples), the output variables at timestep $t$ are given by: ",
+        "bbox": [
+            176,
+            622,
+            823,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "sc $\\begin{array} { r l } & { \\times a l a r \\ a n s w e r _ { t } = \\alpha _ { t } ^ { o p } ( c o u n t ) o u t p u t _ { t } ( c o u n t ) , } \\\\ & { o k u p \\ a n s w e r _ { t } [ i ] [ j ] = \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( p r i n t ) r o w \\ s e l e c t _ { t - t } [ i ] , \\forall ( i , j ) i = 1 , 2 , . . . , M , j = 1 , 2 , . . . , C } \\end{array}$ lo where $\\alpha _ { t } ^ { o p } ( o p )$ and $\\alpha _ { t } ^ { c o l } ( j )$ are the probabilities assigned by the selector to operation $o p$ and column $j$ at timestep $t$ respectively and $o u t p u t _ { t } ( c o u n t )$ is the output of the count operation at timestep $t$ . The row selector variable at timestep $t$ is obtained by taking the weighted average of the outputs of the remaining operations and is discussed in the Appendix. lookup answerT $[ i ] [ j ]$ is the probability that the element $( i , j )$ in the input table is in the final answer predicted by the model. ",
+        "bbox": [
+            174,
+            656,
+            828,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 TRAINING OBJECTIVE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            370,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We modify the training objective of Neural Programmer to handle the supervision signal available in real-world settings. In previous work, the position of the answers are explicitly marked in the table when the answer is an entry from the table. However, as discussed in Section 1, in real-world datasets (e.g., (Pasupat & Liang, 2015)) the answer is simply written down introducing two kinds of ambiguities. First, when the answer is a number and if the number is in the table, it is not known whether the loss should be computed using the scalar answer variable or the lookup answer variable. Second, when the answer is a natural language phrase and if the phrase occurs in multiple positions in the table, we again do not know which entry (or entries) in the table is actually responsible for generating the answer. We extend Neural Programmer to handle this weaker supervision signal during training by computing the loss only on the prediction that is closest to the desired response. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For scalar answers we compute the square loss: ",
+        "bbox": [
+            174,
+            180,
+            483,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17de03dbbddfcf56386cfa9437a243a73d58f7c9f37670c21ff5806c6832dc86.jpg",
+        "text": "$$\nL _ { s c a l a r } ( s c a l a r ~ a n s w e r _ { T } , y ) = \\frac { 1 } { 2 } ( s c a l a r ~ a n s w e r _ { T } - y ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            202,
+            691,
+            232
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $y$ is the ground truth answer. We divide $L _ { s c a l a r }$ by the number of rows in the input table and do not backpropagate on examples for which the loss is greater than a threshold since it leads to instabilities in training. ",
+        "bbox": [
+            174,
+            256,
+            825,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "When the answer is a list of items $y \\ = \\ ( a _ { 1 } , a _ { 2 } , . . . , a _ { N } )$ , for each element in the list $( a _ { i } , i { \\ = }$ $1 , 2 , \\ldots , N )$ we compute all the entries in the table that match that element, given by $S _ { i } ~ =$ $\\{ ( r , c ) , \\forall ( r , c ) \\Pi [ r ] [ { \\bar { c } } ] = a _ { i } \\}$ . We tackle the ambiguity introduced when an answer item occurs at multiple entries in the table by computing the loss only on the entry which is assigned the highest probability by the model. We construct $g \\in \\{ 0 , 1 \\} ^ { M \\times C }$ , where $g [ i , j ]$ indicates whether the element $( i , j )$ in the input table is part of the output. We compute log-loss for each entry and the final loss is given by: ",
+        "bbox": [
+            173,
+            305,
+            825,
+            404
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ae81f20ea17438712efce096bfa4644530bca673e422bd7c9088882a59370378.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle { \\cal L } _ { l o o k u p } ( l o o k u p ~ a n s w e r _ { T } , y ) = \\sum _ { i = 1 } ^ { N } m i n _ { ( r , c ) \\in S _ { i } } ( - \\log ( l o o k u p ~ a n s w e r _ { T } [ r , c ] ) ) } \\ ~ } \\\\ { { \\displaystyle ~ - \\ \\frac { 1 } { M C } \\sum _ { i = 1 } ^ { M } \\sum _ { j = 1 } ^ { C } [ g [ i , j ] ~ = = \\ 0 ] \\log ( 1 - l o o k u p ~ a n s w e r _ { T } [ i , j ] ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            410,
+            810,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $[ c o n d ]$ is 1 when cond is True, and 0 otherwise. ",
+        "bbox": [
+            174,
+            506,
+            531,
+            521
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We deal with the ambiguity that occurs when the ground truth is a number and if the number also occurs in the table, by computing the final loss as the soft minimum of $L _ { s c a l a r }$ and $L _ { l o o k u p }$ . Otherwise, the loss for an example is $L _ { s c a l a r }$ when the ground truth is a number and $L _ { l o o k u p }$ when the ground truth matches some entries in the table. The two loss functions $L _ { s c a l a r }$ and $L _ { l o o k u p }$ are in different scales, so we multiply $L _ { l o o k u p }$ by a constant factor which we set to 50.0 after a small exploration in our experiments. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            612
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since we employ hard selection at test time, only one among scalar answer and lookup answer is modified at the last timestep. We use the variable that is set at the last timestep as the final output of the model. ",
+        "bbox": [
+            174,
+            618,
+            825,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            326,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We apply Neural Programmer on the WikiTableQuestions dataset (Pasupat & Liang, 2015) and compare it to different non-neural baselines including a natural language semantic parser developed by Pasupat & Liang (2015). Further, we also report results from training the sequence-tosequence model (Sutskever et al., 2014) and a modified version of the pointer networks (Vinyals et al., 2015). Our model is implemented in TensorFlow (Abadi et al., 2016) and the model takes approximately a day to train on a single Tesla K80 GPU. We use double-precision format to store the model parameters since the gradients become undefined values in single-precision format. Our code is available at https://github.com/tensorflow/models/tree/master/neural_ programmer. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            838
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            253,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the train, development, and test split given by Pasupat & Liang (2015). The dataset contains 11321, 2831, and 4344 examples for training, development, and testing respectively. We use their tokenization, number and date pre-processing. There are examples with answers that are neither number answers nor phrases selected from the table. We ignore these questions during training but the model is penalized during evaluation following Pasupat & Liang (2015). The tables provided in the test set are unseen at training, hence requiring the model to adapt to unseen column names at test time. We train only on examples for which the provided table has less than 100 rows since we run out of GPU memory otherwise, but consider all examples at test time. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/576bf09c7185889d9a9c9e8a7dbadad78a605e91b483e6c34cb2f38039e3b0bb.jpg",
+        "table_caption": [
+            "Table 1: Performance of Neural Programmer compared to baselines from (Pasupat & Liang, 2015). The performance of an ensemble of 15 models is competitive to the current state-of-the-art natural language semantic parser. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Dev Accuracy</td><td rowspan=1 colspan=1>Test Accuracy</td></tr><tr><td rowspan=1 colspan=3>Baselines from Pasupat &amp; Liang (2015)</td></tr><tr><td rowspan=1 colspan=1>InformationRetrieval System</td><td rowspan=1 colspan=1>13.4</td><td rowspan=1 colspan=1>12.7</td></tr><tr><td rowspan=1 colspan=1>Simple Semantic Parser</td><td rowspan=1 colspan=1>23.6</td><td rowspan=1 colspan=1>24.3</td></tr><tr><td rowspan=1 colspan=1>Semantic Parser</td><td rowspan=1 colspan=1>37.0</td><td rowspan=1 colspan=1>37.1</td></tr><tr><td rowspan=1 colspan=3>Neural Programmer</td></tr><tr><td rowspan=1 colspan=1>Neural Programmer</td><td rowspan=1 colspan=1>34.1</td><td rowspan=1 colspan=1>34.2</td></tr><tr><td rowspan=1 colspan=1>Ensemble of 15 Neural Programmer models</td><td rowspan=1 colspan=1>37.5</td><td rowspan=1 colspan=1>37.7</td></tr><tr><td rowspan=1 colspan=1>Oracle Score with 15 Neural Programmer models</td><td rowspan=1 colspan=1>50.5</td><td rowspan=1 colspan=1>1</td></tr></table>",
+        "bbox": [
+            214,
+            99,
+            784,
+            241
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            320,
+            825,
+            391
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            409,
+            351,
+            422
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use $T = 4$ timesteps in our experiments. Words and operations are represented as 256 dimensional vectors, and the hidden vectors of the question and the history RNN are also 256 dimensional. The parameters are initialized uniformly randomly within the range [-0.1, 0.1]. We train the model using the Adam optimizer (Kingma & Ba, 2014) with mini-batches of size 20. The $\\epsilon$ hyperparameter in Adam is set to 1e-6 while others are set to the default values. Since the training set is small compared to other datasets in which neural network models are usually applied, we rely on strong regularization: ",
+        "bbox": [
+            174,
+            434,
+            825,
+            532
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• We clip the gradients to norm 1 and employ early-stopping.   \n• The occurrences of words that appear less than 10 times in the training set are replaced by a single unknown word token.   \n• We add a weight decay penalty with strength 0.0001.   \n• We use dropout with a keep probability of 0.8 on input and output vectors of the RNN, and selector, operation and column name representations (Srivastava et al., 2014). We use dropout with keep probability of 0.9 on the recurrent connections of the question RNN and history RNN using the technique from Gal & Ghahramani (2016). We use word-dropout (Iyyer et al., 2015) with keep probability of 0.9. Here, words in the question are randomly replaced with the unknown word token while training. ",
+        "bbox": [
+            215,
+            545,
+            825,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We tune the dropout rates, regularization strength, and the $\\epsilon$ hyperparameter using grid search on the development data, we fix the other hyperparameters after a small exploration during initial experiments. ",
+        "bbox": [
+            176,
+            726,
+            825,
+            767
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            279,
+            828
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the performance of our model in comparison to baselines from Pasupat & Liang (2015). The best result from Neural Programmer is achieved by an ensemble of 15 models. The only difference among these models is that the parameters of each model is initialized with a different random seed. We combine the models by averaging the predicted softmax distributions of the models at every timestep. While it is generally believed that neural network models require a large number of training examples compared to simpler linear models to get good performance, our model ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3d7bf083c3e365a1173a41b851597d25f62eeeb1ce6f200d2ca22c36fd016168.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Dev Accuracy</td></tr><tr><td rowspan=1 colspan=1>NeuralProgrammer</td><td rowspan=1 colspan=1>34.1</td></tr><tr><td rowspan=1 colspan=1>NeuralProgrammer-anonymization</td><td rowspan=1 colspan=1>33.7</td></tr><tr><td rowspan=1 colspan=1>Neural Programmer - match feature</td><td rowspan=1 colspan=1>31.1</td></tr><tr><td rowspan=1 colspan=1>Neural Programmer - {dropout,weight decay}</td><td rowspan=1 colspan=1>30.3</td></tr></table>",
+        "bbox": [
+            282,
+            101,
+            717,
+            178
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Model ablation studies. We find that dropout and weight decay, along with the boolean feature indicating a matched table entry for column selection, have a significant effect on the performance of the model. ",
+        "bbox": [
+            176,
+            188,
+            820,
+            229
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "achieves competitive performance on this small dataset containing only 10,000 examples with weak supervision. ",
+        "bbox": [
+            173,
+            255,
+            823,
+            284
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We did not get better results either by using pre-trained word vectors (Mikolov et al., 2013) or by pre-training the question RNN with a language modeling objective (Dai & Le, 2015). A possible explanation is that the word vectors obtained from unsupervised learning may not be suitable to the task under consideration. For example, the learned representations of words like maximum and minimum from unsupervised learning are usually close to each other but for our task it is counterproductive. We consider replacing soft selection with hard selection and training the model with the REINFORCE algorithm (Williams, 1992). The model fails to learn in this experiment, probably because the model has to search over millions of symbolic programs for every input question making it highly unlikely to find a program that gives a reward. Hence, the parameters of the model are not updated frequently enough. ",
+        "bbox": [
+            173,
+            290,
+            825,
+            429
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 NEURAL NETWORK BASELINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            444,
+            447,
+            458
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To understand the difficulty of the task for neural network models, we experiment with two neural network baselines: the sequence-to-sequence model (Sutskever et al., 2014) and a modified version of the pointer networks (Vinyals et al., 2015). The input to the sequence-to-sequence model is a concatenation of the table and the question, and the decoder produces the output one token at a time. We consider only examples whose input length is less than 400 to make the running time reasonable. The resulting dataset has 8, 857 and 1, 623 training and development examples respectively. The accuracy of the best model on this development set after hyperparameter tuning is only $8 . 9 \\%$ . Next, we experiment with pointer networks to select entries in the table as the final answer. We modify pointer networks to have two-attention heads: one to select the column and the other to select entries within a column. Additionally, the model performs multiple pondering steps on the table before returning the final answer. We train this model only on lookup questions, since the model does not have a decoder to generate answers. We consider only examples whose tables have less than 100 rows resulting in training and development set consisting of 7, 534 and 1, 829 examples respectively. The accuracy of the best model on this development set after hyperparameter tuning is only $4 . 0 \\dot { \\% }$ . These results confirm our intuition that discrete operations are hard to learn for neural networks particularly with small datasets in real-world settings. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            690
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            707,
+            285,
+            720
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4.1 MODEL ABLATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            762,
+            359,
+            776
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows the impact of different model design choices on the final performance. While anonymizing phrases in the question that match some table entry seems to have a small positive effect, regularization has a much larger effect on the performance. Column selection is performed in Neelakantan et al. (2016) using only the name of a column; however, this selection procedure is insufficient in real-world settings. For example the column selected in question 3 in Table 3 does not have a corresponding phrase in the question. Hence, to select a column we additionally use a boolean feature that indicates whether an entry in that column matches some phrase in the question. Table 2 shows that the addition of this boolean feature has a significant effect on performance. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            897
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b976d693840f8cd6fa894c533932edd452488ede3e032749a299ed53247e9627.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>ID</td><td rowspan=1 colspan=1>Question</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Step 1</td><td rowspan=1 colspan=1>Step 2</td><td rowspan=1 colspan=1>Step 3</td><td rowspan=1 colspan=1>Step 4</td></tr><tr><td rowspan=2 colspan=1>1</td><td rowspan=2 colspan=1>what is the total number ofteams?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>count</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=2 colspan=1>2</td><td rowspan=2 colspan=1>how many games had morethan 1,5oO in attendance?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>&gt;=</td><td rowspan=1 colspan=1>count</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>attendance</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=2 colspan=1>what is the total numberof runner-ups listed on thechart?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>count</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>outcome</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=2 colspan=1>4</td><td rowspan=2 colspan=1>which year held the mostcompetitions?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>mfe</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>year</td><td rowspan=1 colspan=1>year</td></tr><tr><td rowspan=2 colspan=1>5</td><td rowspan=2 colspan=1>what opponent is listed laston the table?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>last</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>last</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>opponent</td></tr><tr><td rowspan=2 colspan=1>6</td><td rowspan=2 colspan=1>which section is longest??</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>argmax</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>kilometers</td><td rowspan=1 colspan=1>name</td></tr><tr><td rowspan=2 colspan=1>7</td><td rowspan=2 colspan=1>which engine(s) has the leastamount of power?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>argmin</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>power</td><td rowspan=1 colspan=1>engine</td></tr><tr><td rowspan=2 colspan=1>8</td><td rowspan=2 colspan=1>whatwas claudia roll&#x27;stime?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>swimmer</td><td rowspan=1 colspan=1>time</td></tr><tr><td rowspan=2 colspan=1>9</td><td rowspan=2 colspan=1>who had more silver medals,cuba or brazil?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>argmax</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>argmax</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>nation</td><td rowspan=1 colspan=1>nation</td><td rowspan=1 colspan=1>silver</td><td rowspan=1 colspan=1>nation</td></tr><tr><td rowspan=2 colspan=1>10</td><td rowspan=2 colspan=1>who was the next appointeddirector after lee p. brown?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>next</td><td rowspan=1 colspan=1>last</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>name</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>name</td></tr><tr><td rowspan=2 colspan=1>11</td><td rowspan=2 colspan=1>what team is listed previousto belgium?</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=1>previous</td><td rowspan=1 colspan=1>first</td><td rowspan=1 colspan=1>print</td></tr><tr><td rowspan=1 colspan=1>Column</td><td rowspan=1 colspan=1>team</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>team</td></tr></table>",
+        "bbox": [
+            174,
+            266,
+            823,
+            633
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: A few examples of programs induced by Neural Programmer that generate the correct answer in the development set. mfe is abbreviation for the operation most frequent entry. The model runs for 4 timesteps selecting an operation and a column at every step. The model employs hard selection during evaluation. The column name is displayed in the table only when the operation picked at that step takes in a column as input while the operation is displayed only when it is other than the reset operation. Programs that choose count as the final operation produce a number as the final answer while programs that select print as the final operation produce entries selected from the table as the final answer. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7427c947c2d787592ec5cf31d95184f4f4409c8a80631fe37f78873237c39d89.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>Program in Table 3Amount (%)</td><td rowspan=1 colspan=1>Amount (%)</td></tr><tr><td rowspan=1 colspan=3>Scalar Answer</td></tr><tr><td rowspan=1 colspan=1>Only Count</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>6.5</td></tr><tr><td rowspan=1 colspan=1>Comparison+ Count</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2.1</td></tr><tr><td rowspan=1 colspan=1>Select + Count</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>22.1</td></tr><tr><td rowspan=1 colspan=1>Scalar Answer</td><td rowspan=1 colspan=1>1,2,3</td><td rowspan=1 colspan=1>30.7</td></tr><tr><td rowspan=1 colspan=3>Lookup Answer</td></tr><tr><td rowspan=1 colspan=1>Most Frequent Entry + Print</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1.7</td></tr><tr><td rowspan=1 colspan=1>First/Last+Print</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>9.5</td></tr><tr><td rowspan=1 colspan=1>Superlative+Print</td><td rowspan=1 colspan=1>6.7</td><td rowspan=1 colspan=1>13.5</td></tr><tr><td rowspan=1 colspan=1>Select+Print</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>17.5</td></tr><tr><td rowspan=1 colspan=1>Select + {first, last, previous, next, superlative} + Print</td><td rowspan=1 colspan=1>9-11</td><td rowspan=1 colspan=1>27.1</td></tr><tr><td rowspan=1 colspan=1>Lookup Answer</td><td rowspan=1 colspan=1>4-11</td><td rowspan=1 colspan=1>69.3</td></tr></table>",
+        "bbox": [
+            184,
+            101,
+            812,
+            295
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Statistics of the different sequence of operations among the examples answered correctly by the model in the development set. For each sequence of operations in the table, we also point to corresponding example programs in Table 3. Superlative operations include argmax and argmin, while comparison operations include greater than, less than, greater than or equal to and less than or equal to. The model induces a program that results in a scalar answer $3 0 . 7 \\%$ of the time while the induced program is a table lookup for the remaining questions. print and select are the two most common operations used $6 9 . 3 \\%$ and $6 6 . 7 \\%$ of the time respectively. ",
+        "bbox": [
+            173,
+            305,
+            825,
+            402
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.4.2 INDUCED PROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            435,
+            377,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows few examples of programs induced by Neural Programmer that yield the correct answer in the development set. The programs given in Table 3 show a few characteristics of the learned model. First, our analysis indicates that the model can adapt to unseen column names at test time. For example in Question 3, the word outcome occurs only 8 times in the training set and is replaced with the unknown word token. Second, the model does not always induce the most efficient (with respect to number of operations other than the reset operation that are picked) program to solve a task. The last 3 questions in the table can be solved using simpler programs. Finally, the model does not always induce the correct program to get the ground truth answer. For example, the last 2 programs will not result in the correct response for all input database tables. The programs would produce the correct response only when the select operation matches one entry in the table. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            602
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.4.3 CONTRIBUTION OF DIFFERENT OPERATIONS",
+        "text_level": 1,
+        "bbox": [
+            178,
+            654,
+            535,
+            667
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows the contribution of the different operations. The model induces a program that results in a scalar answer $3 0 . 7 \\%$ of the time while the induced program is a table lookup for the remaining questions. The two most commonly used operations by the model are print and select. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.4.4 ERROR ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            743,
+            352,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To conclude this section, we suggest ideas to potentially improve the performance of the model. First, the oracle performance with 15 Neural Programmer models is $5 0 . 5 \\%$ on the development set while averaging achieves only $3 7 . 5 \\%$ implying that there is still room for improvement. Next, the accuracy of a single model on the training set is $5 3 \\%$ which is about $20 \\%$ higher than the accuracy in both the development set and the test set. This difference in performance indicates that the model suffers from significant overfitting even after employing strong regularization. It also suggests that the performance of the model could be greatly improved by obtaining more training data. Nevertheless, there are limits to the performance improvements we may reasonably expect: in particular, as shown in previous work (Pasupat & Liang, 2015), $21 \\%$ of questions on a random set of 200 examples in the considered dataset are not answerable because of various issues such as annotation errors and tables requiring advanced normalization. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 OTHER RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            408,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While we discuss in detail various semantic parsing and neural program induction techniques in Section 1, here we briefly describe other relevant work. Recently, Kocisky et al. (2016) develop a semi-supervised semantic parsing method that uses question-program pairs as supervision. Concurrently to our work, Liang et al. (2016) propose neural symbolic machine, a model very similar to Neural Programmer but trained using the REINFORCE algorithm (Williams, 1992). They use only 2 discrete operations and run for a total of 3 timesteps, hence inducing programs that are much simpler than ours. Neural networks have also been applied on question-answering datasets that do not require much arithmetic reasoning (Bordes et al., 2014; Iyyer et al., 2014; Sukhbaatar et al., 2015; Peng et al., 2015; Hermann et al., 2015; Kumar et al., 2016). Wang & Jiang (2016) use a neural network model to get state-of-the-art results on a reading comprehension task (Rajpurkar et al., 2016). ",
+        "bbox": [
+            173,
+            133,
+            825,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            318,
+            323
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we enhance Neural Programmer to work with weaker supervision signals to make it more broadly applicable. Soft selection during training enables the model to actively explore the space of programs by backpropagation with superior sample complexity. In our experiments, we show that the model achieves performance comparable to a state-of-the-art traditional semantic parser even though the training set contains only 10,000 examples. To our knowledge, this is the first instance of a weakly supervised, end-to-end neural network model that induces programs on a real-world dataset. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            435
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements We are grateful to Panupong Pasupat for answering numerous questions about the dataset, and providing pre-processed version of the dataset and the output of the semantic parser. We thank David Belanger, Samy Bengio, Greg Corrado, Andrew Dai, Jeff Dean, Nando de Freitas, Shixiang Gu, Navdeep Jaitly, Rafal Jozefowicz, Ashish Vaswani, Luke Vilnis, Yuan Yu and Barret Zoph for their suggestions and the Google Brain team for the support. Arvind Neelakantan is supported by a Google PhD fellowship in machine learning. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            555,
+            285,
+            570
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz ´ Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Gor- ´ don Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul A. Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viegas, Oriol Vinyals, ´ Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. ArXiv, 2016. ",
+        "bbox": [
+            174,
+            578,
+            825,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Learning to compose neural networks for question answering. NAACL, 2016. ",
+        "bbox": [
+            173,
+            698,
+            823,
+            727
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. ICLR, 2014. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antoine Bordes, Sumit Chopra, and Jason Weston. Question answering with subgraph embeddings. EMNLP, 2014. ",
+        "bbox": [
+            174,
+            773,
+            820,
+            801
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew M Dai and Quoc V Le. Semi-supervised sequence learning. NIPS, 2015. ",
+        "bbox": [
+            173,
+            810,
+            709,
+            825
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. NIPS, 2016. ",
+        "bbox": [
+            173,
+            834,
+            825,
+            863
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Tomas Kocisk ´ y, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa ´ Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. NIPS, 2015. ",
+        "bbox": [
+            174,
+            871,
+            821,
+            900
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 1997. ",
+        "bbox": [
+            173,
+            909,
+            808,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohit Iyyer, Jordan L. Boyd-Graber, Leonardo Max Batista Claudino, Richard Socher, and Hal Daume III. A neural network for factoid question answering over paragraphs. ´ EMNLP, 2014. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mohit Iyyer, Varun Manjunatha, Jordan Boyd-Graber, and Hal Daume III. Deep unordered compo- ´ sition rivals syntactic methods for text classification. ACL, 2015. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robin Jia and Percy Liang. Data recombination for neural semantic parsing. ACL, 2016. ",
+        "bbox": [
+            176,
+            193,
+            753,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin and Tomas Mikolov. Inferring algorithmic patterns with stack-augmented recurrent nets. NIPS, 2015. ",
+        "bbox": [
+            173,
+            217,
+            823,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lukasz Kaiser and Ilya Sutskever. Neural gpus learn algorithms. ICLR, 2016. ",
+        "bbox": [
+            176,
+            253,
+            687,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2014. ",
+        "bbox": [
+            176,
+            279,
+            795,
+            294
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Kocisky, Gabor Melis, Edward Grefenstette, Chris Dyer, Wang Ling, Phil Blunsom, and Karl Moritz Hermann. Semantic parsing with semi-supervised sequential autoencoders. ArXiv, 2016. ",
+        "bbox": [
+            176,
+            303,
+            823,
+            345
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jayant Krishnamurthy and Thomas Kollar. Jointly learning to parse and perceive: Connecting natural language to the physical world. TACL, 2013. ",
+        "bbox": [
+            169,
+            354,
+            823,
+            383
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ankit Kumar, Ozan Irsoy, Jonathan Su, James Bradbury, Robert English, Brian Pierce, Peter Ondruska, Ishaan Gulrajani, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. ICML, 2016. ",
+        "bbox": [
+            176,
+            392,
+            825,
+            435
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Kwiatkowski, Eunsol Choi, Yoav Artzi, and Luke Zettlemoyer. Scaling semantic parsers with on-the-fly ontology matching. EMNLP, 2013. ",
+        "bbox": [
+            176,
+            444,
+            821,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chen Liang, Jonathan Berant, Quoc Le, Kenneth Forbus, and Ni Lao. Neural symbolic machines: Learning semantic parsers on freebase with weak supervision. NAMPI Workshop, NIPS, 2016. ",
+        "bbox": [
+            176,
+            481,
+            818,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Percy Liang. Learning executable semantic parsers for natural language understanding. ACM, 2016. ",
+        "bbox": [
+            173,
+            520,
+            820,
+            536
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Percy Liang, Michael I. Jordan, and Dan Klein. Learning dependency-based compositional semantics. ACL, 2011. ",
+        "bbox": [
+            174,
+            544,
+            821,
+            573
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. ArXiv, 2013. ",
+        "bbox": [
+            173,
+            582,
+            821,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arvind Neelakantan, Quoc V. Le, and Ilya Sutskever. Neural programmer: Neural programmer: Inducing latent programs with gradient descent. ICLR, 2016. ",
+        "bbox": [
+            173,
+            619,
+            821,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Panupong Pasupat and Percy Liang. Compositional semantic parsing on semi-structured tables. ACL, 2015. ",
+        "bbox": [
+            174,
+            657,
+            821,
+            686
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baolin Peng, Zhengdong Lu, Hang Li, and Kam-Fai Wong. Towards neural network-based reasoning. ArXiv, 2015. ",
+        "bbox": [
+            173,
+            695,
+            823,
+            724
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: 100, $0 0 0 +$ questions for machine comprehension of text. ArXiv, 2016. ",
+        "bbox": [
+            173,
+            733,
+            823,
+            762
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed and Nando De Freitas. Neural programmer-interpreters. ICLR, 2016. ",
+        "bbox": [
+            173,
+            771,
+            704,
+            787
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 2014. ",
+        "bbox": [
+            176,
+            795,
+            820,
+            824
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. NIPS, 2015. ",
+        "bbox": [
+            174,
+            833,
+            821,
+            862
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. NIPS, 2014. ",
+        "bbox": [
+            173,
+            871,
+            823,
+            900
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. NIPS, 2015. ",
+        "bbox": [
+            171,
+            909,
+            722,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. ArXiv, 2016. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yushi Wang, Jonathan Berant, and Percy Liang. Building a semantic parser overnight. ACL, 2015. ",
+        "bbox": [
+            173,
+            140,
+            820,
+            157
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "P. Werbos. Backpropagation through time: what does it do and how to do it. Proceedings of IEEE, 1990. ",
+        "bbox": [
+            173,
+            165,
+            823,
+            195
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 1992. ",
+        "bbox": [
+            171,
+            203,
+            823,
+            232
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pengcheng Yin, Zhengdong Lu, Hang Li, and Ben Kao. Neural enquirer: Learning to query tables with natural language. ArXiv, 2015. ",
+        "bbox": [
+            169,
+            239,
+            825,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba, Tomas Mikolov, Armand Joulin, and Rob Fergus. Learning simple algorithms from examples. ICML, 2016. ",
+        "bbox": [
+            171,
+            277,
+            823,
+            308
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John M. Zelle and Raymond J. Mooney. Learning to parse database queries using inductive logic programming. AAAI/IAAI, 1996. ",
+        "bbox": [
+            169,
+            315,
+            823,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Luke S. Zettlemoyer and Michael Collins. Learning to map sentences to logical form: Structured classification with probabilistic categorial grammars. UAI, 2005. ",
+        "bbox": [
+            169,
+            353,
+            825,
+            383
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/f31217e4b049803ac299cec64df3ccc0aab3d5ceb23f94690a27f87d74bcc9cb.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Type</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=3>Definition</td></tr><tr><td rowspan=1 colspan=1>Aggregate</td><td rowspan=1 colspan=1>count</td><td rowspan=1 colspan=3>Mcountt =∑ row_selectt-1[i]i=1</td></tr><tr><td rowspan=2 colspan=1>Superlative</td><td rowspan=1 colspan=1>argmax</td><td rowspan=1 colspan=3>maxt[i][j]=max(O.0,row_selectt-1[i]-C([[[i][]]&lt;I[k][j]] × row_selectt-1[k])),i=1,...,M,j=1,...,C</td></tr><tr><td rowspan=1 colspan=1>argmin</td><td rowspan=1 colspan=3>mint[i][j]=max(O.0,row_selectt-1[i]-M([[i][j] &gt; I[k][j]] × row_select-1[k])),i=1,...,M,j =1,...,C</td></tr><tr><td rowspan=4 colspan=1>Comparison</td><td rowspan=1 colspan=1>&gt;</td><td rowspan=1 colspan=1>gi][i]=II</td><td rowspan=1 colspan=1>illi</td><td rowspan=1 colspan=1>g[i][j]= I[i][] &gt; pivotg,V(i,j),i= 1,...,M,j = 1,...,C</td></tr><tr><td rowspan=1 colspan=1>&lt;</td><td rowspan=1 colspan=1>[i][=II</td><td rowspan=1 colspan=1>i]i</td><td rowspan=1 colspan=1>li][j]=I[i][]&lt; pivot,V(i,j),i =1,...,M,j=1,...,C</td></tr><tr><td rowspan=1 colspan=1>M</td><td rowspan=1 colspan=1>geii=II</td><td rowspan=1 colspan=1>il</td><td rowspan=1 colspan=1>geli]l]= I[𝑖]j]≥ pivotge,∀(i,j),i = 1,...,M,j = 1,...,C</td></tr><tr><td rowspan=1 colspan=1>≤</td><td rowspan=1 colspan=2>leij=Iij</td><td rowspan=1 colspan=1>le[i][j]=II[i][j]≤ pivote,V(i,j),i=1,...,M,j=1,...,C</td></tr><tr><td rowspan=6 colspan=1>Table Ops</td><td rowspan=1 colspan=1>select</td><td rowspan=1 colspan=3>s[i][j]= 1.O if II[i]lj] appears in question else 0.0,∀(i,j),i=1,...,M,j =1,...,C</td></tr><tr><td rowspan=1 colspan=1>mfe</td><td rowspan=1 colspan=3>mfe[i][j]=1.O if I[i]lj] is the most common entry in column j else 0.0,∀(i,j),i =1,...,M,j=1,.,C</td></tr><tr><td rowspan=1 colspan=1>first</td><td rowspan=1 colspan=3>i=1,...,M</td></tr><tr><td rowspan=1 colspan=1>last</td><td rowspan=1 colspan=3>i=1,...,M</td></tr><tr><td rowspan=1 colspan=1>previous</td><td rowspan=1 colspan=3>Pt[]= row_selectt-1[i+ 1],i=1,...,M-1;pt[M]=0</td></tr><tr><td rowspan=1 colspan=1>next</td><td rowspan=1 colspan=3>nt[i]=row_selectt-1[i-1],i=2,...,M;nt[1]=0</td></tr><tr><td rowspan=1 colspan=1>Print</td><td rowspan=1 colspan=1>print</td><td rowspan=1 colspan=3>lookup answert[il[i]= row_selectt-1[i],∀(i,j)i=1,...,M,j =1,...,C</td></tr><tr><td rowspan=1 colspan=1>Reset</td><td rowspan=1 colspan=1>reset</td><td rowspan=1 colspan=3>rt[]=1,Vi =1,2,...,M</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            831,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 5: List of all operations provided to the model along with their definitions. mfe is abbreviation for the operation most frequent entry. [cond] is 1 when cond is True, and 0 otherwise. Comparison, select, reset and mfe operations are independent of the timestep while all the other operations are computed at every time step. Superlative operations and most frequent entry are computed within a column. The operations calculate the expected output with the respect to the membership probabilities given by the row selector so that they can work with probabilistic selection. ",
+        "bbox": [
+            173,
+            433,
+            826,
+            518
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            541,
+            263,
+            556
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "OPERATIONS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            602,
+            266,
+            616
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 5 shows the list of operations built into the model along with their definitions. ",
+        "bbox": [
+            173,
+            627,
+            722,
+            642
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ROW SELECTOR ",
+        "bbox": [
+            174,
+            659,
+            287,
+            672
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Section 2.3, the output variables scalar answer and lookup answer are calculated using the output of the count operations and print operation respectively. The row selector is computed using the output of the remaining operations and is given by, ",
+        "bbox": [
+            176,
+            684,
+            825,
+            727
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/177b37bcedf712f1d9b57b4a3d8926defc13bfe0e35ea14123fa2180e3a5d89d.jpg",
+        "text": "$$\n\\begin{array} { l } { { r o w ~ s e l e c t o r } [ \\hat { l } ] = \\displaystyle \\sum _ { j = 1 } ^ { C } \\{ \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( > ) g [ \\hat { l } ] [ j ] + \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( < ) l [ \\hat { l } ] [ j ] }  \\\\ { ~ + ~ \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( \\ge ) g [ \\hat { l } ] [ j ] + \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( \\le ) l [ \\hat { l } ] [ j ] , }  \\\\ { { ~ + ~ \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( a r g m a x ) m a x [ \\hat { l } ] j ] + \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( a r g m i n _ { t } ) m i n [ \\hat { l } ] [ j ] , } } \\\\ { { ~ + ~ \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( s e l e c t ) s [ i ] [ j ] + \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( m f e ) m f e [ \\hat { l } ] [ j ] ] } } \\\\ { { ~ + ~ \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( s e l e c t ) s [ i ] [ j ] + \\alpha _ { t } ^ { c o l } ( j ) \\alpha _ { t } ^ { o p } ( m f e ) m f e [ \\hat { l } ] [ j ] ] } } \\\\ { { ~ + ~ \\alpha _ { t } ^ { o p } ( p r e v i o u s ) p _ { t } [ \\hat { l } ] + \\alpha _ { t } ^ { o p } ( m e x t ) n _ { t } [ \\hat { l } ] + \\alpha _ { t } ^ { o p } ( r e s e t ) r _ { t } [ \\hat { l } ] } } \\\\ { { ~ + ~ \\alpha _ { t } ^ { e o p } ( f i r s t ) f [ \\hat { l } ] + \\alpha _ { t } ^ { o p } ( l a s t ) l a _ { t } [ \\hat { l } ] } } \\\\ { { ~ \\forall i , i = 1 , 2 , . . . , ~ M } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            729,
+            785,
+            891
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha _ { t } ^ { o p } ( o p )$ and $\\alpha _ { t } ^ { c o l } ( j )$ are the probabilities assigned by the selector to operation $o p$ and column $j$ at timestep $t$ respectively. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    }
+]

parse/train/vrhNQ7aYSdr/vrhNQ7aYSdr.md

@@ -0,0 +1,274 @@
+# SubTab: Subsetting Features of Tabular Data for Self-Supervised Representation Learning
+
+Talip Uçar, Ehsan Hajiramezanali, Lindsay Edwards
+
+Respiratory and Immunology, R&D, AstraZeneca {talip.ucar, ehsan.hajiramezanali, lindsay.edwards}@astrazeneca.com
+
+# Abstract
+
+Self-supervised learning has been shown to be very effective in learning useful representations, and yet much of the success is achieved in data types such as images, audio, and text. The success is mainly enabled by taking advantage of spatial, temporal, or semantic structure in the data through augmentation. However, such structure may not exist in tabular datasets commonly used in fields such as healthcare, making it difficult to design an effective augmentation method, and hindering a similar progress in tabular data setting. In this paper, we introduce a new framework, Subsetting features of Tabular data (SubTab), that turns the task of learning from tabular data into a multi-view representation learning problem by dividing the input features to multiple subsets. We argue that reconstructing the data from the subset of its features rather than its corrupted version in an autoencoder setting can better capture its underlying latent representation. In this framework, the joint representation can be expressed as the aggregate of latent variables of the subsets at test time, which we refer to as collaborative inference. Our experiments show that the SubTab achieves the state of the art (SOTA) performance of $9 8 . 3 1 \%$ on MNIST in tabular setting, on par with CNN-based SOTA models, and surpasses existing baselines on three other real-world datasets by a significant margin.
+
+# 1 Introduction
+
+In recent years, the self-supervised learning has successfully been used to learn meaningful representations of the data in natural language processing [34, 41, 11, 28, 10, 21, 9]. A similar success has been achieved in image and audio domains [7, 15, 37, 5, 17, 13, 8]. This progress is mainly enabled by taking advantage of spatial, semantic, or temporal structure in the data through data augmentation [7] , pretext task generation [11] and using inductive biases through architectural choices (e.g. CNN for images). However, these methods can be less effective in the lack of such structures and biases in the tabular data commonly used in many fields such as healthcare, advertisement, finance, and law. And some augmentation methods such as cropping, rotation, color transformation etc. are domain specific, and not suitable for tabular setting. The difficulty in designing similarly effective methods tailored for tabular data is one of the reasons why self-supervised learning is under-studied in this domain $\lVert \overline { { 4 6 } } \rVert$ .
+
+The most common approach in tabular data is to corrupt data through adding noise $\boxed { 4 3 }$ . An autoencoder maps corrupted examples of data to a latent space, from which it maps back to uncorrupted data. Through this process, it learns a representation robust to the noise in the input. This approach may not be as effective since it treats all features equally as if features are equally informative. However, perturbing uninformative features may not result in the intended goal of the corruption. A recent work takes advantage of self-supervised learning in tabular data setting by introducing a pretext task [46], in which a de-noising autoencoder with a classifier attached to representation layer is trained on corrupted data. The classifier’s task is to predict the location of corrupted features. However, this framework still relies on noisy data in the input. Additionally, training a classifier on an imbalanced binary mask for a high-dimensional data may not be ideal to learn meaningful representations.
+
+![](images/627972ccde368e4abb61346ab5503e52534cfdcce989262378148d136190a787.jpg)  
+Figure 1: SubTab framework: i) Dividing the features into subsets (similar to feature bagging, or cropping images), ii) Reconstruction of either subsets of features $( \tilde { x } _ { 1 } , \tilde { x } _ { 2 } , \tilde { x } _ { 3 } )$ , or complete feature space $( \breve { \tilde { X } } _ { 1 } , \tilde { X } _ { 2 } , \tilde { X } _ { 3 } )$ , which are used to compute reconstruction loss. iii) Generating projections used to compute contrastive and distance loss. $E \equiv E n c o d e r .$ $D \equiv D e c o d e r$ , $G \equiv P r$ ojection.
+
+In this work, we turn the problem of learning representation from a single-view of the data into the one learnt from its multiple views by dividing the features into subsets, akin to cropping in image domain or feature bagging in ensemble learning, to generate different views of the data. Each subset can be considered a different view. We show that reconstructing data from the subset of its features forces the encoder to learn better representation than the ones learned through the existing methods such as adding noise. We train our model in a self-supervised setting and evaluate it on downstream tasks such as classification, and clustering. We use five different datasets; MNIST in tabular format, the cancer genome atlas (TCGA) [42], human gut metagen-omic samples of obesity cohorts (Obesity) [36, 26], UCI adult income (Income) [24], and UCI BlogFeedback (Blog) [4].
+
+SubTab can: i) construct a better representation by using the aggregate of the representation of the subsets, a process that we refer as collaborative inference ii) discover the regions of informative features by measuring predictive power of each subset, which is useful especially in high-dimensional data iii) do training and inference in the presence of missing features by ignoring corresponding subsets and iv) use smaller models by reducing input dimension, making it less prone to overfitting.
+
+# 2 Method
+
+The augmentation methods such as adding noise, rotation, cropping etc. are commonly used in image domain. Among them, the cropping is shown to be the most effective technique $\textcircled { 7 }$ . Inspired from this insight, we propose subsetting features of tabular data.
+
+Figure 1 presents SubTab framework, in which we have an encoder (E), a decoder (D), and an optional projection (G). For the purpose of this paper, we will refer $^ { h }$ as latent, or representation, $_ { z }$ as projection, $\tilde { \pmb x }$ , and $\tilde { X }$ as the reconstruction of subset, and whole data respectively. Small letters are associated with subsets while capital latters are associated the whole set of features. Moreover, throughout this work, when we say that a representation is "good", we refer to its performance in a classification task using a linear model.
+
+In SubTab framework, we divide tabular data to multiple subsets. Neighbouring subsets can have overlapping regions, defined as a percentage of a dimension of the subset. Each of the subsets is fed to the same encoder (i.e. parameter sharing) to get their corresponding latent representation. A shared decoder is used to reconstruct either the subset fed to the encoder, or full tabular data (i.e. reconstructing all features from the subset of features). We chose the latter in our experiments since it is more effective in learning good representations. We should also note that, in the latter case, the autoencoder cannot learn the identity, eliminating the constraint on the dimension of the bottleneck (i.e. representation). We compute one reconstruction loss term per subset.
+
+![](images/07c289a2119a323df61b9f955041fe75764f373e6d0ba73815abb1733a070355.jpg)  
+Figure 2: a) Push-Pull forces applied by each loss. PS / NS $:$ Positive/Negative sample; CL/RL/DL: Contrastive, Reconstruction, Distance losses b) Column or feature selection strategies for adding noise to each subset. Top: Selecting a block of neighbouring columns; Middle: Selecting columns randomly; Bottom: Selecting random features per row c) Latent variables from each subset is aggregated at test time. The mean (default), sum, max, or min aggregation can be used.
+
+Moreover, we can optionally add contrastive loss to our objective by using all combination of pairs of projections from all subsets. For example, given three subsets as in Figure 1, there are three combinations of two: $\textstyle { { \binom { n } { k } } = { \binom { 3 } { 2 } } = { \frac { 3 ! } { 2 ! ( 1 ) ! } } = \dot { 3 } }$ . For four subsets, it would be 6 pairs of combination, and so on. We can add one more loss term, referred as distance loss, to reduce the distance between the pairs of projections of the subsets by using a loss function such as mean squared error (MSE). All three loss terms apply a pulling force on positive samples while contrastive loss also applies a push force between positive and negative samples as shown in Figure 2a.
+
+Once the dataset is divided into subsets in data preparation step, a process that is similar to feature bagging in ensemble learning, their location is fixed. Thus, we don’t change the relative order of features in a subset during training since standard neural network architectures are not permutation invariant. This is to ensure that same features are fed to the same input units of neural network. However, our method can be extended to permutation invariant setting as a next step.
+
+# 2.1 Strategies for adding noise
+
+Our framework is complementary to other augmentation techniques used in tabular data setting. Thus, we experimented with adding noise to randomly selected entries in each subset by using three types of noise: i) adding Gaussian noise, ${ \mathcal { N } } ( 0 , \sigma ^ { 2 } )$ , ii) overwriting the value of a selected entry with another value randomly sampled from the same column, referred as swap-noise, iii) zeroing-out randomly selected entries, referred as zero-out noise.
+
+Moreover, we use three different strategies when selecting the features to add noise to, as shown in Figure 2b: i) a random block of neighboring columns (NC), ii) random columns (RC) iii) random features per each sample (RF). To add noise, we create a binomial mask, $_ { \mathbf { \nabla } } \mathbf { m }$ , and a noise matrix, $\epsilon$ with same shape as the subset, in which the entries of the mask is assigned to 1 with probability $p$ and to 0 otherwise. The corrupted version, $\scriptstyle { \mathbf { \mathcal { x } } } _ { 1 c }$ , of subset $\mathbf { \mathbf { { x } _ { 1 } } }$ is generated as following:
+
+$$
+x _ { 1 c } = ( 1 - m ) \odot x _ { 1 } + m \odot \epsilon
+$$
+
+# 2.2 Training
+
+Our objective function is:
+
+$$
+\mathcal { L } _ { t } = \mathcal { L } _ { r } + \mathcal { L } _ { c } + \mathcal { L } _ { d } ,
+$$
+
+where $\mathcal { L } _ { t } , \mathcal { L } _ { r }$ , $\mathcal { L } _ { c }$ and $\mathcal { L } _ { d }$ are total, reconstruction, contrastive, and distance losses, respectively.
+
+i) Reconstruction loss: Given a subset, denoted by $\scriptstyle { \mathbf { 2 } } \mathbf { 4 }$ , we can reconstruct either the same subset, $\tilde { \mathbfit { x } } _ { k }$ or the entire feature space $\tilde { X } _ { k }$ . Then, we can compute the reconstruction loss for $k ^ { t h }$ subset by
+
+computing mean squared error using either $( x _ { k } , \tilde { x } _ { k } )$ , or $( X , \tilde { X } _ { k } )$ pair as shown in Figure 1. We chose the latter since it was more effective. Overall reconstruction loss:
+
+$$
+\mathcal { L } _ { r } = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } s _ { k } , \mathrm { w h e r e } s _ { k } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \left( X ^ { ( i ) } - \tilde { X } _ { k } ^ { ( i ) } \right) ^ { 2 }
+$$
+
+where $K$ is the total number of subsets, $N$ is the size of the batch, $s _ { k }$ is the reconstruction loss for $k ^ { t h }$ subset, and $\mathcal { L } _ { r }$ is the average of reconstruction loss over all subsets.
+
+ii) Contrastive loss: If the dataset is rich in the number of classes such that chances of sampling negative samples are high, we can use a projection network (G) to get projections, $z ^ { \prime } s$ , of representations, $\bar { \boldsymbol { h } } ^ { \prime } \boldsymbol { s }$ . Samples at the same rows of two subsets, ${ z } _ { 1 }$ and ${ z _ { 2 } }$ , can be considered as positive pairs while remaining rows in the subsets can be considered as negative to those samples.This allows us to compute the contrastive loss for each pair of projections using a loss function such as the normalized temperature-scaled cross entropy loss (NT-Xent) $\lVert \rVert$ . For three subsets, $\{ x _ { 1 } , x _ { 2 } , x _ { 3 } \}$ , we can compute such a loss for every pair $\{ z _ { a } , z _ { b } \}$ of total three pairs from the set $\bar { S } = \{ \{ z _ { 1 } , z _ { 2 } \} , \{ z _ { 1 } , z _ { 3 } \} , \{ z _ { 2 } , z _ { 3 } \} \}$ . Overall contrastive loss is:
+
+$$
+\mathcal { L } _ { c } = \frac { 1 } { J } \sum _ { \{ z _ { a } , z _ { b } \} \in S } p ( z _ { a } , z _ { b } ) , \mathrm { ~ w h e r e ~ } p ( z _ { a } , z _ { b } ) = \frac { 1 } { 2 N } \sum _ { i = 1 } ^ { N } \Big [ l ( z _ { a } ( ^ { i } ) , z _ { b } ( ^ { i } ) ) + l ( z _ { b } ( ^ { i } ) , z _ { a } ( ^ { i } ) ) \Big ]
+$$
+
+$$
+l ( z _ { \mathbf { a } } ^ { ( i ) } , z _ { b } ^ { ( i ) } ) = - \log \frac { \exp ( s i m ( z _ { \mathbf { a } } ^ { ( i ) } , z _ { b } ^ { ( i ) } ) / \tau ) } { \sum _ { k = 1 } ^ { N } \mathbb { 1 } _ { k \neq i } \exp ( s i m ( z _ { \mathbf { a } } ^ { ( i ) } , z _ { b } ^ { ( k ) } ) / \tau ) }
+$$
+
+where $J$ is the total number of pairs in set $S$ , $p ( z _ { a } , z _ { b } )$ is total contrastive loss for a pair of projection $\{ z _ { a } , z _ { b } \}$ , $l \big ( z _ { a } ^ { \mathrm { ~ } } ^ { ( i ) } , z _ { b } ^ { \mathrm { ~ } ( i ) } \big )$ is the loss function for a corresponding positive pairs of examples $( z _ { a } { ^ { ( i ) } } , z _ { b } { ^ { ( i ) } } )$ in subsets $\{ z _ { a } , z _ { b } \}$ , and $\mathcal { L } _ { c }$ is the average of contrastive loss over all pairs.
+
+iii) Distance loss: We can also add mean-squared error (MSE) loss for pairs of projections of subsets since the corresponding samples in subsets should be close to each other. Hence, we can compute an overall MSE loss as:
+
+$$
+{ \mathcal { L } } _ { d } = { \frac { 1 } { J } } \sum _ { \{ z _ { a } , z _ { b } \} \in S } p ( z _ { a } , z _ { b } ) , { \mathrm { ~ w h e r e ~ } } p ( z _ { a } , z _ { b } ) = { \frac { 1 } { N } } \sum _ { i = 1 } ^ { N } \left( z _ { a } ^ { ( i ) } - z _ { b } ^ { ( i ) } \right) ^ { 2 }
+$$
+
+The pseudocode of algorithm can be found in Algorithm $\bigstar$ in the Appendix. We should note that both $\mathcal { L } _ { c }$ and $\mathcal { L } _ { d }$ in equation $^ { ( 2 ) }$ are optional, and we used them only in some experiments.
+
+# 2.3 Test time
+
+At test time, we feed the subsets of test set to the encoder, and get the aggregate of the representations of all available subsets as shown in Figure $2 \mathrm { c } .$ Please note that we can use mean, sum, min, max, or any other aggregation method to get joint representation, which is analogous to pooling in Computer Vision, or the aggregation of neighbouring nodes in graph convolutional networks $\pmb { \widetilde { \left. 2 3 \right. } }$ . We used mean aggregation in all our experiments, but did compare different aggregation methods in Appendix F.4. Our experiments show that we can use the representations of only one, or few subsets and still achieve a good performance at test time. For example, we could use only $h _ { 1 }$ , or aggregate of $\boldsymbol { h } _ { 1 }$ and $h _ { 2 }$ rather than aggregating over all subsets $( h _ { 1 } , h _ { 2 } , h _ { 3 } )$ in Figure $\boxed { 2 \mathrm { c } }$ This allows the model to infer from the data even in the presence of missing features, in which case we can ignore the subset with missing features. We can also design an aggregation function that computes weighted mean of the representations of subsets since some subsets might be more informative than others:
+
+$$
+h = \frac { 1 } { Z } \sum _ { k = 1 } ^ { K } \eta _ { k } * h _ { k } , \mathrm { a n d } Z = \sum _ { k = 1 } ^ { K } \eta _ { k } ,
+$$
+
+where $K$ is number of subsets, and $\eta _ { k }$ is the weight for $k _ { t h }$ subset. $\eta$ can be a learnable parameter in semi-supervised, or supervised setting by using an attention mechanism. We can also use 1D convolution in equation $\textcircled { 7 }$ by treating representations of subsets as separate channels during training. We left these ideas as future work and used the mean aggregation (i.e. $\eta _ { k } = 1 \mathrm { ~ }$ ) throughout our experiments, unless explicitly stated. A comparison of different aggregation methods can be found in Table $\underline { { \sqrt { \bf A } ^ { 3 } } } \mathrm { | i n }$ the Appendix.
+
+# 3 Experiments
+
+We conducted various experiments on diverse set of tabular datasets including MNIST $\pm \pm$ in tabular format, the cancer genome atlas (TCGA) $\pmb { \| 4 2 } \pmb { \| }$ , human gut metagen-omic samples of obesity cohorts (Obesity) [36, 26], UCI adult income (Income) $\pm \overbrace { | 2 4 | }$ , and UCI BlogFeedback (Blog) [4] to demonstrate the effectiveness of the SubTab framework. We compare our method to autoencoder baseline with and without dropout, other self-supervised methods such as VIME-self $\boxed { \boxed { 4 6 } }$ , Denoising Autoencoder (DAE) $\boxed { \boxplus 3 }$ , and Context Encoder (CAE) $\textcircled { 1 3 9 } \textcircled { 1 }$ as well as fully-supervised models such as logistic regression, random forest, and XGBoost $\textcircled { 6 }$ . For each dataset, once we decided on a particular autoencoder architecture, we used it for all models compared (i.e. VIME-self, DAE, CAE, and our model). We tried both ReLU and leakyReLU as activation functions for all, and both performed equally well. The code for SubTab is provided1. The summary of model architectures and hyperparameters are in Table $\boxed { \mathbf { A } 1 }$ in the Appendix. We should note that we ran more experiments using; i) Synthetic datasets and ii) OpenML-CC18 datasets $\lVert \rVert$ in Appendix G and H respectively.
+
+# 3.1 Data
+
+MNIST: We flattened $2 8 \mathbf { x } 2 8$ images, and scaled them by dividing all with 255 as it is done in [46]. We split training set into training and validation sets $( 9 0 - 1 0 \%$ split) when searching for hyper-parameters, and then used all of training set to train the final model. The test set is used only for final evaluation.
+
+The Cancer Genome Atlas (TCGA): TCGA is a public cancer genomics dataset characterized over 20,000 primary cancer and matched normal samples that holds information over 38 cohorts. The task is to classify the cancer cohorts from the reverse phase protein array (RPPA) dataset. It includes 6671 samples with 122 features, which we divided to $8 0 { - } 1 0 { - } 1 0 \%$ train-validation-test sets. Once hyper-parameters is found, we trained the models on combined training and validation set.
+
+Obesity: The dataset consists of publicly available human gut metagen-omic samples of obesity cohorts $\textcircled { 1 3 6 }$ . It is derived from whole-genome shotgun metagenomic studies. The dataset consists of 164 obese patients and 89 non-obese controls and has 425 features $\pmb { \left. 2 6 \right. }$ . We scaled the dataset by using min-max scaling. Since it is a small dataset, we evaluated the model by using 10 randomly drawn training-test $( 9 0 - 1 0 \% )$ splits, for each of which we used 10-fold cross-validation.
+
+UCI Adult Income: It is a well-known public dataset extracted from the 1994 Census database $\pm$ It includes the details such as education level and demographics to predict whether the income of a person exceeds $\$ 508$ /yr. The data consists of six continuous and eight categorical features. After one-hot encoding of categorical features, there are total of 101 features. The pre-processing steps can be found in Section B.1 of Appendix.
+
+UCI BlogFeedback: The data originates from blog posts, and is originally used for regression task of predicting the number of comments in the upcoming 24 hours. Similar to Yoon et al. $\check { \left| 4 6 \right| }$ , we turned it into a binary classification task of predicting whether there is a comment for a post or not.There are 280 integer and real valued features, and separate training and test datasets are provided. Further information can be found in Section B.2 of Appendix.
+
+# 3.2 Evaluation
+
+For self-supervised models, once the models are trained, we evaluate them by training a logistic regression model on the latent representations of training set, and testing it on the latent representation of the test set. For SubTab, the joint latent representation is obtained by using the mean aggregation of embeddings of the subsets for both training and test sets. We use the performance on a classification task as a measure of quality of the representation as it is usually done in the self-supervised learning. MNIST has 10, TCGA has 38, and the rest (i.e. Obesity, Income, and Blog) has 2 classes each.
+
+# 3.3 Results
+
+MNIST: We used a simple three-layer encoder architecture with dimensions of [512, 256, 128], referred as the base model, in which the last layer is a linear layer. During training of the base model, we used both reconstruction and contrastive losses. Additionally, we trained our model under three conditions: i) without any noise in the input data, ii) with noise in the input data and iii) same as (ii), but we also added distance loss computed for pairs of projections $\{ z _ { i } , z _ { j } , \ldots \}$ .
+
+![](images/f22844ca8a29df355d839bd394288cedfe8ccc7994506998c0476fd0d48d621c.jpg)  
+Figure 3: a) Test accuracy on MNIST dataset over different number of subsets and varying levels of overlaps. b-c) t-SNE plots for training (b) and test (c) sets of MNIST for the case of using 4 subsets with $7 5 \%$ overlap between neighboring subsets.
+
+![](images/916e7798e05f50a945f8f30f63ca1aaa7a644ab72658c1a8f73ebc551c186b1d.jpg)  
+Figure 4: a) After training the base model (latent dimension ${ \boldsymbol { \mathbf { \rho } } } = 1 2 8$ ) on four subsets with $7 5 \%$ overlap, we test its performance using different number of subsets. The performance improves as we start increasing number of subsets involved in prediction. b) Comparing our model to CNN-based SOTA models trained on $2 8 \mathbf { x } 2 8$ MNIST in image format (please see Section 3.4 for details).
+
+For SubTab, we trained our base model multiple times without noise at the input. For each training, we used different number of subsets with different levels of overlap between neighbouring subsets (Figure $\textcircled { 3 } \textcircled { \mu }$ . For small number of subsets (e.g. 2 or 3), the performance monotonically decreases when we increase the overlap between subsets. But, for higher number of subsets, the performance generally improves as we increase the number of shared features between the neighbouring subsets. In general, our results show that $K = 4$ with $7 5 \%$ overlap, and $K = 7$ with $50 \%$ overlap perform the best in MNIST dataset, where $K$ refers to the number of subsets. Figure $^ 3$ also shows t-SNE plots of training and test sets for $\mathrm { K } = 4$ with $7 5 \%$ overlap, which proves the high quality of clustering, while Table $\perp$ summarizes the classification accuracy of all models on the test set. Our base model without noise outperforms autoencoder baselines and other self-supervised models with the same architecture. We experimented with three noise types for all self-supervised models, and observed that adding swap-noise at the input pushes the performance higher. For SubTab, adding distance loss and increasing the dimensions of the last layer from 128 to 512 help improve the performance even further. Moreover, we conducted three additional experiments (details in Section $\dot { \mathbf { C } } . 3$ of Appendix):
+
+In the first experiment, for the optimum case of $K = 4$ with $7 5 \%$ overlap, we trained and tested accuracy of a linear model by using the joint representations obtained from the varying number of subsets. Starting with a single subset of the data, we plot the training and test accuracy of the model (Figure $^ { 4 \mathrm { { a } } ) }$ . The linear model is able to achieve $8 7 . 5 \%$ test accuracy using the representation of a single subset. As we start adding latent representations of remaining subsets, both the training and test accuracy keep increasing, eventually achieving top accuracy when all subsets are used. The evolution of clusters corresponding to Figure $\textcircled { 4 } \textcircled { \scriptsize { \tt d } }$ can be seen in Figure $\mathbf { A } 7$ in Appendix. This experiment indicates that we can achieve a good performance using only small subset of features when we don’t have access to data on other features.
+
+![](images/3dc8d84d69b06eb39db88cb75022b9f6e386e5ec4ce588e49abc154b0e5ebca6.jpg)  
+Figure 5: a) The test accuracy using the mean aggregation of the latent representations of subsets, starting with the first subset, and keep adding new subsets sequentially. b) The test accuracy of individual subsets. c) Comparing the test accuracy by aggregating the representations of different set of subsets at test time for two versions of the model; untrained and the one trained on all subsets.
+
+In the second experiment, we evaluated SubTab under the condition of missing features during training (Figure $5 \mathrm { a } )$ . To do so, we first sliced the unshuffled features of MNIST to seven subsets with no overlap (the case corresponding to the legend "7" at zero overlap in Figure $3 \mathrm { a } )$ . Each subset corresponds to four rows in a $2 8 \mathbf { x } 2 8$ image, starting from top four rows (subset 1) to the bottom ones (subset 7). Then, we trained the base model on five different sets of subsets; $\{ 4 \} , \{ 4 , 5 \} , \{ 3 , 4 , 5 \} , \{ 2 , 3 , 4 , 5 , 6 \}$ , and $\{ 1 , 2 , 3 , 4 , 5 , 6 , 7 \}$ , resulting in five different trained SubTab models. Please note that we selected the sets such that we expand out from the most informative middle regions of the image (i.e. subset 4) to the least informative top and bottom areas.
+
+In order to compare the performance of five models, we followed the following steps for each trained model: 1) We first obtained the embeddings of all seven subsets for both training and test sets; 2) We then trained and evaluated a logistic regression model by using the joint embedding of each of the following seven sets: $\{ 1 \} , \{ 1 , \bar { 2 } \} , \{ 1 , \bar { 2 , } 3 \} , . . . , \{ 1 , 2 , 3 , 4 , 5 , 6 , \bar { 7 } \}$ i.e. starting from the first subset, we kept adding new subsets sequentially to increase the information content in the sets. For example, for the set $\{ 1 , 2 , 3 \}$ , we first trained a logistic regression model by using joint embedding of subset 1, 2 and 3 from training set, and evaluated it by using the joint embedding of same subsets from test set. The joint embedding of a set is obtained by using mean aggregation of embeddings of subsets in the set. In addition to five models, we initialized a sixth SubTab model, but kept it untrained and followed the same procedure described before to use it as a baseline. The results are shown in Figure 5a.
+
+In this experiment, we observe that even when the model is trained on a single subset (subset 4, or the blue line in Figure $\textcircled { 5 } \textcircled { \scriptsize { \mathtt { h } } }$ , aggregating the representations of all seven subsets including the subsets not used in training does improve the results. This is because the encoder is able to map samples of different classes to different points in latent space even if it is not trained on them. Since we use the mean aggregation over different views (i.e. subsets) of the same class, we can still make each class in the data distinguishable from the rest in the latent space. We also note that when the model is trained on more and more subsets, its performance keeps improving. As a baseline, we also conducted the same test using untrained model (red line in the plot), and observed similar behaviour in which the test accuracy generally improves as we use more subsets when constructing the joint latent representation. Moreover, we measured the test accuracy of individual subsets to see how informative each subset is (Figure $\textcircled { 5 } \textcircled { > }$ . The result is as expected since we kept the features unshuffled in this experiment, and know that the subsets corresponding to the mid-region of the images (i.e. subsets 3, 4, and 5) should be more informative than the ones corresponding to the top and bottom regions (i.e. subsets 1, and 7). We repeated the same experiment using 28 subsets to get a higher resolution and added the result in Figure A8 in Appendix. From this experiment; i) we see that joint representation improves as we include more subsets (i.e. sub-views) at training and/or test time, ii) we can identify the informative subsets of features using SubTab framework.
+
+In the third experiment, we evaluated SubTab on handling missing features at test time. Specifically, we used the model trained on all subsets, and compared it to the untrained model (i.e. our baseline). For each model, we obtained the joint embedding for training set by using mean aggregation over embeddings of all seven subsets, and then trained a linear model. The test accuracy of the linear model is measured by using; i) only subset 4, ii) aggregate of the most informative subsets {3,4,5}, iii) aggregate of {2,3,4,5,6} excluding the least informative subsets, and iv) all seven subsets of the test set (Figure 5c).
+
+Table 1: Accuracy scores for all models for various datasets. The abbreviations in the table; NC: Neighbour columns used, RF: Random features used, G: Gaussian noise used, S: Swap noise used.   
+
+<table><tr><td>Type</td><td>Models</td><td>MNIST</td><td>Income</td><td>Blog</td><td>Obesity</td><td>TCGA</td></tr><tr><td rowspan="3">Supervised baseline</td><td>Logistic Regression</td><td>92.60±0.03</td><td>84.68±0.05</td><td>84.15±0.12</td><td>62.35±4.02</td><td>36.98± 1.25</td></tr><tr><td>Random Forest</td><td>96.96±0.06</td><td>84.62±0.07</td><td>83.61±0.15</td><td>67.45±2.23</td><td>61.62± 1.02</td></tr><tr><td>XGBoost</td><td>98.02±0.086</td><td>86.11±0.20</td><td>84.29±0.23</td><td>64.05±4.52</td><td>72.61±1.31</td></tr><tr><td rowspan="2">Autoencoder baseline</td><td>AE</td><td>92.77±0.32</td><td>84.67±0.07</td><td>84.06±0.24</td><td>61.96±3.28</td><td>55.16±0.75</td></tr><tr><td>AE w/Dropout (p=0.2)</td><td>94.31±0.28</td><td>85.00±0.10</td><td>84.18±0.20</td><td>62.74±4.38</td><td>56.87±2.26</td></tr><tr><td rowspan="9">Self- supervised</td><td>DAE (RF)</td><td>96.30±0.14 (S)</td><td>84.37±0.36 (G)</td><td>84.12±0.29 (G)</td><td>56.43±5.79 (G)</td><td>54.31±1.39 (G)</td></tr><tr><td>CAE (NC)</td><td>96.39±0.20 (S)</td><td>84.24±0.18 (G)</td><td>84.3±0.31 (G)</td><td>62.26±5.01 (G)</td><td>54.20±1.17(G)</td></tr><tr><td>VIME-self</td><td>95.23±0.17 (S)</td><td>84.43±0.08 (G)</td><td>84.11±0.27(G)</td><td>66.45±4.54(G)</td><td>55.11±1.37 (G)</td></tr><tr><td>SubTabwith:</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Base model (No noise)</td><td>97.26±0.2</td><td>85.31±0.08</td><td>84.29±0.26</td><td>68.01±3.07</td><td>57.02±1.50</td></tr><tr><td>+Noise</td><td>97.47±0.18 (S)</td><td>85.34±0.07 (G)</td><td>84.47±0.15 (G)</td><td>71.13±4.08 (G)</td><td>58.25±1.36 (G)</td></tr><tr><td>+Distance loss</td><td>97.52±0.14 (S)</td><td>85.35±0.06(G)</td><td>84.64±0.19 (G)</td><td>69.25±4.19 (G)</td><td>58.15±1.56 (G)</td></tr><tr><td>+LatentDim=512</td><td>97.86±0.07 (S)</td><td>=</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>=</td><td></td></tr></table>
+
+The results indicate that SubTab can accommodate missing features at test time, and can still perform well. This might also indicate that working with subsets can give us a way to deal with uncertainty better when there are missing features at test time. As the model collects more information in the form of more features, its prediction improves (see Figure $\textcircled { 5 } \mathrm { { c } }$ ). We can also train the model when there are missing subsets during training, and it still performs well (e.g. see legend "4", corresponding to the model trained only on subset 4, in Figure $: 5 \mathrm { a } \big )$ . Our experiments simulate a practical scenario. For example, in healthcare, we might not have access to some features in one hospital while we might have them in another. So, our method would be beneficial in this type of cases.
+
+Overall, we can make the following observations from our experiments: i) the less informative subsets can add value to the overall representation, or at least does not harm the performance (see the aggregate over {3,4,5} versus "All" in Figure $\textcircled { 5 } \mathrm { { c } }$ , ii) untrained model can be used to analyze which subsets can be potentially more informative, iii) once a model is trained on a subset, the performance of the individual subset does not change whether it is trained together with other subsets or not (for example, compare the performance of subset 3, 4, and 5 across all models in Figure $^ { 5 | { \scriptsize 5 } ) } _ { \cdot }$ , iv) general idea behind our framework works even for untrained model, and v) we may not need to impute data in our framework since we can simply ignore them as missing subsets, which is good since imputation generally distorts data, and the results.
+
+TCGA: We used an encoder architecture with three layers [1024, 784, 784], where the third layer is linear. For VIME-self, DAE, CAE, and our model, we experimented with three noise types (Gaussian, swap, and zero-out noise) at the different $\%$ levels of masking ratio $p$ . We observed that $p = [ 0 . 1 5 , 0 . 3 ]$ range worked well for all models. For Gaussian noise, we used a distribution with zero mean, and different levels of standard deviation $( \sigma )$ . Among all three noise types, Gaussian noise with $\sigma = 0 . 1$ worked the best for all models. Please note that VIME-self uses swap-noise in its original implementation, but swap-noise does not work well on this dataset. For SubTab, similar to MNIST, we used four subsets with $7 5 \%$ overlap. SubTab performs better than other self-supervised models with a significant margin and almost doubles the performance of logistic regression model trained on raw data as shown in Table 1.
+
+Obesity: We used a two-layer encoder with [1024, 1024] dimensions. Second layer is a linear layer. Gaussian noise $\mathcal { N } ( 0 , 0 . 3 )$ and masking ratio $p = 0 . 2$ works well across all models. Six subsets $K = 6$ ) with $0 \%$ overlap performed the best for the SubTab. We note that this dataset has 164 obese patients out of 253 total patients. So, the baseline accuracy is $1 6 4 / 2 5 3 = 6 4 . 8 2 \%$ . Based on this fact, we can say that all models, except ours, did not perform well on this dataset. Our model with added Gaussian noise results in accuracy of $7 1 . 1 3 \pm 4 . 0 8 \%$ , which is well above all models, including supervised ones. It means that our model was able to learn useful representation from the data. We should also note that the performance of our model is much better than what Oh and Zhang $\pmb { \mathbb { B } } 6 \mathbb { I }$ reported $( 6 6 \pm 3 . 2 \% )$ even though they trained a DAE on the same data, and reported their results using a random forest, a non-linear model, on the learned representations rather than a linear model.
+
+UCI Adult Income & BlogFeedback: For these two datasets, we used the same architecture as in Obesity. For Income dataset, the best performance is obtained using 5 subsets with $25 \%$ overlap whereas we used 7 subsets with $7 5 \%$ overlap for Blog dataset. For the base model, we only used reconstruction loss. Adding Gaussian noise to the input and distance loss to the objective improves the performance for both datasets. SubTab outperforms other self-supervised models in both datasets.
+
+The choice of hyper-parameters and other details for all experiments can be found in Table A1 in Section C.1 of Appendix.
+
+# 3.4 Ablation study
+
+We conducted a comprehensive ablation study using MNIST. Table 2 summarizes our experiments. The first thing to note is that the performance of the our base model is already good with only reconstruction loss. Hence, we can argue that the reconstruction of original feature space from a subset of features is a very effective way of learning representation. By adding noise to the input data, we can improve the performance. In the case of MNIST, swap-noise is very effective. Also, by adding additional losses such as contrastive, and distance losses as well as increasing the dimension of representation layer from 128 to 512, we can further improve the results. Moreover, we shuffled the features of MNIST to make sure that we don’t have any gains from unintentional spatial
+
+Table 2: Ablation study using MNIST with 4 subsets with $7 5 \%$ overlap. Abbreviations are; RL: Reconstruction Loss, CL: Contrastive Loss, DL: Distance Loss, SF: Shuffled Features, LD: Latent Dim, Agg: Aggregating embeddings.   
+
+<table><tr><td rowspan=1 colspan=1>RL</td><td rowspan=1 colspan=1>CL</td><td rowspan=1 colspan=1>Noise</td><td rowspan=1 colspan=1>DL</td><td rowspan=1 colspan=1>SF</td><td rowspan=1 colspan=1>LD</td><td rowspan=1 colspan=1>Agg</td><td rowspan=1 colspan=1>Test Accuracy</td></tr><tr><td rowspan=2 colspan=1>+1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.13</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.11</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.26</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Zero-out</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=3 colspan=1>97.2597.2597.47</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Gaussian</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.52</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.2</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>1</td><td rowspan=2 colspan=1>95.9297.86</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>+</td></tr></table>
+
+correlations between neighboring features. We kept all parameters and random seeds same for the comparison. As shown in the table, our model’s performance does not change much. We also tried concatenating latent variables of subsets rather than aggregating them when testing the performance. Comparing last two rows in the table, the aggregation is shown to work much better. Please note that we compared different aggregation functions in Appendix $\underline { { \overline { { \operatorname { F . 4 } } } } }$ showing that mean aggregation worked the best.
+
+Finally, we compared the performance of SubTab on shallow and deep architecture choices. We trained and tested very shallow architectures for SubTab (referred as shallow SubTab), and compared them to relatively deeper SubTab models used in Table $^ 1$ (referred as deep SubTab). We used one-layer encoder and decoder with 784 dimension each for MNIST while using 1024 dimension for other datasets. Shallow SubTab is trained and evaluated under the same conditions as the deeper ones. As shown in Table $\textcircled { 3 }$ shallow SubTab significantly improves results in MNIST and TCGA, placing our model performance on par with CNN-based SOTA models $\pm 0 1 \big [ 1 9 \big ] \big [ 2 5 \big ] \big [ 2 2 \big ] \big [ 3 2 \big ]$ as shown in Figure 4b. Obesity is the only dataset which exploits the deeper architecture.
+
+# 4 Related works
+
+We refer the reader to the introduction section that lists some of the recent noticeable works in self-supervised learning. Since our work focuses on tabular data, we will review some of the recent work done in tabular data in self-supervised framework. The most recent work is mostly based on solving a pretext task. For example, Yoon et al. $\textcircled { 1 4 6 } |$ uses a de-noising autoencoder with a classifier attached to its representation layer. A random binary mask is generated to mask and overwrite a portion of entries in the tabular data, and the corrupted data is given as input to the encoder. The classifier is used to predict the mask while decoder is used to re-construct the uncorrupted original input similar to de-noising autoencoder $\boxed { 4 3 }$ . Although the proposed method is shown to work well in the experiments, there are couple drawbacks to this approach. Firstly, this approach might not work well in very high-dimensional, small and noisy data sets since the model might easily become over-parameterized and be prone to overfitting to the data. Secondly, training a classifier in this setting can be challenging since it needs to predict very high dimensional, sparse, and imbalanced binary mask, similar to the problems observed when training a model on imbalanced, binary dataset. In a similar way, TabNet [1] and TaBERT [45] also tries to recover original data from corrupted one.
+
+Table 3: Comparing shallow and deep SubTab architectures.   
+
+<table><tr><td>Model</td><td>MNIST</td><td>Income</td><td>Blog</td><td>Obesity</td><td>TCGA</td></tr><tr><td>Deep SubTab</td><td>97.86±0.07</td><td>85.35±0.06</td><td>84.64±0.19</td><td>71.13±4.08</td><td>58.25± 1.36</td></tr><tr><td>Shallow SubTab</td><td>98.31±0.06</td><td>85.34±0.03</td><td>84.64±0.09</td><td>66.88±5.35</td><td>61.41±1.11</td></tr></table>
+
+# 5 Conclusion
+
+In this work, we show that a simple MLP-based autoencoder trained on MNIST in tabular format can perform on par with the CNN-based SOTA models trained on MNIST images in unsupervised/selfsupervised framework. SubTab achieves SOTA in MNIST dataset in tabular setting. We also tested our approach on other commonly used tabular datasets, and proved its benefits. In SubTab, the main performance gain comes from two parts of the model: i) reconstruction of all features from the subset of features, and ii) learning the joint representation by aggregating the embeddings of the subsets.
+
+Using subsets of features may obviate the need for data imputation during training, and allows inference using subsets of features at test time. It might open the door to distributed training of high-dimensional data since the models can be trained on different subsets of features at the same time. We can also potentially take advantage of different datasets with common features by assigning those features to same subsets (i.e. transfer learning). We should note that the subsets shared the same autoencoder in our experiments although we could use separate autoencoders for different subsets if some of the features are drastically different than the rest.
+
+SubTab is computationally scalable when we use only reconstruction loss during training. However, using contrastive, and/or distance losses requires the combinations of projections, which makes the computational complexity quadratic during training and limits the number of subsets we can use to divide the data. In this case, computational complexity is still linear at test time since we need to compute only the aggregate of the representations of the subsets. Also, when we divide the features into subsets, we keep the location of features in each subset same throughout training and test time since neural networks are not permutation invariant. As a possible solution, we can extend our work to permutation invariant architectures by treating collection of features as a set. We also showed that SubTab framework can be used to discover most informative subsets of features with limited resolution. A hierarchical version of SubTab might be used for identifying individual important features, but we leave it as a future work.
+
+Finally, although the primary focus of this work is tabular data setting, SubTab can be extended to other domains such as images, audio, text and so on. We leave the extensions and applications of SubTab as a future work.
+
+# 6 Broader Impact
+
+Tabular data is a commonly used format in healthcare, finance, law and many other fields. Despite its broad usage, the most of the research in deep learning, especially with regards to unsupervised representation learning, has been on other data types such as images, text and audio. Our paper tries to close this gap by introducing a new framework to learn good representations from tabular data in unsupervised/self-supervised setting. The progress in this line of research will open doors to widespread applications of tabular data in other areas such as transfer learning, distributed learning, and multi-view learning, in which we can combine knowledge such as demographics and genomics from tabular data with those in images, text and audio. However, we should be aware of the shortcomings of such data integration in terms of biases and privacy issues that it might introduce.
+
+# 7 Acknowledgements
+
+We thank the anonymous reviewers for their helpful and constructive feedback on the paper. We would also like to thank the entire Respiratory and Immunology AI team and are grateful for general support from other organizations within AstraZeneca.
+
+# References
+
+[1] Sercan O Arik and Tomas Pfister. Tabnet: Attentive interpretable tabular learning. arXiv preprint arXiv:1908.07442, 2019.
+
+[2] Bernd Bischl, Giuseppe Casalicchio, Matthias Feurer, Frank Hutter, Michel Lang, Rafael G Mantovani, Jan N van Rijn, and Joaquin Vanschoren. Openml benchmarking suites. arXiv preprint arXiv:1708.03731, 2017.
+
+[3] James P Bridge, Sean B Holden, and Lawrence C Paulson. Machine learning for first-order theorem proving. Journal of automated reasoning, 53(2):141–172, 2014.
+
+[4] Krisztian Buza. Feedback prediction for blogs. In Data analysis, machine learning and knowledge discovery, pages 145–152. Springer, 2014.
+
+[5] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.
+
+[6] Tianqi Chen and Carlos Guestrin. XGBoost: A scalable tree boosting system. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’16, pages 785–794, New York, NY, USA, 2016. ACM. ISBN 978-1-4503-4232-2. doi: 10.1145/2939672.2939785. URL http://doi.acm.org/10.1145/2939672.2939785.
+
+[7] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020.
+
+[8] Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020.
+
+[9] Ronan Collobert and Jason Weston. A unified architecture for natural language processing: Deep neural networks with multitask learning. In Proceedings of the 25th international conference on Machine learning, pages 160–167, 2008.
+
+[10] Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettlemoyer, and Veselin Stoyanov. Unsupervised cross-lingual representation learning at scale. arXiv preprint arXiv:1911.02116, 2019.
+
+[11] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+[12] Dheeru Dua and Casey Graff. UCI machine learning repository, 2017. URL http://archive. ics.uci.edu/ml.
+
+[13] William Falcon and Kyunghyun Cho. A framework for contrastive self-supervised learning and designing a new approach. arXiv preprint arXiv:2009.00104, 2020.
+
+[14] Ananda L Freire, Guilherme A Barreto, Marcus Veloso, and Antonio T Varela. Short-term memory mechanisms in neural network learning of robot navigation tasks: A case study. In 2009 6th Latin American Robotics Symposium (LARS 2009), pages 1–6. IEEE, 2009.
+
+[15] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.
+
+[16] Michael Harries and New South Wales. Splice-2 comparative evaluation: Electricity pricing. 1999.
+
+[17] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738, 2020.
+
+[18] Irwin Hersey. Textures: A photographic album for artists and designers by phil brodatz. Leonardo, 1(1):91–92, 1968.   
+[19] Weihua Hu, Takeru Miyato, Seiya Tokui, Eiichi Matsumoto, and Masashi Sugiyama. Learning discrete representations via information maximizing self-augmented training. In International Conference on Machine Learning, pages 1558–1567. PMLR, 2017.   
+[20] Xu Ji, João F Henriques, and Andrea Vedaldi. Invariant information clustering for unsupervised image classification and segmentation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 9865–9874, 2019.   
+[21] Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. Bag of tricks for efficient text classification. arXiv preprint arXiv:1607.01759, 2016.   
+[22] Lyes Khacef, Laurent Rodriguez, and Benoit Miramond. Improving self-organizing maps with unsupervised feature extraction. In International Conference on Neural Information Processing, pages 474–486. Springer, 2020.   
+[23] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.   
+[24] Ron Kohavi. Scaling up the accuracy of naive-bayes classifiers: A decision-tree hybrid. In Kdd, volume 96, pages 202–207, 1996.   
+[25] Adam R Kosiorek, Sara Sabour, Yee Whye Teh, and Geoffrey E Hinton. Stacked capsule autoencoders. arXiv preprint arXiv:1906.06818, 2019.   
+[26] Emmanuelle Le Chatelier, Trine Nielsen, Junjie Qin, Edi Prifti, Falk Hildebrand, Gwen Falony, Mathieu Almeida, Manimozhiyan Arumugam, Jean-Michel Batto, Sean Kennedy, et al. Richness of human gut microbiome correlates with metabolic markers. Nature, 500(7464):541–546, 2013.   
+[27] Yann LeCun. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998.   
+[28] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   
+[29] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017.   
+[30] DD Lucas, R Klein, J Tannahill, D Ivanova, S Brandon, D Domyancic, and Y Zhang. Failure analysis of parameter-induced simulation crashes in climate models. Geoscientific Model Development, 6(4):1157–1171, 2013.   
+[31] Renata CB Madeo, Clodoaldo AM Lima, and Sarajane M Peres. Gesture unit segmentation using support vector machines: segmenting gestures from rest positions. In Proceedings of the 28th Annual ACM Symposium on Applied Computing, pages 46–52, 2013.   
+[32] Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015.   
+[33] C Merz and PM Murphy. Pima indians diabetes dataset. UCI Repository, 1996.   
+[34] Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013.   
+[35] Michiel O Noordewier, Geoffrey G Towell, and Jude W Shavlik. Training knowledge-based neural networks to recognize genes in dna sequences. In Advances in neural information processing systems, pages 530–536, 1991.   
+[36] Min Oh and Liqing Zhang. Deepmicro: deep representation learning for disease prediction based on microbiome data. Scientific reports, 10(1):1–9, 2020.
+
+[37] Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
+
+[38] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, highperformance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019. URL http://papers.neurips.cc/paper/ 9015-pytorch-an-imperative-style-high-performance-deep-learning-library pdf.
+
+[39] Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A Efros. Context encoders: Feature learning by inpainting. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2536–2544, 2016.
+
+[40] F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12:2825–2830, 2011.
+
+[41] Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pages 1532–1543, 2014.
+
+[42] Katarzyna Tomczak, Patrycja Czerwinska, and Maciej Wiznerowicz. The cancer genome atlas ´ (tcga): an immeasurable source of knowledge. Contemporary oncology, 19(1A):A68, 2015.
+
+[43] Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pages 1096–1103, 2008.
+
+[44] I-Cheng Yeh, King-Jang Yang, and Tao-Ming Ting. Knowledge discovery on rfm model using bernoulli sequence. Expert Systems with Applications, 36(3):5866–5871, 2009.
+
+[45] Pengcheng Yin, Graham Neubig, Wen-tau Yih, and Sebastian Riedel. Tabert: Pretraining for joint understanding of textual and tabular data. arXiv preprint arXiv:2005.08314, 2020.
+
+[46] Jinsung Yoon, Yao Zhang, James Jordon, and Mihaela van der Schaar. Vime: Extending the success of self-and semi-supervised learning to tabular domain. Advances in Neural Information Processing Systems, 33, 2020.
+
+[47] Kun Zhang and Wei Fan. Forecasting skewed biased stochastic ozone days: analyses, solutions and beyond. Knowledge and Information Systems, 14(3):299–326, 2008.

parse/train/vrhNQ7aYSdr/vrhNQ7aYSdr_content_list.json

@@ -0,0 +1,1410 @@
+[
+    {
+        "type": "text",
+        "text": "SubTab: Subsetting Features of Tabular Data for Self-Supervised Representation Learning ",
+        "text_level": 1,
+        "bbox": [
+            204,
+            122,
+            795,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Talip Uçar, Ehsan Hajiramezanali, Lindsay Edwards ",
+        "bbox": [
+            313,
+            224,
+            684,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Respiratory and Immunology, R&D, AstraZeneca {talip.ucar, ehsan.hajiramezanali, lindsay.edwards}@astrazeneca.com ",
+        "bbox": [
+            210,
+            253,
+            785,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Self-supervised learning has been shown to be very effective in learning useful representations, and yet much of the success is achieved in data types such as images, audio, and text. The success is mainly enabled by taking advantage of spatial, temporal, or semantic structure in the data through augmentation. However, such structure may not exist in tabular datasets commonly used in fields such as healthcare, making it difficult to design an effective augmentation method, and hindering a similar progress in tabular data setting. In this paper, we introduce a new framework, Subsetting features of Tabular data (SubTab), that turns the task of learning from tabular data into a multi-view representation learning problem by dividing the input features to multiple subsets. We argue that reconstructing the data from the subset of its features rather than its corrupted version in an autoencoder setting can better capture its underlying latent representation. In this framework, the joint representation can be expressed as the aggregate of latent variables of the subsets at test time, which we refer to as collaborative inference. Our experiments show that the SubTab achieves the state of the art (SOTA) performance of $9 8 . 3 1 \\%$ on MNIST in tabular setting, on par with CNN-based SOTA models, and surpasses existing baselines on three other real-world datasets by a significant margin. ",
+        "bbox": [
+            233,
+            349,
+            766,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            612,
+            310,
+            628
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, the self-supervised learning has successfully been used to learn meaningful representations of the data in natural language processing [34, 41, 11, 28, 10, 21, 9]. A similar success has been achieved in image and audio domains [7, 15, 37, 5, 17, 13, 8]. This progress is mainly enabled by taking advantage of spatial, semantic, or temporal structure in the data through data augmentation [7] , pretext task generation [11] and using inductive biases through architectural choices (e.g. CNN for images). However, these methods can be less effective in the lack of such structures and biases in the tabular data commonly used in many fields such as healthcare, advertisement, finance, and law. And some augmentation methods such as cropping, rotation, color transformation etc. are domain specific, and not suitable for tabular setting. The difficulty in designing similarly effective methods tailored for tabular data is one of the reasons why self-supervised learning is under-studied in this domain $\\lVert \\overline { { 4 6 } } \\rVert$ . ",
+        "bbox": [
+            174,
+            643,
+            825,
+            796
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The most common approach in tabular data is to corrupt data through adding noise $\\boxed { 4 3 }$ . An autoencoder maps corrupted examples of data to a latent space, from which it maps back to uncorrupted data. Through this process, it learns a representation robust to the noise in the input. This approach may not be as effective since it treats all features equally as if features are equally informative. However, perturbing uninformative features may not result in the intended goal of the corruption. A recent work takes advantage of self-supervised learning in tabular data setting by introducing a pretext task [46], in which a de-noising autoencoder with a classifier attached to representation layer is trained on corrupted data. The classifier’s task is to predict the location of corrupted features. However, this framework still relies on noisy data in the input. Additionally, training a classifier on an imbalanced binary mask for a high-dimensional data may not be ideal to learn meaningful representations. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/627972ccde368e4abb61346ab5503e52534cfdcce989262378148d136190a787.jpg",
+        "image_caption": [
+            "Figure 1: SubTab framework: i) Dividing the features into subsets (similar to feature bagging, or cropping images), ii) Reconstruction of either subsets of features $( \\tilde { x } _ { 1 } , \\tilde { x } _ { 2 } , \\tilde { x } _ { 3 } )$ , or complete feature space $( \\breve { \\tilde { X } } _ { 1 } , \\tilde { X } _ { 2 } , \\tilde { X } _ { 3 } )$ , which are used to compute reconstruction loss. iii) Generating projections used to compute contrastive and distance loss. $E \\equiv E n c o d e r .$ $D \\equiv D e c o d e r$ , $G \\equiv P r$ ojection. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            88,
+            815,
+            304
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            398,
+            825,
+            440
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we turn the problem of learning representation from a single-view of the data into the one learnt from its multiple views by dividing the features into subsets, akin to cropping in image domain or feature bagging in ensemble learning, to generate different views of the data. Each subset can be considered a different view. We show that reconstructing data from the subset of its features forces the encoder to learn better representation than the ones learned through the existing methods such as adding noise. We train our model in a self-supervised setting and evaluate it on downstream tasks such as classification, and clustering. We use five different datasets; MNIST in tabular format, the cancer genome atlas (TCGA) [42], human gut metagen-omic samples of obesity cohorts (Obesity) [36, 26], UCI adult income (Income) [24], and UCI BlogFeedback (Blog) [4]. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            571
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SubTab can: i) construct a better representation by using the aggregate of the representation of the subsets, a process that we refer as collaborative inference ii) discover the regions of informative features by measuring predictive power of each subset, which is useful especially in high-dimensional data iii) do training and inference in the presence of missing features by ignoring corresponding subsets and iv) use smaller models by reducing input dimension, making it less prone to overfitting. ",
+        "bbox": [
+            174,
+            578,
+            825,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            669,
+            271,
+            685
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The augmentation methods such as adding noise, rotation, cropping etc. are commonly used in image domain. Among them, the cropping is shown to be the most effective technique $\\textcircled { 7 }$ . Inspired from this insight, we propose subsetting features of tabular data. ",
+        "bbox": [
+            176,
+            702,
+            823,
+            744
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 presents SubTab framework, in which we have an encoder (E), a decoder (D), and an optional projection (G). For the purpose of this paper, we will refer $^ { h }$ as latent, or representation, $_ { z }$ as projection, $\\tilde { \\pmb x }$ , and $\\tilde { X }$ as the reconstruction of subset, and whole data respectively. Small letters are associated with subsets while capital latters are associated the whole set of features. Moreover, throughout this work, when we say that a representation is \"good\", we refer to its performance in a classification task using a linear model. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In SubTab framework, we divide tabular data to multiple subsets. Neighbouring subsets can have overlapping regions, defined as a percentage of a dimension of the subset. Each of the subsets is fed to the same encoder (i.e. parameter sharing) to get their corresponding latent representation. A shared decoder is used to reconstruct either the subset fed to the encoder, or full tabular data (i.e. reconstructing all features from the subset of features). We chose the latter in our experiments since it is more effective in learning good representations. We should also note that, in the latter case, the autoencoder cannot learn the identity, eliminating the constraint on the dimension of the bottleneck (i.e. representation). We compute one reconstruction loss term per subset. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/07c289a2119a323df61b9f955041fe75764f373e6d0ba73815abb1733a070355.jpg",
+        "image_caption": [
+            "Figure 2: a) Push-Pull forces applied by each loss. PS / NS $:$ Positive/Negative sample; CL/RL/DL: Contrastive, Reconstruction, Distance losses b) Column or feature selection strategies for adding noise to each subset. Top: Selecting a block of neighbouring columns; Middle: Selecting columns randomly; Bottom: Selecting random features per row c) Latent variables from each subset is aggregated at test time. The mean (default), sum, max, or min aggregation can be used. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            826,
+            227
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            332,
+            825,
+            375
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we can optionally add contrastive loss to our objective by using all combination of pairs of projections from all subsets. For example, given three subsets as in Figure 1, there are three combinations of two: $\\textstyle { { \\binom { n } { k } } = { \\binom { 3 } { 2 } } = { \\frac { 3 ! } { 2 ! ( 1 ) ! } } = \\dot { 3 } }$ . For four subsets, it would be 6 pairs of combination, and so on. We can add one more loss term, referred as distance loss, to reduce the distance between the pairs of projections of the subsets by using a loss function such as mean squared error (MSE). All three loss terms apply a pulling force on positive samples while contrastive loss also applies a push force between positive and negative samples as shown in Figure 2a. ",
+        "bbox": [
+            173,
+            381,
+            826,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Once the dataset is divided into subsets in data preparation step, a process that is similar to feature bagging in ensemble learning, their location is fixed. Thus, we don’t change the relative order of features in a subset during training since standard neural network architectures are not permutation invariant. This is to ensure that same features are fed to the same input units of neural network. However, our method can be extended to permutation invariant setting as a next step. ",
+        "bbox": [
+            173,
+            488,
+            826,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Strategies for adding noise ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            398,
+            590
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our framework is complementary to other augmentation techniques used in tabular data setting. Thus, we experimented with adding noise to randomly selected entries in each subset by using three types of noise: i) adding Gaussian noise, ${ \\mathcal { N } } ( 0 , \\sigma ^ { 2 } )$ , ii) overwriting the value of a selected entry with another value randomly sampled from the same column, referred as swap-noise, iii) zeroing-out randomly selected entries, referred as zero-out noise. ",
+        "bbox": [
+            173,
+            601,
+            826,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we use three different strategies when selecting the features to add noise to, as shown in Figure 2b: i) a random block of neighboring columns (NC), ii) random columns (RC) iii) random features per each sample (RF). To add noise, we create a binomial mask, $_ { \\mathbf { \\nabla } } \\mathbf { m }$ , and a noise matrix, $\\epsilon$ with same shape as the subset, in which the entries of the mask is assigned to 1 with probability $p$ and to 0 otherwise. The corrupted version, $\\scriptstyle { \\mathbf { \\mathcal { x } } } _ { 1 c }$ , of subset $\\mathbf { \\mathbf { { x } _ { 1 } } }$ is generated as following: ",
+        "bbox": [
+            173,
+            676,
+            825,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d4198aa59c43c1593f987ffc50f576df02bea159edf31b78431d296044a9ab5.jpg",
+        "text": "$$\nx _ { 1 c } = ( 1 - m ) \\odot x _ { 1 } + m \\odot \\epsilon\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            755,
+            612,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Training ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            797,
+            274,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our objective function is: ",
+        "bbox": [
+            174,
+            824,
+            343,
+            838
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9437c1daa58e50459dccf9e649fd1c10bde9db486071ae6dbcc7ab2c8adab86.jpg",
+        "text": "$$\n\\mathcal { L } _ { t } = \\mathcal { L } _ { r } + \\mathcal { L } _ { c } + \\mathcal { L } _ { d } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            839,
+            568,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { t } , \\mathcal { L } _ { r }$ , $\\mathcal { L } _ { c }$ and $\\mathcal { L } _ { d }$ are total, reconstruction, contrastive, and distance losses, respectively. ",
+        "bbox": [
+            171,
+            861,
+            797,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "i) Reconstruction loss: Given a subset, denoted by $\\scriptstyle { \\mathbf { 2 } } \\mathbf { 4 }$ , we can reconstruct either the same subset, $\\tilde { \\mathbfit { x } } _ { k }$ or the entire feature space $\\tilde { X } _ { k }$ . Then, we can compute the reconstruction loss for $k ^ { t h }$ subset by ",
+        "bbox": [
+            174,
+            881,
+            820,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "computing mean squared error using either $( x _ { k } , \\tilde { x } _ { k } )$ , or $( X , \\tilde { X } _ { k } )$ pair as shown in Figure 1. We chose the latter since it was more effective. Overall reconstruction loss: ",
+        "bbox": [
+            174,
+            87,
+            825,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/580e6b0217831951a3058982152fafc0934e4eb90057af2b8bd839efe0bb439e.jpg",
+        "text": "$$\n\\mathcal { L } _ { r } = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } s _ { k } , \\mathrm { w h e r e } s _ { k } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\left( X ^ { ( i ) } - \\tilde { X } _ { k } ^ { ( i ) } \\right) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            121,
+            684,
+            165
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $K$ is the total number of subsets, $N$ is the size of the batch, $s _ { k }$ is the reconstruction loss for $k ^ { t h }$ subset, and $\\mathcal { L } _ { r }$ is the average of reconstruction loss over all subsets. ",
+        "bbox": [
+            173,
+            167,
+            823,
+            196
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "ii) Contrastive loss: If the dataset is rich in the number of classes such that chances of sampling negative samples are high, we can use a projection network (G) to get projections, $z ^ { \\prime } s$ , of representations, $\\bar { \\boldsymbol { h } } ^ { \\prime } \\boldsymbol { s }$ . Samples at the same rows of two subsets, ${ z } _ { 1 }$ and ${ z _ { 2 } }$ , can be considered as positive pairs while remaining rows in the subsets can be considered as negative to those samples.This allows us to compute the contrastive loss for each pair of projections using a loss function such as the normalized temperature-scaled cross entropy loss (NT-Xent) $\\lVert \\rVert$ . For three subsets, $\\{ x _ { 1 } , x _ { 2 } , x _ { 3 } \\}$ , we can compute such a loss for every pair $\\{ z _ { a } , z _ { b } \\}$ of total three pairs from the set $\\bar { S } = \\{ \\{ z _ { 1 } , z _ { 2 } \\} , \\{ z _ { 1 } , z _ { 3 } \\} , \\{ z _ { 2 } , z _ { 3 } \\} \\}$ . Overall contrastive loss is: ",
+        "bbox": [
+            173,
+            202,
+            826,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4d30c444a6e285d58f25f2e7c2bc8319416962c2b9555278ff9ddacf5d054c90.jpg",
+        "text": "$$\n\\mathcal { L } _ { c } = \\frac { 1 } { J } \\sum _ { \\{ z _ { a } , z _ { b } \\} \\in S } p ( z _ { a } , z _ { b } ) , \\mathrm { ~ w h e r e ~ } p ( z _ { a } , z _ { b } ) = \\frac { 1 } { 2 N } \\sum _ { i = 1 } ^ { N } \\Big [ l ( z _ { a } ( ^ { i } ) , z _ { b } ( ^ { i } ) ) + l ( z _ { b } ( ^ { i } ) , z _ { a } ( ^ { i } ) ) \\Big ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            319,
+            785,
+            362
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/efac1283abe58d8b738bc71fbcdc0ee594f30d4fdcbb3d10fe7011c34cd29c8d.jpg",
+        "text": "$$\nl ( z _ { \\mathbf { a } } ^ { ( i ) } , z _ { b } ^ { ( i ) } ) = - \\log \\frac { \\exp ( s i m ( z _ { \\mathbf { a } } ^ { ( i ) } , z _ { b } ^ { ( i ) } ) / \\tau ) } { \\sum _ { k = 1 } ^ { N } \\mathbb { 1 } _ { k \\neq i } \\exp ( s i m ( z _ { \\mathbf { a } } ^ { ( i ) } , z _ { b } ^ { ( k ) } ) / \\tau ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            366,
+            694,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $J$ is the total number of pairs in set $S$ , $p ( z _ { a } , z _ { b } )$ is total contrastive loss for a pair of projection $\\{ z _ { a } , z _ { b } \\}$ , $l \\big ( z _ { a } ^ { \\mathrm { ~ } } ^ { ( i ) } , z _ { b } ^ { \\mathrm { ~ } ( i ) } \\big )$ is the loss function for a corresponding positive pairs of examples $( z _ { a } { ^ { ( i ) } } , z _ { b } { ^ { ( i ) } } )$ in subsets $\\{ z _ { a } , z _ { b } \\}$ , and $\\mathcal { L } _ { c }$ is the average of contrastive loss over all pairs. ",
+        "bbox": [
+            173,
+            409,
+            825,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "iii) Distance loss: We can also add mean-squared error (MSE) loss for pairs of projections of subsets since the corresponding samples in subsets should be close to each other. Hence, we can compute an overall MSE loss as: ",
+        "bbox": [
+            173,
+            460,
+            825,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/10243757f66a872741814c00db2785e6ff8c9f244e0bde00635ffbb7b0635ba0.jpg",
+        "text": "$$\n{ \\mathcal { L } } _ { d } = { \\frac { 1 } { J } } \\sum _ { \\{ z _ { a } , z _ { b } \\} \\in S } p ( z _ { a } , z _ { b } ) , { \\mathrm { ~ w h e r e ~ } } p ( z _ { a } , z _ { b } ) = { \\frac { 1 } { N } } \\sum _ { i = 1 } ^ { N } \\left( z _ { a } ^ { ( i ) } - z _ { b } ^ { ( i ) } \\right) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            505,
+            738,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The pseudocode of algorithm can be found in Algorithm $\\bigstar$ in the Appendix. We should note that both $\\mathcal { L } _ { c }$ and $\\mathcal { L } _ { d }$ in equation $^ { ( 2 ) }$ are optional, and we used them only in some experiments. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Test time ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            598,
+            276,
+            613
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At test time, we feed the subsets of test set to the encoder, and get the aggregate of the representations of all available subsets as shown in Figure $2 \\mathrm { c } .$ Please note that we can use mean, sum, min, max, or any other aggregation method to get joint representation, which is analogous to pooling in Computer Vision, or the aggregation of neighbouring nodes in graph convolutional networks $\\pmb { \\widetilde { \\left. 2 3 \\right. } }$ . We used mean aggregation in all our experiments, but did compare different aggregation methods in Appendix F.4. Our experiments show that we can use the representations of only one, or few subsets and still achieve a good performance at test time. For example, we could use only $h _ { 1 }$ , or aggregate of $\\boldsymbol { h } _ { 1 }$ and $h _ { 2 }$ rather than aggregating over all subsets $( h _ { 1 } , h _ { 2 } , h _ { 3 } )$ in Figure $\\boxed { 2 \\mathrm { c } }$ This allows the model to infer from the data even in the presence of missing features, in which case we can ignore the subset with missing features. We can also design an aggregation function that computes weighted mean of the representations of subsets since some subsets might be more informative than others: ",
+        "bbox": [
+            173,
+            623,
+            826,
+            776
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/152de539f8131bb45a01851f5f34a7e5a784ab28aa292b73682f4b1135404582.jpg",
+        "text": "$$\nh = \\frac { 1 } { Z } \\sum _ { k = 1 } ^ { K } \\eta _ { k } * h _ { k } , \\mathrm { a n d } Z = \\sum _ { k = 1 } ^ { K } \\eta _ { k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            780,
+            622,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $K$ is number of subsets, and $\\eta _ { k }$ is the weight for $k _ { t h }$ subset. $\\eta$ can be a learnable parameter in semi-supervised, or supervised setting by using an attention mechanism. We can also use 1D convolution in equation $\\textcircled { 7 }$ by treating representations of subsets as separate channels during training. We left these ideas as future work and used the mean aggregation (i.e. $\\eta _ { k } = 1 \\mathrm { ~ }$ ) throughout our experiments, unless explicitly stated. A comparison of different aggregation methods can be found in Table $\\underline { { \\sqrt { \\bf A } ^ { 3 } } } \\mathrm { | i n }$ the Appendix. ",
+        "bbox": [
+            173,
+            827,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            312,
+            107
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We conducted various experiments on diverse set of tabular datasets including MNIST $\\pm \\pm$ in tabular format, the cancer genome atlas (TCGA) $\\pmb { \\| 4 2 } \\pmb { \\| }$ , human gut metagen-omic samples of obesity cohorts (Obesity) [36, 26], UCI adult income (Income) $\\pm \\overbrace { | 2 4 | }$ , and UCI BlogFeedback (Blog) [4] to demonstrate the effectiveness of the SubTab framework. We compare our method to autoencoder baseline with and without dropout, other self-supervised methods such as VIME-self $\\boxed { \\boxed { 4 6 } }$ , Denoising Autoencoder (DAE) $\\boxed { \\boxplus 3 }$ , and Context Encoder (CAE) $\\textcircled { 1 3 9 } \\textcircled { 1 }$ as well as fully-supervised models such as logistic regression, random forest, and XGBoost $\\textcircled { 6 }$ . For each dataset, once we decided on a particular autoencoder architecture, we used it for all models compared (i.e. VIME-self, DAE, CAE, and our model). We tried both ReLU and leakyReLU as activation functions for all, and both performed equally well. The code for SubTab is provided1. The summary of model architectures and hyperparameters are in Table $\\boxed { \\mathbf { A } 1 }$ in the Appendix. We should note that we ran more experiments using; i) Synthetic datasets and ii) OpenML-CC18 datasets $\\lVert \\rVert$ in Appendix G and H respectively. ",
+        "bbox": [
+            173,
+            121,
+            825,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Data ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            304,
+            246,
+            318
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "MNIST: We flattened $2 8 \\mathbf { x } 2 8$ images, and scaled them by dividing all with 255 as it is done in [46]. We split training set into training and validation sets $( 9 0 - 1 0 \\%$ split) when searching for hyper-parameters, and then used all of training set to train the final model. The test set is used only for final evaluation. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            372
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Cancer Genome Atlas (TCGA): TCGA is a public cancer genomics dataset characterized over 20,000 primary cancer and matched normal samples that holds information over 38 cohorts. The task is to classify the cancer cohorts from the reverse phase protein array (RPPA) dataset. It includes 6671 samples with 122 features, which we divided to $8 0 { - } 1 0 { - } 1 0 \\%$ train-validation-test sets. Once hyper-parameters is found, we trained the models on combined training and validation set. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Obesity: The dataset consists of publicly available human gut metagen-omic samples of obesity cohorts $\\textcircled { 1 3 6 }$ . It is derived from whole-genome shotgun metagenomic studies. The dataset consists of 164 obese patients and 89 non-obese controls and has 425 features $\\pmb { \\left. 2 6 \\right. }$ . We scaled the dataset by using min-max scaling. Since it is a small dataset, we evaluated the model by using 10 randomly drawn training-test $( 9 0 - 1 0 \\% )$ splits, for each of which we used 10-fold cross-validation. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "UCI Adult Income: It is a well-known public dataset extracted from the 1994 Census database $\\pm$ It includes the details such as education level and demographics to predict whether the income of a person exceeds $\\$ 508$ /yr. The data consists of six continuous and eight categorical features. After one-hot encoding of categorical features, there are total of 101 features. The pre-processing steps can be found in Section B.1 of Appendix. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            599
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "UCI BlogFeedback: The data originates from blog posts, and is originally used for regression task of predicting the number of comments in the upcoming 24 hours. Similar to Yoon et al. $\\check { \\left| 4 6 \\right| }$ , we turned it into a binary classification task of predicting whether there is a comment for a post or not.There are 280 integer and real valued features, and separate training and test datasets are provided. Further information can be found in Section B.2 of Appendix. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            693,
+            289,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For self-supervised models, once the models are trained, we evaluate them by training a logistic regression model on the latent representations of training set, and testing it on the latent representation of the test set. For SubTab, the joint latent representation is obtained by using the mean aggregation of embeddings of the subsets for both training and test sets. We use the performance on a classification task as a measure of quality of the representation as it is usually done in the self-supervised learning. MNIST has 10, TCGA has 38, and the rest (i.e. Obesity, Income, and Blog) has 2 classes each. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            818,
+            263,
+            832
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "MNIST: We used a simple three-layer encoder architecture with dimensions of [512, 256, 128], referred as the base model, in which the last layer is a linear layer. During training of the base model, we used both reconstruction and contrastive losses. Additionally, we trained our model under three conditions: i) without any noise in the input data, ii) with noise in the input data and iii) same as (ii), but we also added distance loss computed for pairs of projections $\\{ z _ { i } , z _ { j } , \\ldots \\}$ . ",
+        "bbox": [
+            174,
+            844,
+            825,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/f22844ca8a29df355d839bd394288cedfe8ccc7994506998c0476fd0d48d621c.jpg",
+        "image_caption": [
+            "Figure 3: a) Test accuracy on MNIST dataset over different number of subsets and varying levels of overlaps. b-c) t-SNE plots for training (b) and test (c) sets of MNIST for the case of using 4 subsets with $7 5 \\%$ overlap between neighboring subsets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            90,
+            820,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/916e7798e05f50a945f8f30f63ca1aaa7a644ab72658c1a8f73ebc551c186b1d.jpg",
+        "image_caption": [
+            "Figure 4: a) After training the base model (latent dimension ${ \\boldsymbol { \\mathbf { \\rho } } } = 1 2 8$ ) on four subsets with $7 5 \\%$ overlap, we test its performance using different number of subsets. The performance improves as we start increasing number of subsets involved in prediction. b) Comparing our model to CNN-based SOTA models trained on $2 8 \\mathbf { x } 2 8$ MNIST in image format (please see Section 3.4 for details). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            305,
+            720,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            551,
+            823,
+            582
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For SubTab, we trained our base model multiple times without noise at the input. For each training, we used different number of subsets with different levels of overlap between neighbouring subsets (Figure $\\textcircled { 3 } \\textcircled { \\mu }$ . For small number of subsets (e.g. 2 or 3), the performance monotonically decreases when we increase the overlap between subsets. But, for higher number of subsets, the performance generally improves as we increase the number of shared features between the neighbouring subsets. In general, our results show that $K = 4$ with $7 5 \\%$ overlap, and $K = 7$ with $50 \\%$ overlap perform the best in MNIST dataset, where $K$ refers to the number of subsets. Figure $^ 3$ also shows t-SNE plots of training and test sets for $\\mathrm { K } = 4$ with $7 5 \\%$ overlap, which proves the high quality of clustering, while Table $\\perp$ summarizes the classification accuracy of all models on the test set. Our base model without noise outperforms autoencoder baselines and other self-supervised models with the same architecture. We experimented with three noise types for all self-supervised models, and observed that adding swap-noise at the input pushes the performance higher. For SubTab, adding distance loss and increasing the dimensions of the last layer from 128 to 512 help improve the performance even further. Moreover, we conducted three additional experiments (details in Section $\\dot { \\mathbf { C } } . 3$ of Appendix): ",
+        "bbox": [
+            173,
+            587,
+            826,
+            780
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the first experiment, for the optimum case of $K = 4$ with $7 5 \\%$ overlap, we trained and tested accuracy of a linear model by using the joint representations obtained from the varying number of subsets. Starting with a single subset of the data, we plot the training and test accuracy of the model (Figure $^ { 4 \\mathrm { { a } } ) }$ . The linear model is able to achieve $8 7 . 5 \\%$ test accuracy using the representation of a single subset. As we start adding latent representations of remaining subsets, both the training and test accuracy keep increasing, eventually achieving top accuracy when all subsets are used. The evolution of clusters corresponding to Figure $\\textcircled { 4 } \\textcircled { \\scriptsize { \\tt d } }$ can be seen in Figure $\\mathbf { A } 7$ in Appendix. This experiment indicates that we can achieve a good performance using only small subset of features when we don’t have access to data on other features. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3dc8d84d69b06eb39db88cb75022b9f6e386e5ec4ce588e49abc154b0e5ebca6.jpg",
+        "image_caption": [
+            "Figure 5: a) The test accuracy using the mean aggregation of the latent representations of subsets, starting with the first subset, and keep adding new subsets sequentially. b) The test accuracy of individual subsets. c) Comparing the test accuracy by aggregating the representations of different set of subsets at test time for two versions of the model; untrained and the one trained on all subsets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            825,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the second experiment, we evaluated SubTab under the condition of missing features during training (Figure $5 \\mathrm { a } )$ . To do so, we first sliced the unshuffled features of MNIST to seven subsets with no overlap (the case corresponding to the legend \"7\" at zero overlap in Figure $3 \\mathrm { a } )$ . Each subset corresponds to four rows in a $2 8 \\mathbf { x } 2 8$ image, starting from top four rows (subset 1) to the bottom ones (subset 7). Then, we trained the base model on five different sets of subsets; $\\{ 4 \\} , \\{ 4 , 5 \\} , \\{ 3 , 4 , 5 \\} , \\{ 2 , 3 , 4 , 5 , 6 \\}$ , and $\\{ 1 , 2 , 3 , 4 , 5 , 6 , 7 \\}$ , resulting in five different trained SubTab models. Please note that we selected the sets such that we expand out from the most informative middle regions of the image (i.e. subset 4) to the least informative top and bottom areas. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to compare the performance of five models, we followed the following steps for each trained model: 1) We first obtained the embeddings of all seven subsets for both training and test sets; 2) We then trained and evaluated a logistic regression model by using the joint embedding of each of the following seven sets: $\\{ 1 \\} , \\{ 1 , \\bar { 2 } \\} , \\{ 1 , \\bar { 2 , } 3 \\} , . . . , \\{ 1 , 2 , 3 , 4 , 5 , 6 , \\bar { 7 } \\}$ i.e. starting from the first subset, we kept adding new subsets sequentially to increase the information content in the sets. For example, for the set $\\{ 1 , 2 , 3 \\}$ , we first trained a logistic regression model by using joint embedding of subset 1, 2 and 3 from training set, and evaluated it by using the joint embedding of same subsets from test set. The joint embedding of a set is obtained by using mean aggregation of embeddings of subsets in the set. In addition to five models, we initialized a sixth SubTab model, but kept it untrained and followed the same procedure described before to use it as a baseline. The results are shown in Figure 5a. ",
+        "bbox": [
+            173,
+            455,
+            825,
+            594
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we observe that even when the model is trained on a single subset (subset 4, or the blue line in Figure $\\textcircled { 5 } \\textcircled { \\scriptsize { \\mathtt { h } } }$ , aggregating the representations of all seven subsets including the subsets not used in training does improve the results. This is because the encoder is able to map samples of different classes to different points in latent space even if it is not trained on them. Since we use the mean aggregation over different views (i.e. subsets) of the same class, we can still make each class in the data distinguishable from the rest in the latent space. We also note that when the model is trained on more and more subsets, its performance keeps improving. As a baseline, we also conducted the same test using untrained model (red line in the plot), and observed similar behaviour in which the test accuracy generally improves as we use more subsets when constructing the joint latent representation. Moreover, we measured the test accuracy of individual subsets to see how informative each subset is (Figure $\\textcircled { 5 } \\textcircled { > }$ . The result is as expected since we kept the features unshuffled in this experiment, and know that the subsets corresponding to the mid-region of the images (i.e. subsets 3, 4, and 5) should be more informative than the ones corresponding to the top and bottom regions (i.e. subsets 1, and 7). We repeated the same experiment using 28 subsets to get a higher resolution and added the result in Figure A8 in Appendix. From this experiment; i) we see that joint representation improves as we include more subsets (i.e. sub-views) at training and/or test time, ii) we can identify the informative subsets of features using SubTab framework. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the third experiment, we evaluated SubTab on handling missing features at test time. Specifically, we used the model trained on all subsets, and compared it to the untrained model (i.e. our baseline). For each model, we obtained the joint embedding for training set by using mean aggregation over embeddings of all seven subsets, and then trained a linear model. The test accuracy of the linear model is measured by using; i) only subset 4, ii) aggregate of the most informative subsets {3,4,5}, iii) aggregate of {2,3,4,5,6} excluding the least informative subsets, and iv) all seven subsets of the test set (Figure 5c). ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8434a919ca3c7593f3490e8428525103cddf2ab104aecbbf0f5ee30691223d6a.jpg",
+        "table_caption": [
+            "Table 1: Accuracy scores for all models for various datasets. The abbreviations in the table; NC: Neighbour columns used, RF: Random features used, G: Gaussian noise used, S: Swap noise used. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Type</td><td>Models</td><td>MNIST</td><td>Income</td><td>Blog</td><td>Obesity</td><td>TCGA</td></tr><tr><td rowspan=\"3\">Supervised baseline</td><td>Logistic Regression</td><td>92.60±0.03</td><td>84.68±0.05</td><td>84.15±0.12</td><td>62.35±4.02</td><td>36.98± 1.25</td></tr><tr><td>Random Forest</td><td>96.96±0.06</td><td>84.62±0.07</td><td>83.61±0.15</td><td>67.45±2.23</td><td>61.62± 1.02</td></tr><tr><td>XGBoost</td><td>98.02±0.086</td><td>86.11±0.20</td><td>84.29±0.23</td><td>64.05±4.52</td><td>72.61±1.31</td></tr><tr><td rowspan=\"2\">Autoencoder baseline</td><td>AE</td><td>92.77±0.32</td><td>84.67±0.07</td><td>84.06±0.24</td><td>61.96±3.28</td><td>55.16±0.75</td></tr><tr><td>AE w/Dropout (p=0.2)</td><td>94.31±0.28</td><td>85.00±0.10</td><td>84.18±0.20</td><td>62.74±4.38</td><td>56.87±2.26</td></tr><tr><td rowspan=\"9\">Self- supervised</td><td>DAE (RF)</td><td>96.30±0.14 (S)</td><td>84.37±0.36 (G)</td><td>84.12±0.29 (G)</td><td>56.43±5.79 (G)</td><td>54.31±1.39 (G)</td></tr><tr><td>CAE (NC)</td><td>96.39±0.20 (S)</td><td>84.24±0.18 (G)</td><td>84.3±0.31 (G)</td><td>62.26±5.01 (G)</td><td>54.20±1.17(G)</td></tr><tr><td>VIME-self</td><td>95.23±0.17 (S)</td><td>84.43±0.08 (G)</td><td>84.11±0.27(G)</td><td>66.45±4.54(G)</td><td>55.11±1.37 (G)</td></tr><tr><td>SubTabwith:</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Base model (No noise)</td><td>97.26±0.2</td><td>85.31±0.08</td><td>84.29±0.26</td><td>68.01±3.07</td><td>57.02±1.50</td></tr><tr><td>+Noise</td><td>97.47±0.18 (S)</td><td>85.34±0.07 (G)</td><td>84.47±0.15 (G)</td><td>71.13±4.08 (G)</td><td>58.25±1.36 (G)</td></tr><tr><td>+Distance loss</td><td>97.52±0.14 (S)</td><td>85.35±0.06(G)</td><td>84.64±0.19 (G)</td><td>69.25±4.19 (G)</td><td>58.15±1.56 (G)</td></tr><tr><td>+LatentDim=512</td><td>97.86±0.07 (S)</td><td>=</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>=</td><td></td></tr></table>",
+        "bbox": [
+            176,
+            125,
+            823,
+            272
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            296,
+            823,
+            328
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results indicate that SubTab can accommodate missing features at test time, and can still perform well. This might also indicate that working with subsets can give us a way to deal with uncertainty better when there are missing features at test time. As the model collects more information in the form of more features, its prediction improves (see Figure $\\textcircled { 5 } \\mathrm { { c } }$ ). We can also train the model when there are missing subsets during training, and it still performs well (e.g. see legend \"4\", corresponding to the model trained only on subset 4, in Figure $: 5 \\mathrm { a } \\big )$ . Our experiments simulate a practical scenario. For example, in healthcare, we might not have access to some features in one hospital while we might have them in another. So, our method would be beneficial in this type of cases. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            443
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Overall, we can make the following observations from our experiments: i) the less informative subsets can add value to the overall representation, or at least does not harm the performance (see the aggregate over {3,4,5} versus \"All\" in Figure $\\textcircled { 5 } \\mathrm { { c } }$ , ii) untrained model can be used to analyze which subsets can be potentially more informative, iii) once a model is trained on a subset, the performance of the individual subset does not change whether it is trained together with other subsets or not (for example, compare the performance of subset 3, 4, and 5 across all models in Figure $^ { 5 | { \\scriptsize 5 } ) } _ { \\cdot }$ , iv) general idea behind our framework works even for untrained model, and v) we may not need to impute data in our framework since we can simply ignore them as missing subsets, which is good since imputation generally distorts data, and the results. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            574
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "TCGA: We used an encoder architecture with three layers [1024, 784, 784], where the third layer is linear. For VIME-self, DAE, CAE, and our model, we experimented with three noise types (Gaussian, swap, and zero-out noise) at the different $\\%$ levels of masking ratio $p$ . We observed that $p = [ 0 . 1 5 , 0 . 3 ]$ range worked well for all models. For Gaussian noise, we used a distribution with zero mean, and different levels of standard deviation $( \\sigma )$ . Among all three noise types, Gaussian noise with $\\sigma = 0 . 1$ worked the best for all models. Please note that VIME-self uses swap-noise in its original implementation, but swap-noise does not work well on this dataset. For SubTab, similar to MNIST, we used four subsets with $7 5 \\%$ overlap. SubTab performs better than other self-supervised models with a significant margin and almost doubles the performance of logistic regression model trained on raw data as shown in Table 1. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Obesity: We used a two-layer encoder with [1024, 1024] dimensions. Second layer is a linear layer. Gaussian noise $\\mathcal { N } ( 0 , 0 . 3 )$ and masking ratio $p = 0 . 2$ works well across all models. Six subsets $K = 6$ ) with $0 \\%$ overlap performed the best for the SubTab. We note that this dataset has 164 obese patients out of 253 total patients. So, the baseline accuracy is $1 6 4 / 2 5 3 = 6 4 . 8 2 \\%$ . Based on this fact, we can say that all models, except ours, did not perform well on this dataset. Our model with added Gaussian noise results in accuracy of $7 1 . 1 3 \\pm 4 . 0 8 \\%$ , which is well above all models, including supervised ones. It means that our model was able to learn useful representation from the data. We should also note that the performance of our model is much better than what Oh and Zhang $\\pmb { \\mathbb { B } } 6 \\mathbb { I }$ reported $( 6 6 \\pm 3 . 2 \\% )$ even though they trained a DAE on the same data, and reported their results using a random forest, a non-linear model, on the learned representations rather than a linear model. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "UCI Adult Income & BlogFeedback: For these two datasets, we used the same architecture as in Obesity. For Income dataset, the best performance is obtained using 5 subsets with $25 \\%$ overlap whereas we used 7 subsets with $7 5 \\%$ overlap for Blog dataset. For the base model, we only used reconstruction loss. Adding Gaussian noise to the input and distance loss to the objective improves the performance for both datasets. SubTab outperforms other self-supervised models in both datasets. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The choice of hyper-parameters and other details for all experiments can be found in Table A1 in Section C.1 of Appendix. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            154
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.4 Ablation study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            170,
+            315,
+            185
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We conducted a comprehensive ablation study using MNIST. Table 2 summarizes our experiments. The first thing to note is that the performance of the our base model is already good with only reconstruction loss. Hence, we can argue that the reconstruction of original feature space from a subset of features is a very effective way of learning representation. By adding noise to the input data, we can improve the performance. In the case of MNIST, swap-noise is very effective. Also, by adding additional losses such as contrastive, and distance losses as well as increasing the dimension of representation layer from 128 to 512, we can further improve the results. Moreover, we shuffled the features of MNIST to make sure that we don’t have any gains from unintentional spatial ",
+        "bbox": [
+            174,
+            195,
+            496,
+            416
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/d3a13cec0cce50ec12b7b14cfdfec69f1b66f781ca197977829866eaa3f0225a.jpg",
+        "table_caption": [
+            "Table 2: Ablation study using MNIST with 4 subsets with $7 5 \\%$ overlap. Abbreviations are; RL: Reconstruction Loss, CL: Contrastive Loss, DL: Distance Loss, SF: Shuffled Features, LD: Latent Dim, Agg: Aggregating embeddings. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>RL</td><td rowspan=1 colspan=1>CL</td><td rowspan=1 colspan=1>Noise</td><td rowspan=1 colspan=1>DL</td><td rowspan=1 colspan=1>SF</td><td rowspan=1 colspan=1>LD</td><td rowspan=1 colspan=1>Agg</td><td rowspan=1 colspan=1>Test Accuracy</td></tr><tr><td rowspan=2 colspan=1>+1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.13</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.11</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.26</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Zero-out</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=3 colspan=1>97.2597.2597.47</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Gaussian</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.52</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>97.2</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>1</td><td rowspan=2 colspan=1>95.9297.86</td></tr><tr><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>+</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>+</td></tr></table>",
+        "bbox": [
+            511,
+            276,
+            833,
+            392
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "correlations between neighboring features. We kept all parameters and random seeds same for the comparison. As shown in the table, our model’s performance does not change much. We also tried concatenating latent variables of subsets rather than aggregating them when testing the performance. Comparing last two rows in the table, the aggregation is shown to work much better. Please note that we compared different aggregation functions in Appendix $\\underline { { \\overline { { \\operatorname { F . 4 } } } } }$ showing that mean aggregation worked the best. ",
+        "bbox": [
+            173,
+            416,
+            826,
+            498
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we compared the performance of SubTab on shallow and deep architecture choices. We trained and tested very shallow architectures for SubTab (referred as shallow SubTab), and compared them to relatively deeper SubTab models used in Table $^ 1$ (referred as deep SubTab). We used one-layer encoder and decoder with 784 dimension each for MNIST while using 1024 dimension for other datasets. Shallow SubTab is trained and evaluated under the same conditions as the deeper ones. As shown in Table $\\textcircled { 3 }$ shallow SubTab significantly improves results in MNIST and TCGA, placing our model performance on par with CNN-based SOTA models $\\pm 0 1 \\big [ 1 9 \\big ] \\big [ 2 5 \\big ] \\big [ 2 2 \\big ] \\big [ 3 2 \\big ]$ as shown in Figure 4b. Obesity is the only dataset which exploits the deeper architecture. ",
+        "bbox": [
+            173,
+            505,
+            826,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 Related works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            636,
+            325,
+            652
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We refer the reader to the introduction section that lists some of the recent noticeable works in self-supervised learning. Since our work focuses on tabular data, we will review some of the recent work done in tabular data in self-supervised framework. The most recent work is mostly based on solving a pretext task. For example, Yoon et al. $\\textcircled { 1 4 6 } |$ uses a de-noising autoencoder with a classifier attached to its representation layer. A random binary mask is generated to mask and overwrite a portion of entries in the tabular data, and the corrupted data is given as input to the encoder. The classifier is used to predict the mask while decoder is used to re-construct the uncorrupted original input similar to de-noising autoencoder $\\boxed { 4 3 }$ . Although the proposed method is shown to work well in the experiments, there are couple drawbacks to this approach. Firstly, this approach might not work well in very high-dimensional, small and noisy data sets since the model might easily become over-parameterized and be prone to overfitting to the data. Secondly, training a classifier in this setting can be challenging since it needs to predict very high dimensional, sparse, and imbalanced binary mask, similar to the problems observed when training a model on imbalanced, binary dataset. In a similar way, TabNet [1] and TaBERT [45] also tries to recover original data from corrupted one. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d77c8d3e97a02d17070862d5e0be7e995e4e5232fa7d42e52e9f401a42420c5.jpg",
+        "table_caption": [
+            "Table 3: Comparing shallow and deep SubTab architectures. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>MNIST</td><td>Income</td><td>Blog</td><td>Obesity</td><td>TCGA</td></tr><tr><td>Deep SubTab</td><td>97.86±0.07</td><td>85.35±0.06</td><td>84.64±0.19</td><td>71.13±4.08</td><td>58.25± 1.36</td></tr><tr><td>Shallow SubTab</td><td>98.31±0.06</td><td>85.34±0.03</td><td>84.64±0.09</td><td>66.88±5.35</td><td>61.41±1.11</td></tr></table>",
+        "bbox": [
+            238,
+            863,
+            756,
+            910
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            152,
+            299,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we show that a simple MLP-based autoencoder trained on MNIST in tabular format can perform on par with the CNN-based SOTA models trained on MNIST images in unsupervised/selfsupervised framework. SubTab achieves SOTA in MNIST dataset in tabular setting. We also tested our approach on other commonly used tabular datasets, and proved its benefits. In SubTab, the main performance gain comes from two parts of the model: i) reconstruction of all features from the subset of features, and ii) learning the joint representation by aggregating the embeddings of the subsets. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            267
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Using subsets of features may obviate the need for data imputation during training, and allows inference using subsets of features at test time. It might open the door to distributed training of high-dimensional data since the models can be trained on different subsets of features at the same time. We can also potentially take advantage of different datasets with common features by assigning those features to same subsets (i.e. transfer learning). We should note that the subsets shared the same autoencoder in our experiments although we could use separate autoencoders for different subsets if some of the features are drastically different than the rest. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            371
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "SubTab is computationally scalable when we use only reconstruction loss during training. However, using contrastive, and/or distance losses requires the combinations of projections, which makes the computational complexity quadratic during training and limits the number of subsets we can use to divide the data. In this case, computational complexity is still linear at test time since we need to compute only the aggregate of the representations of the subsets. Also, when we divide the features into subsets, we keep the location of features in each subset same throughout training and test time since neural networks are not permutation invariant. As a possible solution, we can extend our work to permutation invariant architectures by treating collection of features as a set. We also showed that SubTab framework can be used to discover most informative subsets of features with limited resolution. A hierarchical version of SubTab might be used for identifying individual important features, but we leave it as a future work. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, although the primary focus of this work is tabular data setting, SubTab can be extended to other domains such as images, audio, text and so on. We leave the extensions and applications of SubTab as a future work. ",
+        "bbox": [
+            176,
+            535,
+            825,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            339,
+            613
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tabular data is a commonly used format in healthcare, finance, law and many other fields. Despite its broad usage, the most of the research in deep learning, especially with regards to unsupervised representation learning, has been on other data types such as images, text and audio. Our paper tries to close this gap by introducing a new framework to learn good representations from tabular data in unsupervised/self-supervised setting. The progress in this line of research will open doors to widespread applications of tabular data in other areas such as transfer learning, distributed learning, and multi-view learning, in which we can combine knowledge such as demographics and genomics from tabular data with those in images, text and audio. However, we should be aware of the shortcomings of such data integration in terms of biases and privacy issues that it might introduce. ",
+        "bbox": [
+            174,
+            627,
+            825,
+            752
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            771,
+            367,
+            789
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank the anonymous reviewers for their helpful and constructive feedback on the paper. We would also like to thank the entire Respiratory and Immunology AI team and are grateful for general support from other organizations within AstraZeneca. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            844
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            266,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Sercan O Arik and Tomas Pfister. Tabnet: Attentive interpretable tabular learning. arXiv preprint arXiv:1908.07442, 2019. ",
+        "bbox": [
+            178,
+            113,
+            823,
+            142
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[2] Bernd Bischl, Giuseppe Casalicchio, Matthias Feurer, Frank Hutter, Michel Lang, Rafael G Mantovani, Jan N van Rijn, and Joaquin Vanschoren. Openml benchmarking suites. arXiv preprint arXiv:1708.03731, 2017. ",
+        "bbox": [
+            178,
+            150,
+            823,
+            193
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[3] James P Bridge, Sean B Holden, and Lawrence C Paulson. Machine learning for first-order theorem proving. Journal of automated reasoning, 53(2):141–172, 2014. ",
+        "bbox": [
+            178,
+            200,
+            823,
+            229
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[4] Krisztian Buza. Feedback prediction for blogs. In Data analysis, machine learning and knowledge discovery, pages 145–152. Springer, 2014. ",
+        "bbox": [
+            179,
+            237,
+            823,
+            267
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[5] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020. ",
+        "bbox": [
+            179,
+            273,
+            823,
+            316
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[6] Tianqi Chen and Carlos Guestrin. XGBoost: A scalable tree boosting system. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’16, pages 785–794, New York, NY, USA, 2016. ACM. ISBN 978-1-4503-4232-2. doi: 10.1145/2939672.2939785. URL http://doi.acm.org/10.1145/2939672.2939785. ",
+        "bbox": [
+            181,
+            325,
+            826,
+            382
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[7] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020. ",
+        "bbox": [
+            178,
+            390,
+            823,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[8] Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020. ",
+        "bbox": [
+            178,
+            439,
+            823,
+            469
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[9] Ronan Collobert and Jason Weston. A unified architecture for natural language processing: Deep neural networks with multitask learning. In Proceedings of the 25th international conference on Machine learning, pages 160–167, 2008. ",
+        "bbox": [
+            179,
+            477,
+            823,
+            520
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[10] Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettlemoyer, and Veselin Stoyanov. Unsupervised cross-lingual representation learning at scale. arXiv preprint arXiv:1911.02116, 2019. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            584
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[11] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018. ",
+        "bbox": [
+            173,
+            592,
+            823,
+            635
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[12] Dheeru Dua and Casey Graff. UCI machine learning repository, 2017. URL http://archive. ics.uci.edu/ml. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[13] William Falcon and Kyunghyun Cho. A framework for contrastive self-supervised learning and designing a new approach. arXiv preprint arXiv:2009.00104, 2020. ",
+        "bbox": [
+            174,
+            680,
+            823,
+            709
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[14] Ananda L Freire, Guilherme A Barreto, Marcus Veloso, and Antonio T Varela. Short-term memory mechanisms in neural network learning of robot navigation tasks: A case study. In 2009 6th Latin American Robotics Symposium (LARS 2009), pages 1–6. IEEE, 2009. ",
+        "bbox": [
+            173,
+            717,
+            823,
+            760
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[15] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020. ",
+        "bbox": [
+            173,
+            767,
+            823,
+            824
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[16] Michael Harries and New South Wales. Splice-2 comparative evaluation: Electricity pricing. 1999. ",
+        "bbox": [
+            173,
+            832,
+            820,
+            861
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738, 2020. ",
+        "bbox": [
+            174,
+            869,
+            826,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[18] Irwin Hersey. Textures: A photographic album for artists and designers by phil brodatz. Leonardo, 1(1):91–92, 1968.   \n[19] Weihua Hu, Takeru Miyato, Seiya Tokui, Eiichi Matsumoto, and Masashi Sugiyama. Learning discrete representations via information maximizing self-augmented training. In International Conference on Machine Learning, pages 1558–1567. PMLR, 2017.   \n[20] Xu Ji, João F Henriques, and Andrea Vedaldi. Invariant information clustering for unsupervised image classification and segmentation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 9865–9874, 2019.   \n[21] Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. Bag of tricks for efficient text classification. arXiv preprint arXiv:1607.01759, 2016.   \n[22] Lyes Khacef, Laurent Rodriguez, and Benoit Miramond. Improving self-organizing maps with unsupervised feature extraction. In International Conference on Neural Information Processing, pages 474–486. Springer, 2020.   \n[23] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.   \n[24] Ron Kohavi. Scaling up the accuracy of naive-bayes classifiers: A decision-tree hybrid. In Kdd, volume 96, pages 202–207, 1996.   \n[25] Adam R Kosiorek, Sara Sabour, Yee Whye Teh, and Geoffrey E Hinton. Stacked capsule autoencoders. arXiv preprint arXiv:1906.06818, 2019.   \n[26] Emmanuelle Le Chatelier, Trine Nielsen, Junjie Qin, Edi Prifti, Falk Hildebrand, Gwen Falony, Mathieu Almeida, Manimozhiyan Arumugam, Jean-Michel Batto, Sean Kennedy, et al. Richness of human gut microbiome correlates with metabolic markers. Nature, 500(7464):541–546, 2013.   \n[27] Yann LeCun. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998.   \n[28] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   \n[29] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017.   \n[30] DD Lucas, R Klein, J Tannahill, D Ivanova, S Brandon, D Domyancic, and Y Zhang. Failure analysis of parameter-induced simulation crashes in climate models. Geoscientific Model Development, 6(4):1157–1171, 2013.   \n[31] Renata CB Madeo, Clodoaldo AM Lima, and Sarajane M Peres. Gesture unit segmentation using support vector machines: segmenting gestures from rest positions. In Proceedings of the 28th Annual ACM Symposium on Applied Computing, pages 46–52, 2013.   \n[32] Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015.   \n[33] C Merz and PM Murphy. Pima indians diabetes dataset. UCI Repository, 1996.   \n[34] Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013.   \n[35] Michiel O Noordewier, Geoffrey G Towell, and Jude W Shavlik. Training knowledge-based neural networks to recognize genes in dna sequences. In Advances in neural information processing systems, pages 530–536, 1991.   \n[36] Min Oh and Liqing Zhang. Deepmicro: deep representation learning for disease prediction based on microbiome data. Scientific reports, 10(1):1–9, 2020. ",
+        "bbox": [
+            169,
+            46,
+            828,
+            914
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. ",
+        "bbox": [
+            169,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[38] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, highperformance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019. URL http://papers.neurips.cc/paper/ 9015-pytorch-an-imperative-style-high-performance-deep-learning-library pdf. ",
+        "bbox": [
+            176,
+            128,
+            826,
+            256
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[39] Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A Efros. Context encoders: Feature learning by inpainting. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2536–2544, 2016. ",
+        "bbox": [
+            174,
+            262,
+            826,
+            305
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[40] F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12:2825–2830, 2011. ",
+        "bbox": [
+            174,
+            314,
+            826,
+            369
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[41] Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pages 1532–1543, 2014. ",
+        "bbox": [
+            173,
+            378,
+            825,
+            422
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[42] Katarzyna Tomczak, Patrycja Czerwinska, and Maciej Wiznerowicz. The cancer genome atlas ´ (tcga): an immeasurable source of knowledge. Contemporary oncology, 19(1A):A68, 2015. ",
+        "bbox": [
+            171,
+            430,
+            823,
+            460
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[43] Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pages 1096–1103, 2008. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            511
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] I-Cheng Yeh, King-Jang Yang, and Tao-Ming Ting. Knowledge discovery on rfm model using bernoulli sequence. Expert Systems with Applications, 36(3):5866–5871, 2009. ",
+        "bbox": [
+            173,
+            520,
+            821,
+            549
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Pengcheng Yin, Graham Neubig, Wen-tau Yih, and Sebastian Riedel. Tabert: Pretraining for joint understanding of textual and tabular data. arXiv preprint arXiv:2005.08314, 2020. ",
+        "bbox": [
+            173,
+            556,
+            821,
+            587
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[46] Jinsung Yoon, Yao Zhang, James Jordon, and Mihaela van der Schaar. Vime: Extending the success of self-and semi-supervised learning to tabular domain. Advances in Neural Information Processing Systems, 33, 2020. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            637
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[47] Kun Zhang and Wei Fan. Forecasting skewed biased stochastic ozone days: analyses, solutions and beyond. Knowledge and Information Systems, 14(3):299–326, 2008. ",
+        "bbox": [
+            171,
+            646,
+            823,
+            675
+        ],
+        "page_idx": 12
+    }
+]