Add files using upload-large-folder tool

parse/train/BJlVNY8llV/BJlVNY8llV.md

@@ -0,0 +1,240 @@
+# Hybrid Rotation Invariant Networks for small sample size Deep Learning
+
+Alexander Katzmann1,3 Marc-Steffen Seibel $^ { 1 , 3 }$ Alexander M¨uhlberg1 Michael S¨uhling1
+
+alexander.katzmann@siemens.com marc-steffen.seibel@siemens.com alexander.muehlberg.ext@siemens.com michael.suehling@siemens.com $\bot$ Siemens Healthcare GmbH, Computed Tomography, 91301 Forchheim, Germany
+
+Dominik N¨orenberg $^ { 2 }$ Stefan Maurus2 Thomas Huber2
+
+dominik.noerenberg@med.uni-muenchen.de stefan.maurus@med.uni-muenchen.de thomas.huber@med.uni-muenchen.de
+
+$^ 2$ University Hospital Grohadern, Ludwig-Maximilians-University Munich, Department of Radiology, 81377 Munich, Germany
+
+Horst-Michael Groß3 horst-michael.gross@tu-ilmenau.de
+
+3 Ilmenau, University of Technology, Neuroinformatics and Cognitive Robotics Lab, 98693 Ilmenau, Germany
+
+Editors: Under Review for MIDL 2019
+
+# Abstract
+
+Medical image analysis using deep learning has become a topic of steadily growing interest. While model capacity is continiously increasing, limited data is still a major issue for deep learning in medical imaging. Virtually all past approaches work with a high amount of regularization as well as systematic data augmentation. In explorative tasks realistic data augmentation with affine transformations may not always be possible, which prevents models from effective generalization. Within this paper, we propose inherently rotationally invariant convolutional layers enabling the model to develop invariant features from limited training data. Our approach outperforms classical convolutions on the CIFAR-10, CIFAR100, and STL-10 datasets. We show the transferability to clinical scenarios by applying our approach on oncologic tasks for metastatic colorectal cancer treatment assessment and liver lesion segmentation in pancreatic cancer patients.
+
+Keywords: rotational invariance, regularization, colorectal cancer, pancreatic cancer
+
+# 1. Introduction
+
+With the rise of deep learning and its success in a wide range of applications, within the last years (semi-)automated medical image analysis using deep learning has become a topic of steadily growing interest (Litjens et al., 2017; Shen et al., 2017). A major reason for the success of deep learning is its high model complexity. However, with an increasing amount of trainable parameters, deep learning models become highly prone to overfitting.
+
+Most - or virtually all - medical applications of deep learning have to handle this problem, i.e. model regularization, in one or the other way. Standard techniques involve dropout (Srivastava et al., 2014), batch normalization (Ioffe and Szegedy, 2015), data augmentation and various forms of dimensionality or effective model complexity reduction, such as architectural bottlenecking through sparse representations or using denoising autoencoders (Vincent et al., 2008). Most of the mentioned techniques increase training set variance by (effectively) introducing semi-synthetically generated samples with no additional information, which eventually leads to a reduced model parameter variance, and thus, a reduced effective model complexity. This process can be seen as an a-priori knowledge-guided model regularization. However, the applied techniques differ: While dropout, batch-normalization, and architectural regularization tackle the problem from within the models training task, data augmentation is done from the outside. Non-augmenting model regularization induces invariance in a form which is part of the optimization process, thus making it possible for the model to learn more efficiently, while data augmentation assumes that semi-synthetically generated samples are semantically following some form of invariance visually perceived by human. This, however, might be a wrong assumption.
+
+Neural networks apply a vast amount of non-linear projections. Meanwhile handy tools for visualization are existent, and while they can be considered as being generally helpful in neural network development, a) their introduction and distribution took considerably longer than the network advancements’, and predominantly b) current visualization and inspection tools are still just starting to be at the edge of what can genuinely be considered as intuitive or obvious. As a consequence, there is still a lack of knowledge on the emergence of concrete interactions within the network.
+
+In turn, this means that while samples and their respective labels might for human observers seem invariant to affine transformations, e.g. shearing, rotation, or scaling, these transformations could in fact induce semantic label errors. This might be mostly assumed irrelevant in scenarios where humans significantly outperform machines, so their sense of invariance should be reasonable to a specific point. However, especially within the medical field one prospective speculation is the improvement of diagnostic performance beyond the level of human vision. Therefore, it might be advisable to optimize the network’s choice of transformations itself for maximizing the output accuracy.
+
+Another factor is that data augmentation can be seen as inefficient with respect to training time. When invariance is encoded directly into the model, data augmentation can be kept as low as possible. For example, there have been many efforts to introduce rotational invariance into neural networks (Marcos et al., 2016; Winkels and Cohen, 2018; Cheng et al., 2016) with some of them reaching back to non-convolutional approaches (Fasel and GaticaPerez, 2006). Also there have been approaches to systematically learn steerable filters for convolutional neural networks being inherently rotationally invariant (Weiler et al., 2017) based on the work from Jacob and Unser (2003, 2004).
+
+While differing in their choice of concrete methods, all these approaches have in common that they either create invariance a) by some form of rotated duplication of filters, or b) by constraining the network to only allow special filter configurations which are rotationally invariant themselves, e.g. via custom loss function or network constraints. While a) unintentionally reduces the effective network capacity, b) prevents the network from detecting actually non-invariant features.
+
+Within this paper, we demonstrate that simple transformational layers within the network for invariance might significantly improve the network’s performance. We show this by introducing an inherently rotation-invariant convolutional layer, while preserving the input’s local pose. We show that our network outperforms classic convolutional neural networks which share the same model complexity, i.e. number of optimizable parameters, with respect to the final test set performance. In our experiments, we show that this especially holds true when data is limited, as it is typical within clinical scenarios. As a proof of concept, we provide an exhaustive evaluation with a variety of metrics on the well-known benchmark datasets CIFAR-10, CIFAR-100 and STL-10. We furthermore demonstrate the transferability to the clinical context using two self-acquired medical datasets with the tasks of oncological treatment response classification in metastatic colorectal cancer patients (mCRC) and liver lesion segmentation in pancreatic cancer patients.
+
+# 2. Material and methods
+
+Invariance to visual distortions is often important in terms of generalization performance. Common distortion types within visual perception comprise translation, scale, rotation, illumination, and many more. Deep learning research often relies on the belief that data amount might compensate for variance with respect to these distortions at least to some point. Still, most top-performing neural networks apply data augmentation even when trained on large datasets. Data augmentation induces additional variance into the training data which in turn increases the probability of the classifier being invariant to changes represented within the augmented data with respect to an output label. The applied transformations generally rely on the a-priori knowledge of label invariance regarding specific types of transformations based on visual-perception. More formally, the transformations are input-variant but label-invariant, or in simple terms: transformations are generally reasonable with respect to the actual label, i.e. with the example of the well-known CIFAR 10 dataset within a reasonable range of transformations the perceived class of an image of the class ”bird” will not change into one of the class ”frog” or vice-versa.
+
+While this is immediately comprehensible for visually perceivable classes, the situation changes when deep learning is applied to explorative tasks where the ground-truth labels can not directly be perceived by human visual inspection. Assessment beyond human perception, however, is a major goal of many approaches within the clinical domain, e.g. by Radiomics (Gillies et al., 2015). Instead, transformations might induce unnatural variance in these cases and, thus, even worsen classification performance as labels might actually be rotationally and transformationally variant. With our approach, we show that it is feasible to make the search for invariant vs. variant features a matter of the network optimization process.
+
+# 2.1. The ORB approach
+
+Our approach is built upon the idea of ORB - Oriented FAST and Rotational Brief from Rublee et al. (2011). ORB was one of the most recognized approaches introducing rotational invariance into actually non-invariant visual patch recognition utilizing the intensity centroids described by Rosin (1999). For this purpose Rublee et al. determine image patch
+
+moments as:
+
+$$
+m _ { p q } = \sum _ { x , y } x ^ { p } y ^ { q } I ( x , y )
+$$
+
+based on normalized image intensities $I$ at positions $( x , y )$ . Image patch moments can be used for finding the image centroid as:
+
+$$
+C = \left( { \frac { m _ { 1 0 } } { m _ { 0 0 } } } , { \frac { m _ { 0 1 } } { m _ { 0 0 } } } \right)
+$$
+
+which allows rotating the patch according to the inverse of its orientation $\Theta$ :
+
+$$
+\Theta = \operatorname { a t a n 2 } ( m _ { 0 1 } , m _ { 1 0 } )
+$$
+
+After rotation, originally non-invariant transformations can be applied to the image while preserving rotational invariance.
+
+![](images/06a10ebdd4b68c20a5a4c9b3a445a334e7da2ce0208bc8bcfac99a2230074f9e.jpg)
+
+Figure 1: Left: image patches with various orientations. Within convolutional neural networks, these patches would have to be detected with respectively equally oriented filters. Right: Images after centroid rotation. With rotational invariance, all four patches would be mapped to the same orientation.
+
+# 2.2. Hybrid Rotation Invariant Networks
+
+As all aforementioned operations are differentiable, it is possible to transfer these operations to convolutional neural networks, which is reasonable as ORB was created to be applied on image patches itself. We limit this publication to only take into account the two-dimensional case, as the datasets we consider mostly consist of two-dimensional data only. However, the generalization to the n-dimensional case is straightforward. Analogously to classical 2D convolutional layers, our approach first extracts image patches parameterizable by kernel size, strides, extraction rate and border padding. In a second step, image centroids are derived according to Equation (2), and patches are rotated by their respective centroid rotation $\Theta$ from Equation (3). The data is rotated by multiplying the homogeneous extraction coordinates $( x , y , 1 )$ with the matrix $M$ :
+
+$$
+( x ^ { \prime } , y ^ { \prime } , z ) = ( x , y , 1 ) \cdot M \quad { \mathrm { w i t h } } \quad M = { \left[ \begin{array} { l l l } { \cos \Theta } & { - \sin \Theta } & { 0 } \\ { \sin \Theta } & { \cos \Theta } & { 0 } \\ { 0 } & { 0 } & { 1 } \end{array} \right] }
+$$
+
+When extraction coordinates $( x ^ { \prime } , y ^ { \prime } )$ lie between pixels, a bilinear interpolation is applied. While homogeneous and non-homogeneous coordinates result in the same image positions using the transformation matrix $M$ , i.e. $\begin{array} { r } { ( \frac { x ^ { \prime } } { z } , \frac { y ^ { \prime } } { z } ) = ( x ^ { \prime } , y ^ { \prime } ) } \end{array}$ , this matrix format shows that arbitrary transformations are easy to implement, making the approach feasible for invariance to other affine transformations, e.g. scale or sheering. Further approaches could include a learned transformation (see Section 4). Finally, the filter output is calculated analogously to classical convolutions with:
+
+$$
+y = W * p + b
+$$
+
+for each rotated $k \times k$ image patch $p$ , kernel size $k$ , weight matrix $W$ and filter bias $b$ .
+
+# 2.2.1. Rotation invariance vs. rotational equivariance
+
+Rotation invariance might be suboptimal, as the patches’ local rotation might constrain global relations. This is for example the case with face images, where the rotation of eyes or mouth generally have implications for valid rotations of nose and eyebrows. Thus each on its own is not invariant, but equivariant (invariant with knowledge on its pose), while the patches are covariant with respect to other patches (i.e. the rotation of patches is defining for the rotation of other patches). Rotational invariance would imply an arbitrary rotation for each of the subfeatures, meaning that the actual rotation of eyes or nose would have no implications for the rotation of the mouth features, etc.. To preserve rotational equivariance (resp. the knowledge of local rotation), for every rotationally invariant layer two additional filter maps are appended, containing the values $\sin \Theta ( x , y )$ and $\cos \Theta ( x , y )$ for the local rotation $\Theta$ (Equation (3)) at each filter position $( x , y )$ . Still, we can not preserve actual covariance between patches as it is possible with classical convolutions where different rotations are represented by separate filters. To address this issue, we propose a combination of rotationally invariant and classic convolutions called hybrid layers. We expect this mixture to yield significantly better performance: while rotationally invariant input image properties should fastly be covered by the rotationally invariant filters, the non-invariant properties can be treated using standard convolutions, without the need of learning rotated duplicates of the same filters. As we use hybrid layers, i.e. half of the filters are rotationally invariant, while the other half is not, rotation variance and invariance can be preserved at every abstraction stage within the network.
+
+# 2.3. Working Hypotheses and Evaluation
+
+Based on the assumptions mentioned above, we expect our approach to especially perform well when sample size is large enough for successful formation of simple filters but not for sufficiently developing rotated versions of these filters, or for discovering spatial covariances within deeper layers. We hypothesize that a) our approach should reach similar results as with classical convolutions with very small training sets, b) significantly outperform them with medium sample sizes, and c) eventually converge to a value comparable to noninvariant convolutions. Furthermore, we expect our approach to be especially beneficial for difficult learning tasks, as its rotational invariance allows it to develop comparably simple features more efficiently. To test these assumptions, we systematically modified training set sizes $S$ to be:
+
+$$
+S _ { X } = \{ 2 ^ { n } \mid n _ { 0 } \leq n \leq \log _ { 2 } ( | X | ) \} \cup \{ | X | \}
+$$
+
+for dataset $X$ . We chose a start value of $n _ { 0 } = 7$ resulting in the smallest set having a cardinality of $\operatorname* { m i n } ( S _ { X } ) = 2 ^ { 7 } = 1 2 8$ samples since the set with the highest amount of classes
+
+has exactly 100 classes, meaning that ≈ 78% of classes are represented by only one sample within the training set.
+
+# 2.3.1. Training details and sets
+
+For training, we employed Keras (Chollet et al., 2015) using the Tensorflow backend (Abadi et al., 2015). As a proof of concept, we tested our approach on the well-known Cifar-10 and Cifar-100 datasets from Krizhevsky and Hinton (2009), as well as the STL-10 dataset from Coates et al. (2011). To show the impact for classification in typical clinical datasets, we trained our model with an extended version of the metastatic colorectal cancer dataset (mCRC) from Katzmann et al. (2018). To analyze whether our approach is transferable to other tasks, we also employed the aproach for liver lesion segmentation in pancreas carcinoma patients, using a newly acquired dataset. For each set size, we trained both models (i.e. rotationally invariant and classic) for three iterations with varying random seeds in each iteration. Within each iteration, seeds were fixed for both models for ensuring equal initialization and training sample order. For Cifar-10, Cifar-100 and STL-10, all results were evaluated on the respective full test set. For tumor growth prediction and liver lesion segmentation, we chose a 4-fold grouped stratified cross-validation as a tradeoff between training time and explanatory power, with $1 / 4$ of the training set to be used for validation. In every case we optimized using categorical cross entropy loss. The best model was chosen as the one maximizing the lower bound of the $9 5 \%$ bootstrapping confidence interval of ROC area-under-curve on the validation dataset, as this also takes into account metric variance and empirically provided clear advantages over using the validation loss with respect to the generalizability of the results. All results were obtained using bootstrapping until metrics convergence (Efron, 1982).
+
+# 3. Results
+
+# 3.1. Cifar-10, Cifar-100 and STL-10
+
+The Cifar-10 and Cifar-100 datasets consist of 50,000 images each with a size of 32x32 from 10, respectively 100, different classes of everyday objects, e.g. planes, cars, or dogs. The test sets comprise 10,000 samples each. STL-10 is built up similarly to Cifar-10, but contains 5,000 images sized 96x96 pixels for training and 8,000 images for testing. As described above, we trained our model as well as an equivalently built one with classical convolutions while systematically varying the amount of training samples used as described in Section 2.3. The results are shown in Figure 2.
+
+# 3.2. mCRC Dataset
+
+Using an extended version of the dataset from Katzmann et al. (2018), we trained our model to predict disease progressions of patients with metastatic colorectal cancer based on baseline-followup-pairs of liver lesion slices from computed tomography images, that is, predicting growth at followup two relative to lesion size at followup one. This assesment was already shown to be partially predictive for biological information while providing benefits over the clinical standard Response Evaluation Criteria in Solid Tumors (RECIST v1.1) lesion assessment from Eisenhauer et al. (2009). Our target variable definition is defined
+
+![](images/92d428607547d5b16289461cd55777598e099c6c4324c111b5982f1a5f54b0e4.jpg)  
+Figure 2: Results of rotationally invariant vs. variant convolutional neural networks on the CIFAR-10, CIFAR-100 and STL-10 datasets. Results are shown with respect to accuracy, matthews correlation coefficient, and area under the receiver operating curve (ROC-AUC) using multiclass-macro-averaging. The metric’s $9 9 \%$ confidence intervals are given as shadowed areas. Expectedly, rotationally invariant layers outperform classical convolutions with medium sample sizes but become less significant with larger sets or lower-difficulty problems. With the more difficult problems from CIFAR-100 and STL-10, the differences between rotationally invariant and non-invariant layers become more significant.
+
+as the RECIST lesion progressive disease status, thus a lesion growth of $\geq 2 0 \%$ is assumed progression. The dataset contains 592 baseline followup pairs of 320 lesions in 138 scans from 75 patients. The test results are shown in Table 1.   
+
+<table><tr><td></td><td>Our approach</td><td>CI 95</td><td>Classic</td><td>CI 95</td></tr><tr><td>Accuracy</td><td>.636</td><td>[.598, .674]</td><td>.724</td><td>[.689, .760]</td></tr><tr><td>F1</td><td>.335</td><td>[.273, .402]</td><td>.313</td><td>[.232, .390]</td></tr><tr><td>Sensitivity</td><td>.671</td><td>[.569, .774]</td><td>.463</td><td>[.360, .577]</td></tr><tr><td>Specificity</td><td>.631</td><td>[.587, .671]</td><td>.765</td><td>[.727, .801]</td></tr><tr><td>Matthews</td><td>.211</td><td>[.132, .291]</td><td>.177</td><td>[.089, .264]</td></tr><tr><td>AUC</td><td>.717</td><td>[.659, .776]</td><td>.639</td><td>[.561, .713]</td></tr></table>
+
+Table 1: Results on the mCRC dataset for tumor growth prediction. Label distribution was 81 positive vs. 511 negative samples. While classifiers focused on different classes, the balanced Matthews correlation coefficient indicates superiority of rotationinvariant convolutions with significantly higher ROC AUC with $p < . 0 5$ (two-tailed $\boldsymbol { \mathrm { z } }$ -test).
+
+# 3.3. Liver lesion segmentation in pancreatic cancer patients
+
+We applied our approach for liver lesion segmentation using a modified 2D version of the UNet architecture from Ronneberger et al. (2015). The model is trained on a newly acquired dataset of pancreatic cancer patients. Segmenting liver lesions in pancreatic cancer patients can be seen as particulary difficult as one patient may suffer from more than a houndred liver lesions. The dataset consisted of 3481 samples from 135 volumes of 87 pancreas carcinoma patients with fully-volumetrically segmented livers and liver lesions. Metrics were tested with and without outlier detection. When applying outlier detection, surface distances $\geq 5 c m$ were expected to be misclassifications. The obtained results can be found in Table 2. An examplary segmentation result is shown in Figure 3.
+
+<table><tr><td></td><td colspan="3">Our approach</td><td colspan="3">Classic</td></tr><tr><td>Metric</td><td>W</td><td></td><td>w/0</td><td>W</td><td></td><td>w/0</td></tr><tr><td>Mean SD</td><td>8.36 [8.16, 8.60]</td><td>26.6</td><td>[25.0, 28.6]</td><td>8.42 [8.16, 8.68]</td><td></td><td>27.6 [25.8, 29.6]</td></tr><tr><td>Median SD</td><td>2.98 [2.82, 4.00]</td><td>4.70 [.536, .566]</td><td>[4.48, 5.66]</td><td>2.82 [2.82, 4.00]</td><td></td><td>4.76 [4.48, 5.66]</td></tr><tr><td>Dice</td><td colspan="3">.552</td><td colspan="3">.542[.526, .559]</td></tr></table>
+
+Table 2: Results for the pancreatic cancer dataset with hybrid (left) vs. classical convolutions (right). Surface metrics (in mm) were calculated with (w) and without (w/o) outlier removal. When applying outlier removal, both models performed similarly, while without outlier removal our model outperformed classical convolutions with respect to mean and median surface distance (SD).
+
+![](images/d7b2d0af1a9b38c41e2e3eb81d64fd6c481958a72355e7fad0f650903a837c7c.jpg)  
+Figure 3: Examplary segmentation result using rotationally invariant filters. Left: original image; middle: segmentation result; right: overlay. True positives, false positives and false negatives are respectively marked as green, blue, and red.
+
+# 4. Discussion
+
+As shown in Section 3, our approach mostly outperformed classical convolutions for all tested datasets. As expected, this especially holds true when working with medium training set sizes and/or difficult problems, as shown on the example of Cifar-100 and STL-10 with the resulting differences being highly significant for all tested metrics ( $p \leq . 0 1 )$ ). However, more simple problems like Cifar-10 do not neccessarely benefit from the approach when large training sets are available. On medical data, our approach performed superior to classical convolutions, both, for classification ( $p _ { A U C } \leq . 0 5$ ) as well as for segmentation tasks. Though there generally is some understanding on how rotational invariance can be realized by rotationally non-invariant networks (Sauder, 2006), the introduction of inherently rotationally invariant networks might provide major benefits for various training problems especially within the medical domain, where training data is rare and models can easily suffer from overfitting. While deep neural networks are thought to develop even rotationally invariant features on their own, their capabilities are limited due to training data amount, training time and model complexity. Especially these issues major arguments for directly encoding invariance into the model itself.
+
+In future work, the proposed approach should be expanded to explicitly learn invariance when needed, as the choice of using invariant vs. non-invariant features within this publication was realized by statically mixing both layer types only. Extending the given approach, the general form of the transformational matrices like shown in Section 2.2 could be used for making models inherently invariant to other affine transformations, e.g. scale or sheering.
+
+# Acknowledgments
+
+This work has received funding from the German Federal Ministry of Education and Research as part of the PANTHER project under grant agreement no. 13GW0163A. The concepts and information presented in this article are based on research and are not commercially available.
+
+# 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, Dandelion Man´e, 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 Vi´egas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow.org/. Software available from tensorflow.org.
+
+Gong Cheng, Junwei Han, Peicheng Zhou, and Dong Xu. Learning rotation-invariant and fisher discriminative convolutional neural networks for object detection. IEEE Transactions on Image Processing, 28(1):265–278, 2016.
+
+Fran¸cois Chollet et al. Keras. https://keras.io, 2015.
+
+Adam Coates, Andrew Ng, and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pages 215–223, 2011.
+
+Bradley Efron. The jackknife, the bootstrap, and other resampling plans, volume 38. Siam, 1982.
+
+Elizabeth A Eisenhauer, Patrick Therasse, Jan Bogaerts, Lawrence H Schwartz, D Sargent, Robert Ford, Janet Dancey, S Arbuck, Steve Gwyther, Margaret Mooney, et al. New response evaluation criteria in solid tumours: revised recist guideline (version 1.1). European journal of cancer, 45(2):228–247, 2009.
+
+Beat Fasel and Daniel Gatica-Perez. Rotation-invariant neoperceptron. In Pattern Recognition, 2006. ICPR 2006. 18th International Conference on, volume 3, pages 336–339. IEEE, 2006.
+
+Robert J Gillies, Paul E Kinahan, and Hedvig Hricak. Radiomics: images are more than pictures, they are data. Radiology, 278(2):563–577, 2015.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Mathews Jacob and Michael Unser. Optimal steerable filters for feature detection. In ICIP (3), pages 433–436, 2003.
+
+Mathews Jacob and Michael Unser. Design of steerable filters for feature detection using canny-like criteria. IEEE transactions on pattern analysis and machine intelligence, 26 (8):1007–1019, 2004.
+
+Alexander Katzmann, Alexander Muehlberg, Michael Suehling, Dominik Noerenberg, Julian Walter Holch, Volker Heinemann, and Horst-Michael Gross. Predicting lesion growth and patient survival in colorectal cancer patients using deep neural networks. 2018.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Geert Litjens, Thijs Kooi, Babak Ehteshami Bejnordi, Arnaud Arindra Adiyoso Setio, Francesco Ciompi, Mohsen Ghafoorian, Jeroen Awm Van Der Laak, Bram Van Ginneken, and Clara I S´anchez. A survey on deep learning in medical image analysis. Medical image analysis, 42:60–88, 2017.
+
+Diego Marcos, Michele Volpi, and Devis Tuia. Learning rotation invariant convolutional filters for texture classification. In Pattern Recognition (ICPR), 2016 23rd International Conference on, pages 2012–2017. IEEE, 2016.
+
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computer-assisted intervention, pages 234–241. Springer, 2015.
+
+Paul L Rosin. Measuring corner properties. Computer Vision and Image Understanding, 73(2):291–307, 1999.
+
+Ethan Rublee, Vincent Rabaud, Kurt Konolige, and Gary Bradski. Orb: An efficient alternative to sift or surf. In Computer Vision (ICCV), 2011 IEEE international conference on, pages 2564–2571. IEEE, 2011.
+
+Nathaniel Sauder. Encoded invariance in convolutional neural networks. University of Chicago, pages 2–6, 2006.
+
+Dinggang Shen, Guorong Wu, and Heung-Il Suk. Deep learning in medical image analysis. Annual review of biomedical engineering, 19:221–248, 2017.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+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. ACM, 2008.
+
+Maurice Weiler, Fred A Hamprecht, and Martin Storath. Learning steerable filters for rotation equivariant cnns. arXiv preprint arXiv:1711.07289, 2017.
+
+Marysia Winkels and Taco S Cohen. 3d g-cnns for pulmonary nodule detection. arXiv preprint arXiv:1804.04656, 2018.
+
+# Appendix A. Detailed dataset description
+
+# A.1. Tumor growth dataset
+
+The classification goal was defined analogously to the RECIST guideline (Eisenhauer et al., 2009) as a lesion having $\geq 2 0 \%$ growth at the next followup after the input timepoints. Each lesion was masked using fully-volumetric segmentations created by radiologists. All lesions were isotropically rescaled with a target voxel size of $1 m m \times 1 m m \times 1 m m$ using bicubic interpolation. For all lesions a lesion-centered window of $6 4 m m \times 6 4 m m \times 6 4 m m$ due to lesion diameter quantiles of $\left( \mathcal { Q } _ { P r ( \emptyset ) \leq . 1 } , \mathcal { Q } _ { P r ( \emptyset ) \geq . 9 } \right) = ( 1 0 . 5 \mathrm { m m } , 5 5 . 2 \mathrm { m m } )$ ). For each lesion, only the middle slice was classified. In total the dataset contained 592 valid samples, with 81 being positive (growth) vs. 511 being negative (non-growth). All samples underwent histogram equalization. Examplary data is shown in Figure 4.
+
+![](images/fe11a9efcd4e2dd607fc394798f6e06eaf48d3425bdd55efa6aa841fc08755b2.jpg)  
+Figure 4: Example images of the CRC dataset after histogram equalization.
+
+# A.2. Pancreas dataset
+
+The complete dataset consisted of 135 volumes from 87 patients. Classification was done in 2D using single slices of masked livers. Isotropic resampling to $1 m m \times 1 m m \times 1 m m$ voxel size was applied using bicubic interpolation. All slices had a size of $5 1 2 \times 5 1 2$ voxels. Although only venous phases were used, data heterogeneity was high due to various treatments, kernels, scanners and comorbidities, such as fatty liver and cholestasis. All samples were resized to $2 5 6 \times 2 5 6$ pixels. All samples having at least one voxel of lesion tissue were involved in the dataset, resulting in a total quantity of 3536 valid liver slices. Again, all samples underwent histogram equalization. An example image is shown in Figure 3.
+
+# Appendix B. Architectures
+
+Following we list the architectures used to calculate the results from Section 3. The networks are given as convolutional networks. The respective hybrid networks are created by simply replacing the convolutional layers with hybrid layers as described in Section 2.2.
+
+# B.1. Cifar-10, Cifar-100, STL-10
+
+The architectures used for the classification results from Section 3.1 on CIFAR-10, CIFAR100 and STL-10 are shown in Table 3.   
+
+<table><tr><td>Description</td><td>CIFAR-10/-100</td><td>STL-10</td><td>filter size</td></tr><tr><td>input</td><td>(32,32,1)</td><td>(96,96,1)</td><td>1</td></tr><tr><td>conv + BN + leaky ReLU</td><td>(32,32,32)</td><td>(96,96,32)</td><td>(3,3)</td></tr><tr><td>max pooling conv + BN + leaky ReLU</td><td>(16,16,32)</td><td>(48,48,32)</td><td></td></tr><tr><td></td><td>(16,16,48)</td><td>(48,48,48)</td><td>(3,3)</td></tr><tr><td>max pooling</td><td>(8,8,48)</td><td>(24,24,48)</td><td>二</td></tr><tr><td>conv+1 BN +leaky ReLU</td><td>(8,8,64)</td><td>(24,24,64)</td><td>(3,3)</td></tr><tr><td>conv + BN + leaky ReLU fatten</td><td>(8,8,96)</td><td>(24,24,96)</td><td>(3,3)</td></tr><tr><td>dense + BN + leaky ReLU</td><td>(6144,)</td><td>(55296,)</td><td>=</td></tr><tr><td></td><td>(512,）</td><td>(512,)</td><td>一</td></tr><tr><td>softmax</td><td>(10,)/(100,)</td><td>(10,）</td><td></td></tr></table>
+
+Table 3: For CIFAR-10, CIFAR-100 and STL-10, a very simple network architecture was chosen. It is based on a sequence of blocks of convolutional layers (conv), batch normalization (BN), leaky ReLU activation and max pooling, followed by one fully-connected as well as one softmax-output layer and is inspired by the keras example network for the CIFAR-10 dataset.
+
+# B.2. Tumor growth
+
+Tumor growth (Section 3.2) was classified using a two-laned convolutional neural network built analogously to the model from Katzmann et al. (2018) with baseline and followup being processed in one lane each. The network weights were initialized using autoencoder pretraining. The complete architecture is shown in Table 4.
+
+# B.3. Liver lesion segmentation
+
+The architecture for liver lesion segmentation (Section 3.3) is based on the U-Net approach from Ronneberger et al. (2015) with minor modifications. The full architecture is shown in Table 5.
+
+<table><tr><td rowspan=1 colspan=2>Description</td><td rowspan=1 colspan=1>shape</td><td rowspan=1 colspan=1>filter size</td></tr><tr><td rowspan=1 colspan=2>input</td><td rowspan=1 colspan=1>(2,64,64,1)</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=2 colspan=1>2×</td><td rowspan=2 colspan=1>conv + BN + leaky ReLUmax poolingconv + BN + leaky ReLUmax poolingconv + BN + leaky ReLUmax poolingconv + BN + leaky ReLUmax poolingconv + BN + leaky ReLUfattendense+1BN +leaky ReLU</td><td rowspan=1 colspan=1>(64,64,8)</td><td rowspan=2 colspan=1>(5,5)1(5,5)1(5,5)=(5,5)1(5,5)1</td></tr><tr><td rowspan=1 colspan=1>(32,32,8)(32,32,16)(16,16,16)(16,16,24)(8,8,24)(8,8,32)(4,4,32)(4,4,40)(640,）(8,）</td></tr><tr><td rowspan=1 colspan=2>dense+BN + leaky ReLUdense+BN + leaky ReLU</td><td rowspan=1 colspan=1>(4,)(4,)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=2>softmax</td><td rowspan=1 colspan=1>(2,)</td><td rowspan=1 colspan=1></td></tr></table>
+
+Table 4: Classifier architecture for tumor growth classification consisting of blocks of convolutional layers (conv), batch normalization (BN), leaky ReLU activation and max pooling layers, followed by two fully-connected as well as a softmax-output layer.
+
+<table><tr><td rowspan=1 colspan=1>Description</td><td rowspan=1 colspan=1>shape</td><td rowspan=1 colspan=1>filter size</td></tr><tr><td rowspan=1 colspan=1>input</td><td rowspan=1 colspan=1>(256,256,1)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>1  conv + BN + leaky ReLU max pooling</td><td rowspan=1 colspan=1>(256,256,4)(128,128,4)</td><td rowspan=1 colspan=1>(3,3)</td></tr><tr><td rowspan=1 colspan=1>2  conv +1BN+leakyReLUmaxpooling</td><td rowspan=1 colspan=1>(128,128,16)(64,64,16)</td><td rowspan=1 colspan=1>(3,3)</td></tr><tr><td rowspan=1 colspan=1>3  conv + BN + leaky ReLUmax pooling</td><td rowspan=1 colspan=1>(64,64,32)(32,32,32)</td><td rowspan=1 colspan=1>(3.3)</td></tr><tr><td rowspan=1 colspan=1>conv + BN +leakyReLU4            upsampling</td><td rowspan=1 colspan=1>(32,32,64)(64,64,64)</td><td rowspan=1 colspan=1>(3.3)</td></tr><tr><td rowspan=1 colspan=1>concat (3,4)conv + BN + leaky ReLU5            upsampling</td><td rowspan=1 colspan=1>(64,64,96)(64,64,32)(128,128,32)</td><td rowspan=1 colspan=1>(3,3)</td></tr><tr><td rowspan=1 colspan=1>concat (2,5)conv+1BN +leaky ReLU6            upsampling</td><td rowspan=1 colspan=1>(128,128,48)(128,128,16)(256,256,16)</td><td rowspan=1 colspan=1>(3.3)</td></tr><tr><td rowspan=1 colspan=1>concat(1,6)conv + BN + sig.</td><td rowspan=1 colspan=1>(256,256,20)(256,256,1)</td><td rowspan=1 colspan=1>(3.3)</td></tr></table>
+
+Table 5: Segmentation network architecture used for liver lesion segmentation based on U-Net (Ronneberger et al., 2015). As in U-Net, the network convolves and downsamples the image with blocks of convolutional layers (conv), batch normalization (BN), and leaky ReLU activation. Afterwards the image is upsampled again and convolved with the information of the horizontal shortcuts (concat). The final output is generated using a sigmoid function (sig.).

parse/train/SJDaqqveg/SJDaqqveg.md

@@ -0,0 +1,369 @@
+# AN ACTOR-CRITIC ALGORITHM FOR SEQUENCE PREDICTION
+
+Dzmitry Bahdanau Philemon Brakel Kelvin Xu Anirudh Goyal Universite de Montr ´ eal ´
+
+Ryan Lowe Joelle Pineau∗ McGill University
+
+Aaron Courville† Universite de Montr´ eal´
+
+Yoshua Bengio∗ Universite de Montr ´ eal ´
+
+# ABSTRACT
+
+We present an approach to training neural networks to generate sequences using actor-critic methods from reinforcement learning (RL). Current log-likelihood training methods are limited by the discrepancy between their training and testing modes, as models must generate tokens conditioned on their previous guesses rather than the ground-truth tokens. We address this problem by introducing a critic network that is trained to predict the value of an output token, given the policy of an actor network. This results in a training procedure that is much closer to the test phase, and allows us to directly optimize for a task-specific score such as BLEU. Crucially, since we leverage these techniques in the supervised learning setting rather than the traditional RL setting, we condition the critic network on the ground-truth output. We show that our method leads to improved performance on both a synthetic task, and for German-English machine translation. Our analysis paves the way for such methods to be applied in natural language generation tasks, such as machine translation, caption generation, and dialogue modelling.
+
+# 1 INTRODUCTION
+
+In many important applications of machine learning, the task is to develop a system that produces a sequence of discrete tokens given an input. Recent work has shown that recurrent neural networks (RNNs) can deliver excellent performance in many such tasks when trained to predict the next output token given the input and previous tokens. This approach has been applied successfully in machine translation (Sutskever et al., 2014; Bahdanau et al., 2015), caption generation (Kiros et al., 2014; Donahue et al., 2015; Vinyals et al., 2015; Xu et al., 2015; Karpathy & Fei-Fei, 2015), and speech recognition (Chorowski et al., 2015; Chan et al., 2015).
+
+The standard way to train RNNs to generate sequences is to maximize the log-likelihood of the “correct” token given a history of the previous “correct” ones, an approach often called teacher forcing. At evaluation time, the output sequence is often produced by an approximate search for the most likely candidate according to the learned distribution. During this search, the model is conditioned on its own guesses, which may be incorrect and thus lead to a compounding of errors (Bengio et al., 2015). This can become especially problematic for longer sequences. Due to this discrepancy between training and testing conditions, it has been shown that maximum likelihood training can be suboptimal (Bengio et al., 2015; Ranzato et al., 2015). In these works, the authors argue that the network should be trained to continue generating correctly given the outputs already produced by the model, rather than the ground-truth reference outputs from the data. This gives rise to the challenging problem of determining the target for the next network output. Bengio et al. (2015) use the token $k$ from the ground-truth answer as the target for the network at step $k$ , whereas Ranzato et al. (2015) rely on the REINFORCE algorithm (Williams, 1992) to decide whether or not the tokens from a sampled prediction lead to a high task-specific score, such as BLEU (Papineni et al., 2002) or ROUGE (Lin & Hovy, 2003).
+
+In this work, we propose and study an alternative procedure for training sequence prediction networks that aims to directly improve their test time metrics (which are typically not the log-likelihood). In particular, we train an additional network called the critic to output the value of each token, which we define as the expected task-specific score that the network will receive if it outputs the token and continues to sample outputs according to its probability distribution. Furthermore, we show how the predicted values can be used to train the main sequence prediction network, which we refer to as the actor. The theoretical foundation of our method is that, under the assumption that the critic computes exact values, the expression that we use to train the actor is an unbiased estimate of the gradient of the expected task-specific score.
+
+Our approach draws inspiration and borrows the terminology from the field of reinforcement learning (RL) (Sutton & Barto, 1998), in particular from the actor-critic approach (Sutton, 1984; Sutton et al., 1999; Barto et al., 1983). RL studies the problem of acting efficiently based only on weak supervision in the form of a reward given for some of the agent’s actions. In our case, the reward is analogous to the task-specific score associated with a prediction. However, the tasks we consider are those of supervised learning, and we make use of this crucial difference by allowing the critic to use the ground-truth answer as an input. In other words, the critic has access to a sequence of expert actions that are known to lead to high (or even optimal) returns. To train the critic, we adapt the temporal difference methods from the RL literature (Sutton, 1988) to our setup. While RL methods with non-linear function approximators are not new (Tesauro, 1994; Miller et al., 1995), they have recently surged in popularity, giving rise to the field of ‘deep RL’ (Mnih et al., 2015). We show that some of the techniques recently developed in deep RL, such as having a target network, may also be beneficial for sequence prediction.
+
+The contributions of the paper can be summarized as follows: 1) we describe how RL methodology like the actor-critic approach can be applied to supervised learning problems with structured outputs; and 2) we investigate the performance and behavior of the new method on both a synthetic task and a real-world task of machine translation, demonstrating the improvements over maximum-likelihood and REINFORCE brought by the actor-critic training.
+
+# 2 BACKGROUND
+
+We consider the problem of learning to produce an output sequence $Y = ( y _ { 1 } , \dots , y _ { T } )$ , $y _ { t } \in { \mathcal { A } }$ given an input $X$ , where $\mathcal { A }$ is the alphabet of output tokens. We will often use notation $Y _ { f \ldots l }$ to refer to subsequences of the form $( y _ { f } , \ldots , y _ { l } )$ . Two sets of input-output pairs $( X , Y )$ are assumed to be available for both training and testing. The trained predictor $h$ is evaluated by computing the average task-specific score $R ( { \hat { Y } } , Y )$ on the test set, where ${ \hat { Y } } = h ( X )$ is the prediction. To simplify the formulas we always use $T$ to denote the length of an output sequence, ignoring the fact that the output sequences may have different length.
+
+Recurrent neural networks A recurrent neural network (RNN) produces a sequence of state vectors $( s _ { 1 } , \ldots , s _ { T } )$ given a sequence of input vectors $( e _ { 1 } , \dots , e _ { T } )$ by starting from an initial $s _ { 0 }$ state and applying $T$ times the transition function $f$ $\vdots s _ { t } = f ( s _ { t - 1 } , e _ { t } )$ . Popular choices for the mapping $f$ are the Long Short-Term Memory (Hochreiter & Schmidhuber, 1997) and the Gated Recurrent Units (Cho et al., 2014), the latter of which we use for our models.
+
+To build a probabilistic model for sequence generation with an RNN, one adds a stochastic output layer $g$ (typically a softmax for discrete outputs) that generates outputs $y _ { t } \in \mathcal A$ and can feed these outputs back by replacing them with their embedding $e ( y _ { t } )$ :
+
+$$
+\begin{array} { r } { y _ { t } \sim g ( s _ { t - 1 } ) } \\ { s _ { t } = f ( s _ { t - 1 } , e ( y _ { t } ) ) . } \end{array}
+$$
+
+Thus, the RNN defines a probability distribution $p ( y _ { t } | y _ { 1 } , \dots , y _ { t - 1 } )$ of the next output token $y _ { t }$ given the previous tokens $\left( y _ { 1 } , \ldots , y _ { t - 1 } \right)$ . Upon adding a special end-of-sequence token $\varnothing$ to the alphabet $\mathcal { A }$ , the RNN can define the distribution $p ( Y )$ over all possible sequences as $p ( Y ) =$ $\bar { p ( y _ { 1 } ) } p ( y _ { 2 } | y _ { 1 } ) \ldots p ( y _ { T } | y _ { 1 } , \ldots , y _ { T - 1 } ) p ( \emptyset | y _ { 1 } , \ldots , y _ { T } )$ .
+
+RNNs for sequence prediction To use RNNs for sequence prediction, they must be augmented to generate $Y$ conditioned on an input $X$ . The simplest way to do this is to start with an initial state $s _ { 0 } = s _ { 0 } ( X )$ (Sutskever et al., 2014; Cho et al., 2014). Alternatively, one can encode $X$ as a variable-length sequence of vectors $( h _ { 1 } , \ldots , h _ { L } )$ and condition the RNN on this sequence using an attention mechanism. In our models, the sequence of vectors is produced by either a bidirectional RNN (Schuster & Paliwal, 1997) or a convolutional encoder (Rush et al., 2015).
+
+We use a soft attention mechanism (Bahdanau et al., 2015) that computes a weighted sum of a sequence of vectors. The attention weights determine the relative importance of each vector. More formally, we consider the following equations for RNNs with attention:
+
+$$
+\begin{array} { r } { y _ { t } \sim g ( s _ { t - 1 } , c _ { t - 1 } ) } \\ { s _ { t } = f ( s _ { t - 1 } , c _ { t - 1 } , e ( y _ { t } ) ) } \\ { \alpha _ { t } = \beta ( s _ { t } , ( h _ { 1 } , \dots , h _ { L } ) ) } \\ { c _ { t } = \displaystyle \sum _ { j = 1 } ^ { L } \alpha _ { t , j } h _ { j } } \end{array}
+$$
+
+where $\beta$ is the attention mechanism that produces the attention weights $\alpha _ { t }$ and $c _ { t }$ is the context vector, or ‘glimpse’, for time step $t$ . The attention weights are computed by an MLP that takes as input the current RNN state and each individual vector to focus on. The weights are typically (as in our work) constrained to be positive and sum to 1 by using the softmax function.
+
+A conditioned RNN can be trained for sequence prediction by gradient ascent on the log-likelihood $\log p ( { Y } | { X } )$ for the input-output pairs $( X , Y )$ from the training set. To produce a prediction $\hat { Y }$ for a test input sequence $X$ , an approximate beam search for the maximum of $p ( \cdot | X )$ is usually conducted. During this search the probabilities $p ( \cdot | \hat { y } _ { 1 } , \dots , \hat { y } _ { t - 1 } )$ are considered, where the previous tokens $\hat { y } _ { 1 } , \dotsc , \hat { y } _ { t - 1 }$ comprise a candidate beginning of the prediction $\hat { Y }$ .
+
+Value functions We view the conditioned RNN as a stochastic policy that generates actions and receives the task score (e.g., BLEU score) as the return. We furthermore consider the case when the return $R$ is partially received at the intermediate steps in the form of rewards $r _ { t }$ : $R ( { \hat { Y } } , Y ) =$ $\begin{array} { r } { \sum _ { t = 1 } ^ { T } r _ { t } ( \hat { y } _ { t } ; \hat { Y } _ { 1 \dots t - 1 } , Y ) } \end{array}$ . This is more general than the case of receiving the full return at the end of the sequence, as we can simply define all rewards other than $r _ { T }$ to be zero. Receiving intermediate rewards may ease the learning for the critic, and we use reward shaping as explained in Section 3. Given the policy, possible actions and reward function, the value represents the expected future return as a function of the current state of the system, which in our case is uniquely defined by the sequence of actions taken so far, $\hat { Y } _ { 1 \dots t - 1 }$ .
+
+We define the value of an unfinished prediction $\hat { Y } _ { 1 \dots t }$ as follows:
+
+$$
+V ( \hat { Y } _ { 1 . . . t } ; X , Y ) = \underset { \hat { Y } _ { t + 1 . . . T } \sim p ( \cdot | \hat { Y } _ { 1 . . . t } , X ) } { \mathbb { E } } \sum _ { \tau = t + 1 } ^ { T } r _ { \tau } ( \hat { y } _ { \tau } ; \hat { Y } _ { 1 . . . \tau - 1 } , Y ) .
+$$
+
+We define the value of a candidate next token $a$ for an unfinished prediction $\hat { Y } _ { 1 \dots t - 1 }$ as the expected future return after generating token $a$ :
+
+$$
+\langle \hat { Y } _ { 1 \dots t - 1 } , X , Y \rangle = \underset { \hat { Y } _ { t + 1 \dots T } \sim p ( \cdot \vert \hat { Y } _ { 1 \dots t - 1 } , a , X ) } { \mathbb { E } } \left( r _ { t } ( a ; \hat { Y } _ { 1 \dots t - 1 } , Y ) + \underset { \tau = t + 1 } { \overset { T } { \sum } } r _ { \tau } ( \hat { y } _ { \tau } ; \hat { Y } _ { 1 \dots t - 1 } a \hat { Y } _ { t + 1 \dots \tau } , Y ) \right)
+$$
+
+We will refer to the candidate next tokens as actions. For notational simplicity, we henceforth drop $X$ and $Y$ from the signature of $p$ , $V$ , $Q$ , $R$ and $r _ { t }$ , assuming it is clear from the context which of $X$ and $Y$ is meant. We will also use $V$ without arguments for the expected reward of a random prediction.
+
+# Algorithm 1 Actor-Critic Training for Sequence Prediction
+
+Require: A critic $\hat { Q } ( a ; \hat { Y } _ { 1 \dots t } , Y )$ and an actor $\boldsymbol { p } ( \boldsymbol { a } | \hat { Y } _ { 1 \ldots t } , \boldsymbol { X } )$ with weights $\phi$ and $\theta$ respectively.
+
+1: Initialize delayed actor $p$ and target critic $\hat { Q } ^ { \prime }$ with same weights: $\theta ^ { \prime } = \theta$ , $\phi ^ { \prime } = \phi$ .   
+2: while Not Converged do   
+3: Receive a random example $( X , Y )$ .   
+4: Generate a sequence of actions $\hat { Y }$ from $p ^ { ' }$ .   
+5: Compute targets for the critic
+
+$$
+q _ { t } = r _ { t } ( \hat { y } _ { t } ; \hat { Y } _ { 1 \dots t - 1 } , Y ) + \sum _ { a \in \cal A } p ^ { ' } ( a | \hat { Y } _ { 1 \dots t } , X ) \hat { Q } ^ { \prime } ( a ; \hat { Y } _ { 1 \dots t } , Y )
+$$
+
+6: Update the critic weights $\phi$ using the gradient
+
+$$
+\begin{array} { r } { \displaystyle \frac { d } { d \phi } \left( \displaystyle \sum _ { t = 1 } ^ { T } \left( \hat { Q } ( \hat { y } _ { t } ; \hat { Y } _ { 1 \dots t - 1 } , Y ) - q _ { t } \right) ^ { 2 } + \lambda _ { C } C _ { t } \right) } \\ { \mathrm { ~ w h e r e ~ } C _ { t } = \displaystyle \sum _ { a } \left( \hat { Q } ( a ; \hat { Y } _ { 1 \dots t - 1 } ) - \frac { 1 } { | A | } \sum _ { b } \hat { Q } ( b ; \hat { Y } _ { 1 \dots t - 1 } ) \right) ^ { 2 } } \end{array}
+$$
+
+7: Update actor weights $\theta$ using the following gradient estimate
+
+$$
+\begin{array} { r l } & { \frac { d \widehat { V ( X , Y ) } } { d \theta } = \displaystyle \sum _ { t = 1 } ^ { T } \sum _ { a \in \mathcal { A } } \frac { d p ( a | \hat { Y } _ { 1 \ldots t - 1 } , X ) } { d \theta } \hat { Q } ( a ; \hat { Y } _ { 1 \ldots t - 1 } , Y ) } \\ & { \quad \quad \quad + \lambda _ { L L } \displaystyle \sum _ { t = 1 } ^ { T } \frac { d p ( y _ { t } | Y _ { 1 \ldots t - 1 } , X ) } { d \theta } } \end{array}
+$$
+
+8: Update delayed actor and target critic, with constants $\gamma _ { \theta } \ll 1$ , $\gamma _ { \phi } \ll 1$
+
+$$
+\theta ^ { \prime } = \gamma _ { \theta } \theta + ( 1 - \gamma _ { \theta } ) \theta ^ { \prime } , \phi ^ { \prime } = \gamma _ { \phi } \phi + ( 1 - \gamma _ { \phi } ) \phi ^ { \prime }
+$$
+
+9: end while
+
+# Algorithm 2 Complete Actor-Critic Algorithm for Sequence Prediction
+
+1: Initialize critic $\hat { Q } ( a ; \hat { Y } _ { 1 \ldots t } , Y )$ and actor $\boldsymbol { p } ( \boldsymbol { a } | \hat { Y } _ { 1 \ldots t } , \boldsymbol { X } )$ with random weights $\phi$ and $\theta$ respectively.   
+2: Pre-train the actor to predict $y _ { t + 1 }$ given $Y _ { 1 \dots t }$ by maximizing $\log p ( y _ { t + 1 } | Y _ { 1 \dots t } , X )$ .   
+3: Pre-train the critic to estimate $Q$ by running Algorithm 1 with fixed actor.   
+4: Run Algorithm 1.
+
+# 3 ACTOR-CRITIC FOR SEQUENCE PREDICTION
+
+Let $\theta$ be the parameters of the conditioned RNN, which we will also refer to as the actor. Our training algorithm is based on the following way of rewriting the gradient of the expected return $\textstyle { \frac { d V } { d \theta } }$ :
+
+$$
+\frac { d V } { d \theta } = \underset { \hat { Y } \sim p ( \hat { Y } | X ) } { \mathbb { E } } \sum _ { t = 1 } ^ { T } \sum _ { a \in \mathcal { A } } \frac { d p ( a | \hat { Y } _ { 1 \dots t - 1 } ) } { d \theta } Q ( a ; \hat { Y } _ { 1 \dots t - 1 } ) .
+$$
+
+This equality is known in RL under the names policy gradient theorem (Sutton et al., 1999) and stochastic actor-critic (Sutton, 1984). 1 Note that we use the probability rather than the log probability in this formula (which is more typical in RL applications) as we are summing over actions rather than taking an expectation. Intuitively, this equality corresponds to increasing the probability of actions that give high values, and decreasing the probability of actions that give low values. Since this gradient expression is an expectation, it is trivial to build an unbiased estimate for it:
+
+$$
+\widehat { \frac { d V } { d \theta } } = \sum _ { k = 1 } ^ { M } \sum _ { t = 1 } ^ { T } \sum _ { a \in \mathcal { A } } \frac { d p ( a | \hat { Y } _ { 1 \ldots t - 1 } ^ { k } ) } { d \theta } Q ( a ; \hat { Y } _ { 1 \ldots t - 1 } ^ { k } )
+$$
+
+where ${ \hat { Y } } ^ { k }$ are $M$ random samples from $p ( \hat { Y } )$ . By replacing $Q$ with a parameteric estimate $\hat { Q }$ one can obtain a biased estimate with relatively low variance. The parameteric estimate $\hat { Q }$ is called the critic.
+
+The above formula is similar in spirit to the REINFORCE learning rule that Ranzato et al. (2015) use in the same context:
+
+$$
+\widehat { \frac { d V } { d \theta } } = \sum _ { k = 1 } ^ { M } \sum _ { t = 1 } ^ { T } \frac { d \log p ( \hat { y } _ { t } ^ { k } | \hat { Y } _ { 1 . . . t - 1 } ^ { k } ) } { d \theta } \left[ \sum _ { \tau = t } ^ { T } r _ { \tau } ( \hat { y } _ { \tau } ^ { k } ; \hat { Y } _ { 1 . . . \tau - 1 } ^ { k } ) - b _ { t } ( X ) \right] ,
+$$
+
+where the scalar $b _ { t } ( X )$ is called baseline or control variate. The difference is that in REINFORCE the inner sum over all actions is replaced by its 1-sample estimate, namely $\frac { d \log p ( \hat { y } _ { t } | \hat { Y } _ { 1 \dots t - 1 } ) } { d \theta } Q ( \hat { y } _ { t } ; \hat { Y } _ { 1 \dots t - 1 } )$ , where the log probability $\begin{array} { r } { \frac { d \log p ( \hat { y } _ { t } | \ldots ) } { d \theta } = \frac { 1 } { p ( \hat { y } _ { t } | \ldots ) } \frac { d p ( \hat { y } _ { t } | \ldots ) } { d \theta } } \end{array}$ dp(ˆyt|...) is introduced to correct for the sampling of $\hat { y } _ { t }$ . Furthermore, instead of the value $Q ( \hat { y } _ { t } ; \hat { Y } _ { 1 \dots t - 1 } )$ , REINFORCE uses the cumulative reward $\begin{array} { r } { \sum _ { \tau = t } ^ { T } r _ { \tau } \big ( \hat { y } _ { \tau } ; \hat { Y } _ { 1 \dots \tau - 1 } \big ) } \end{array}$ following the action $\hat { y } _ { t }$ , which again can be seen as a 1-sample estimate of $Q$ . Due to these simplifications and the potential high variance in the cumulative reward, the REINFORCE gradient estimator has very high variance. In order to improve upon it, we consider the actor-critic estimate from Equation 8, which has a lower variance at the cost of significant bias, since the critic is not perfect and trained simultaneously with the actor. The success depends on our ability to control the bias by designing the critic network and using an appropriate training criterion for it.
+
+To implement the critic, we propose to use a separate RNN parameterized by $\phi$ . The critic RNN is run in parallel with the actor, consumes the tokens $\hat { y } _ { t }$ that the actor outputs and produces the estimates $\hat { Q } ( a ; \hat { Y } _ { 1 \dots t } )$ for all $a \in { \mathcal { A } }$ . A key difference between the critic and the actor is that the correct answer $Y$ is given to the critic as an input, similarly to how the actor is conditioned on $X$ . Indeed, the return $R ( { \hat { Y } } , Y )$ is a deterministic function of $Y$ , and we argue that using $Y$ to compute $\hat { Q }$ should be of great help. We can do this because the values are only required during training and we do not use the critic at test time. We also experimented with providing the actor states $s _ { t }$ as additional inputs to the critic. See Figure 1 for a visual representation of our actor-critic architecture.
+
+Temporal-difference learning A crucial component of our approach is policy evaluation, that is the training of the critic to produce useful estimates of $\hat { Q }$ . With a na¨ıve Monte-Carlo method, one could use the future return $\begin{array} { r } { \sum _ { \tau = t } ^ { T } r _ { \tau } \big ( \hat { y } _ { \tau } ; \hat { Y } _ { 1 \dots \tau - 1 } \big ) } \end{array}$ as a target to $\hat { Q } ( \hat { y } _ { t } ; \hat { Y } _ { 1 \dots t - 1 } )$ , and use the critic parameters $\phi$ to minimize the square error between these two values. However, like with REINFORCE, using such a target yields to very high variance which quickly grows with the number of steps $T$ . We use a temporal difference (TD) method for policy evaluation (Sutton, 1988). Namely, we use the right-hand side $\begin{array} { r } { q _ { t } = r _ { t } ( \hat { y } _ { t } ; \hat { Y } _ { 1 \dots t - 1 } ) + \sum _ { a \in A } p ( a | \hat { Y } _ { 1 \dots t } ) \hat { Q } ( a ; \hat { Y } _ { 1 \dots t } ) } \end{array}$ of the Bellman equation as the target for the left-hand $\hat { Q } ( \hat { y } _ { t } ; \hat { Y } _ { 1 \dots t - 1 } )$ .
+
+$$
+\underbrace { \overbrace { \underbrace { \left( \begin{array} { l } { { \mathrm {  ~ { \cal ~ E } ~ } } \mathrm { { c o c r } ~ } } \mathrm { { p } } _ { \theta } \right)} ^ { \mathrm { A c t o r } { \mathrm {  ~ { \cal ~ p } } } _ { \theta } } } \\ { \mathrm {  ~ { \cal ~ E } ~ } \mathrm { { c o d e r } ~ } } \end{array}  } _ { \mathrm {  ~ { \scriptstyle ~ \underbrace { \hat { \underbrace {  ~ \psi } ~ } } ~ } , ~ \hat { \psi } _ { 1 } , ~ \hat { y } _ { 2 } , \cdots ~ , ~ \hat { y } _ { T } } } \underbrace { \overbrace { \mathrm {  ~ { \cal ~ E } ~ } \mathrm { { r i t } } \mathrm { { i } } { \mathrm { c } } ~ { \cal { Q } } _ { \phi } } ^ { \mathrm { C r i t i c } ~ { \cal { Q } } _ { \phi } } } _ { \mathrm {  ~ { \scriptstyle ~ \in ~ { c o d e r } ~ } } }
+$$
+
+Figure 1: Both the actor and the critic are encoder-decoder networks. The actor receives an input sequence $X$ and produces samples $\hat { Y }$ which are evaluated by the critic. The critic takes in the ground-truth sequence $Y$ as input to the encoder, and takes the input summary (calculated using an attention mechanism) and the actor’s prediction $\hat { y } _ { t }$ as input at time step $t$ of the decoder. The values $Q _ { 1 } , Q _ { 2 } , \cdots , Q _ { T }$ computed by the critic are used to approximate the gradient of the expected returns with respect to the parameters of the actor. This gradient is used to train the actor to optimize these expected task specific returns (e.g., BLEU score). The critic may also receive the hidden state activations of the actor as input.
+
+Applying deep RL techniques It has been shown in the RL literature that if $\hat { Q }$ is non-linear (like in our case), the TD policy evaluation might diverge (Tsitsiklis & Van Roy, 1997). Previous work has shown that this problem can be alleviated by using an additional target network $\hat { Q } ^ { \prime }$ to compute $q _ { t }$ , which is updated less often and/or more slowly than $\hat { Q }$ . Similarly to (Lillicrap et al., 2015), we update the parameters $\phi ^ { \prime }$ of the target critic by linearly interpolating them with the parameters of the trained one. Attempts to remove the target network by propagating the gradient through $q _ { t }$ resulted in a lower square error $( \hat { Q } ( \hat { y } _ { t } ; \hat { Y } _ { 1 \dots T } ) - q _ { t } ) ^ { 2 }$ , but the resulting $\hat { Q }$ values proved very unreliable as training signals for the actor.
+
+The fact that both actor and critic use outputs of each other for training creates a potentially dangerous feedback loop. To address this, we sample predictions from a delayed actor (Lillicrap et al., 2015), whose weights are slowly updated to follow the actor that is actually trained.
+
+Dealing with large action spaces One of the challenges of our work is that the action space is very large (as is typically the case in NLP tasks with large vocabularies). This can be alleviated by putting constraints on the critic values for actions that are rarely sampled. We found experimentally that shrinking the values of these rare actions is necessary for the algorithm to converge. Specifically, we add a term $C _ { t }$ for every step $t$ to the critic’s optimization objective which drives all value predictions of the critic closer to their mean:
+
+$$
+C _ { t } = \sum _ { a } \left( \hat { Q } ( a ; \hat { Y } _ { 1 \ldots t - 1 } ) - \frac { 1 } { | A | } \sum _ { b } \hat { Q } ( b ; \hat { Y } _ { 1 \ldots t - 1 } ) \right) ^ { 2 }
+$$
+
+This corresponds to penalizing the variance of the outputs of the critic. Without this penalty the values of rare actions can be severely overestimated, which biases the gradient estimates and can cause divergence. A similar trick was used in the context of learning simple algorithms with Q-learning (Zaremba et al., 2015).
+
+Reward shaping While we are ultimately interested in the maximization of the score of a complete prediction, simply awarding this score at the last step provides a very sparse training signal for the critic. For this reason we use potential-based reward shaping with potentials $\Phi ( { \hat { Y } } _ { 1 \dots t } ) = R ( { \hat { Y } } _ { 1 \dots t } )$ for incomplete sequences and $\hat { \Phi } ( \hat { Y } ) = 0$ for complete ones ( $\mathrm { N g }$ et al., 1999). Namely, for a predicted sequence $\hat { Y }$ we compute score values for all prefixes to obtain the sequence of scores $( R ( \hat { Y } _ { 1 \dots 1 } ) , \bar { R ( Y _ { 1 \dots 2 } ) } , \dots , R ( \hat { Y } _ { 1 \dots T } ) )$ . The difference between the consecutive pairs of scores is then used as the reward at each step: $r _ { t } ( \hat { y } _ { t } ; \hat { Y } _ { 1 \ldots t - 1 } ) = R ( \hat { Y } _ { 1 \ldots t } ) - R ( \hat { Y } _ { 1 \ldots t - 1 } )$ . Using the shaped reward $r _ { t }$ instead of awarding the whole score $R$ at the last step does not change the optimal policy $\mathrm { N g }$ et al., 1999).
+
+Putting it all together Algorithm 1 describes the proposed method in detail. We consider adding the weighted log-likelihood gradient to the actor’s gradient estimate. This is in line with the prior work by (Ranzato et al., 2015) and (Shen et al., 2015). It is also motivated by our preliminary experiments that showed that using the actor-critic estimate alone can lead to an early determinization of the policy and vanishing gradients (also discussed in Section 6). Starting training with a randomly initialized actor and critic would be problematic, because neither the actor nor the critic would provide adequate training signals for one another. The actor would sample completely random predictions that receive very little reward, thus providing a very weak training signal for the critic. A random critic would be similarly useless for training the actor. Motivated by these considerations, we pre-train the actor using standard log-likelihood training. Furthermore, we pre-train the critic by feeding it samples from the pre-trained actor, while the actor’s parameters are frozen. The complete training procedure including pre-training is described by Algorithm 2.
+
+# 4 RELATED WORK
+
+In other recent RL-inspired work on sequence prediction, Ranzato et al. (2015) trained a translation model by gradually transitioning from maximum likelihood learning into optimizing BLEU or ROUGE scores using the REINFORCE algorithm. However, REINFORCE is known to have very high variance and does not exploit the availability of the ground-truth like the critic network does. The approach also relies on a curriculum learning scheme. Standard value-based RL algorithms like SARSA and OLPOMDP have also been applied to structured prediction (Maes et al., 2009). Again, these systems do not use the ground-truth for value prediction.
+
+Imitation learning has also been applied to structured prediction (Vlachos, 2012). Methods of this type include the SEARN (Daume Iii et al., 2009) and ´ DAGGER (Ross et al., 2010) algorithms. These methods rely on an expert policy to provide action sequences that the policy learns to imitate. Unfortunately, it’s not always easy or even possible to construct an expert policy for a task-specific score. In our approach, the critic plays a role that is similar to the expert policy, but is learned without requiring prior knowledge about the task-specific score. The recently proposed ‘scheduled sampling’ (Bengio et al., 2015) can also be seen as imitation learning. In this method, ground-truth tokens are occasionally replaced by samples from the model itself during training. A limitation is that the token $k$ for the ground-truth answer is used as the target at step $k$ , which might not always be the optimal strategy.
+
+There are also approaches that aim to approximate the gradient of the expected score. One such approach is ‘Direct Loss Minimization’ (Hazan et al., 2010) in which the inference procedure is adapted to take both the model likelihood and task-specific score into account. Another popular approach is to replace the domain over which the task score expectation is defined with a small subset of it, as is done in Minimum (Bayes) Risk Training (Goel & Byrne, 2000; Shen et al., 2015; Och, 2003). This small subset is typically an $n$ -best list or a sample (like in REINFORCE) that may or may not include the ground-truth as well. None of these methods provide intermediate targets for the actor during training, and Shen et al. (2015) report that as many as 100 samples were required for the best results.
+
+Another recently proposed method is to optimize a global sequence cost with respect to the selection and pruning behavior of the beam search procedure itself (Wiseman & Rush, 2016). This method follows the more general strategy called ‘learning as search optimization’ (Daume III & Marcu, 2005). ´ This is an interesting alternative to our approach; however, it is designed specifically for the precise inference procedure involved.
+
+# 5 EXPERIMENTS
+
+To validate our approach, we performed two sets of experiments 2. First, we trained the proposed model to recover strings of natural text from their corrupted versions. Specifically, we consider each character in a natural language corpus and with some probability replace it with a random character. We call this synthetic task spelling correction. A desirable property of this synthetic task is that data is essentially infinite and overfitting is no concern. Our second series of experiments is done on the task of automatic machine translation using different models and datasets.
+
+In addition to maximum likelihood and actor-critic training we implemented two versions of the REINFORCE gradient estimator. In the first version, we use a linear baseline network that takes the actor states as input, exactly as in (Ranzato et al., 2015). We also propose a novel extension of REINFORCE that leverages the extra information available in the ground-truth output $Y$ . Specifically, we use the $\hat { Q }$ estimates produced by the critic network as the baseline for the REINFORCE algorithm. The motivation behind this approach is that using the ground-truth output should produce a better baseline that lowers the variance of REINFORCE, resulting in higher task-specific scores. We refer to this method as REINFORCE-critic.
+
+# 5.1 SPELLING CORRECTION
+
+We use text from the One Billion Word dataset for the spelling correction task (Chelba et al., 2013), which has pre-defined training and testing sets. The training data was abundant, and we never used any example twice. We evaluate trained models on a section of the test data that comprises 6075 sentences. To speed up experiments, we clipped all sentences to the first 10 or 30 characters.
+
+For the spelling correction actor network, we use an RNN with 100 Gated Recurrent Units (GRU) and a bidirectional GRU network for the encoder. We use the same attention mechanism as proposed in (Bahdanau et al., 2015), which effectively makes our actor network a smaller version of the model used in that work. For the critic network, we employed a model with the same architecture as the actor.
+
+We use character error rate (CER) to measure performance on the spelling task, which we define as the ratio between the total of Levenshtein distances between predictions and ground-truth outputs and the total length of the ground-truth outputs. This is a corpus-level metric for which a lower value is better. We use it as the return by negating per-sentence ratios. At the evaluation time greedy search is used to extract predictions from the model.
+
+We use the ADAM optimizer (Kingma & Ba, 2015) to train all the networks with the parameters recommended in the original paper, with the exception of the scale parameter $\alpha$ . The latter is first set to $1 0 ^ { - 3 }$ and then annealed to $1 0 ^ { - 4 }$ for log-likelihood training. For the pre-training stage of the actor-critic, we use $\alpha \stackrel { - } { = } 1 0 ^ { - 3 }$ and decrease it to $1 0 ^ { - 4 }$ for the joint actor-critic training. We pretrain the actor until its score on the development set stops improving. We pretrain the critic until its TD error stabilizes3. We used $M = 1$ sample for both actor-critic and REINFORCE. For exact hyperparameter settings we refer the reader to Appendix A.
+
+We start REINFORCE training from a pretrained actor, but we do not use the curriculum learning employed in MIXER. The critic is trained in the same way for both REINFORCE and actorcritic, including the pretraining stage. We report results obtained with the reward shaping described in Section 3, as we found that it slightly improves REINFORCE performance.
+
+Table 1 presents our results on the spelling correction task. We observe an improvement in CER over log-likelihood training for all four settings considered. Without simultaneous loglikelihood training, actor-critic training results in a better CER than REINFORCE-critic in three
+
+![](images/460c085511c4b0dfbef2c0396b6671eaf4b5021d48d37b120350a5315592f68a.jpg)  
+Figure 2: Progress of log-likelihood (LL), REINFORCE (RF) and actor-critic (AC) training in terms of BLEU score on the training (train) and validation (valid) datasets. $\mathrm { L L ^ { * } }$ stands for the annealing phase of log-likelihood training. The curves start from the epoch of log-likelihood pretraining from which the parameters were initialized.
+
+Table 1: Character error rate of different methods on the spelling correction task. In the table $L$ is the length of input strings, $\eta$ is the probability of replacing a character with a random one. LL stands for the log-likelihood training, AC and RF-C and for the actor-critic and the REINFORCE-critic respectively, $\mathrm { \ A C + L L }$ and RF- $\mathrm { { C + L L } }$ for the combinations of AC and RF-C with LL.   
+
+<table><tr><td rowspan="2">Setup</td><td colspan="5">CharacterErrorRate</td></tr><tr><td>LL</td><td>AC</td><td>RF-C</td><td>AC+LL</td><td>RF-C+LL</td></tr><tr><td>L=10,n=0.3</td><td>17.81</td><td>17.24</td><td>17.82</td><td>16.65</td><td>16.97</td></tr><tr><td>L =30,n = 0.3</td><td>18.4</td><td>17.31</td><td>18.16</td><td>17.1</td><td>17.47</td></tr><tr><td>L = 10,n = 0.5</td><td>38.12</td><td>35.89</td><td>35.84</td><td>34.6</td><td>35</td></tr><tr><td>L = 30,n = 0.5</td><td>40.87</td><td>37.0</td><td>37.6</td><td>36.36</td><td>36.6</td></tr></table>
+
+Table 2: Our IWSLT 2014 machine translation results with a convolutional encoder compared to the previous work by Ranzato et al. Please see 1 for an explanation of abbreviations. The asterisk identifies results from (Ranzato et al., 2015). The numbers reported with $\leq$ were approximately read from Figure 6 of (Ranzato et al., 2015)   
+
+<table><tr><td rowspan="2">Decoding method</td><td colspan="6">Model</td></tr><tr><td>LL*</td><td>MIXER*</td><td>LL</td><td>RF</td><td>RF-C</td><td>AC</td></tr><tr><td>greedy search</td><td>17.74</td><td>20.73</td><td>19.33</td><td>20.92</td><td>22.24</td><td>21.66</td></tr><tr><td>beam search</td><td>≤20.3</td><td>≤ 21.9</td><td>21.46</td><td>21.35</td><td>22.58</td><td>22.45</td></tr></table>
+
+out of four settings. In the fourth case, actor-critic and REINFORCE-critic have similar performance. Adding the log-likelihood gradient with a cofficient $\lambda _ { L L } = 0 . 1$ helps both of the methods, but actor-critic still retains a margin of improvement over REINFORCE-critic.
+
+# 5.2 MACHINE TRANSLATION
+
+For our first translation experiment, we use data from the German-English machine translation track of the IWSLT 2014 evaluation campaign (Cettolo et al., 2014), as used in Ranzato et al. (2015), and closely follow the pre-processing described in that work. The training data comprises about 153,000 German-English sentence pairs. In addition we considered a larger WMT14 English-French dataset Cho et al. (2014) with more than 12 million examples. For further information about the data we refer the reader to Appendix B.
+
+The return is defined as a smoothed and rescaled version of the BLEU score. Specifically, we start all n-gram counts from 1 instead of 0, and multiply the resulting score by the length of the ground-truth translation. Smoothing is a common practice when sentence-level BLEU score is considered, and it has been used to apply REINFORCE in similar settings (Ranzato et al., 2015).
+
+IWSLT 2014 with a convolutional encoder In our first experiment we use a convolutional encoder in the actor to make our results more comparable with Ranzato et al. (2015). For the same reason, we use 256 hidden units in the networks. For the critic, we replaced the convolutional network with a bidirectional GRU network. For training this model we mostly used the same hyperparameter values as in the spelling correction experiments, with a few differences highlighted in Appendix A. For decoding we used greedy search and beam search with a beam size of 10. We found that penalizing candidate sentences that are too short was required to obtain the best results. Similarly to (Hannun et al., 2014), we subtracted $\rho T$ from the negative log-likelihood of each candidate sentence, where $T$ is the candidate’s length, and $\rho$ is a hyperparameter tuned on the validation set.
+
+The results are summarized in Table 2. We report a significant improvement of 2.3 BLEU points over the log-likelihood baseline when greedy search is used for decoding. Surprisingly, the best performing method is REINFORCE with critic, with an additional 0.6 BLEU point advantage over the actor-critic. When beam-search is used, the ranking of the compared approaches is the same, but the margin between the proposed methods and log-likelihood training becomes smaller. The final performances of the actor-critic and the REINFORCE-critic with greedy search are also 0.7 and 1.3 BLEU points respectively better than what Ranzato et al. (2015) report for their MIXER approach. This comparison should be treated with caution, because our log-likelihood baseline is 1.6 BLEU points stronger than its equivalent from (Ranzato et al., 2015). The performance of REINFORCE with a simple baseline matches the score reported for MIXER in Ranzato et al. (2015).
+
+Table 3: Our IWSLT 2014 machine translation results with a bidirectional recurrent encoder compared to the previous work. Please see Table 1 for an explanation of abbreviations. The asterisk identifies results from (Wiseman & Rush, 2016).   
+
+<table><tr><td rowspan="2">Decoding method</td><td colspan="7">Model</td></tr><tr><td>LL*</td><td>BSO*</td><td>LL</td><td>RF-C</td><td>RF-C+LL</td><td>AC</td><td>AC+LL</td></tr><tr><td>greedy search</td><td>22.53</td><td>23.83</td><td>25.82</td><td>27.42</td><td>27.7</td><td>27.27</td><td>27.49</td></tr><tr><td>beam search</td><td>23.87</td><td>25.48</td><td>27.56</td><td>27.75</td><td>28.3</td><td>27.75</td><td>28.53</td></tr></table>
+
+Table 4: Our WMT 14 machine translation results compared to the previous work. Please see Table 1 for an explanation of abbreviations. The apostrophy and the asterisk identify results from (Bahdanau et al., 2015) and (Shen et al., 2015) respectively.   
+
+<table><tr><td rowspan="2">Decoding method</td><td colspan="6">Model</td></tr><tr><td>LL&#x27;</td><td>LL*</td><td>MRT *</td><td>LL</td><td>AC+LL</td><td>RF-C+LL</td></tr><tr><td>greedy search beam search</td><td>n/a 28.45</td><td>n/a 29.88</td><td>n/a 31.3</td><td>29.33 30.71</td><td>30.85 31.13</td><td>29.83 30.37</td></tr></table>
+
+To better understand the IWSLT 2014 results we provide the learning curves for the considered approaches in Figure 2. We can clearly see that the training methods that use generated predictions have a strong regularization effect — that is, better progress on the validation set in exchange for slower or negative progress on the training set. The effect is stronger for both REINFORCE varieties, especially for the one without a critic. The actor-critic training does a much better job of fitting the training set than REINFORCE and is the only method except log-likelihood that shows a clear overfitting, which is a healthy behaviour for such a small dataset.
+
+In addition, we performed an ablation study. We found that using a target network was crucial; while the joint actor-critic training was still progressing with $\gamma _ { \theta } = 0 . 1$ , with $\gamma _ { \theta } = 1 . 0$ it did not work at all. Similarly important was the value penalty described in Equation (10). We found that good values of the $\lambda$ coefficient were in the range $[ 1 0 ^ { \dot { - } 3 } , 1 0 ^ { - 6 } ]$ . Other techniques, such as reward shaping and a delayed actor, brought moderate performance gains. We refer the reader to Appendix A for more details.
+
+IWSLT 2014 with a bidirectional GRU encoder In order to compare our results with those reported by Wiseman & Rush (2016) we repeated our IWSLT 2014 investigation with a different encoder, a bidirectional RNN with 256 GRU units. In this round of experiments we also tried to used combined training objectives in the same way as in our spelling correction experiments. The results are summarized in Table 3. One can see that the actor-critic training, especially its $\mathrm { \ A C + L L }$ version, yields significant improvements (1.7 with greedy search and 1.0 with beam search) upon the pure log-likelihood training, which are comparable to those brought by Beam Search Optimization (BSO), even though our log-likelihood baseline is much stronger. In this round of experiments actor-critic and REINFORCE-critic performed on par.
+
+WMT 14 Finally we report our results on a very popular large WMT14 English-French dataset (Cho et al., 2014) in Table 4. Our model closely follows the achitecture from (Bahdanau et al., 2015), however we achieved a higher baseline performance by annealing the learning rate $\alpha$ and penalizing output sequences that were too short during beam search. The actor-critic training brings a significant 1.5 BLEU improvement with greedy search and a noticeable 0.4 BLEU improvement with beam search. In previous work Shen et al. (2015) report a higher improvement of 1.4 BLEU with beam search, however they use 100 samples for each training example, whereas we use just one. We note that in this experiment, which is perhaps the most realistic settings, the actor-critic enjoys a significant advantage over the REINFORCE-critic.
+
+# 6 DISCUSSION
+
+We proposed an actor-critic approach to sequence prediction. Our method takes the task objective into account during training and uses the ground-truth output to aid the critic in its prediction of intermediate targets for the actor. We showed that our method leads to significant improvements over maximum likelihood training on both a synthetic task and a machine translation benchmark. Compared to REINFORCE training on machine translation, actor-critic fits the training data much faster, although in some of our experiments we were able to significantly reduce the gap in the training speed and achieve a better test error using our critic network as the baseline for REINFORCE.
+
+One interesting observation we made from the machine translation results is that the training methods that use generated predictions have a strong regularization effect. Our understanding is that conditioning on the sampled outputs effectively increases the diversity of training data. This phenomenon makes it harder to judge whether the actor-critic training meets our expectations, because a noisier gradient estimate yielded a better test set performance. We argue that the spelling correction results obtained on a virtually infinite dataset in conjuction with better machine translation performance on the large WMT 14 dataset provide convincing evidence that the actor-training can be effective. In future work we will consider larger machine translation datasets.
+
+We ran into several optimization issues. The critic would sometimes assign very high values to actions with a very low probability according to the actor. We were able to resolve this by penalizing the critic’s variance. Additionally, the actor would sometimes have trouble to adapt to the demands of the critic. We noticed that the action distribution tends to saturate and become deterministic, causing the gradient to vanish. We found that combining an RL training objective with log-likelihood can help, but in general we think this issue deserves further investigation. For example, one can look for suitable training criteria that have a well-behaved gradient even when the policy has little or no stochasticity.
+
+In a concurrent work Wu et al. (2016) show that a version of REINFORCE with the baseline computed using multiple samples can improve performance of a very strong machine translation system. This result, and our REINFORCE-critic experiments, suggest that often the variance of REINFORCE can be reduced enough to make its application practical. That said, we would like to emphasize that this paper attacks the problem of gradient estimation from a very different angle as it aims for low-variance but potentially high-bias estimates. The idea of using the ground-truth output that we proposed is an absolutely necessary first step in this direction. Future work could focus on further reducing the bias of the actor-critic estimate, for example, by using a multi-sample training criterion for the critic.
+
+# ACKNOWLEDGMENTS
+
+We thank the developers of Theano (Theano Development Team, 2016) and Blocks (van Merrienboer ¨ et al., 2015) for their great work. We thank NSERC, Compute Canada, Calcul Quebec, Canada ´ Research Chairs, CIFAR, CHISTERA project M2CR (PCIN-2015-226) and Samsung Institute of Advanced Techonology for their financial support.
+
+# REFERENCES
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In Proceedings of the ICLR 2015, 2015.
+
+Andrew G Barto, Richard S Sutton, and Charles W Anderson. Neuronlike adaptive elements that can solve difficult learning control problems. Systems, Man and Cybernetics, IEEE Transactions on, (5):834–846, 1983.
+
+Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. arXiv preprint arXiv:1506.03099, 2015.
+
+Mauro Cettolo, Jan Niehues, Sebastian Stuker, Luisa Bentivogli, and Marcello Federico. Report on ¨ the 11th iwslt evaluation campaign. In Proc. of IWSLT, 2014.
+
+William Chan, Navdeep Jaitly, Quoc V Le, and Oriol Vinyals. Listen, attend and spell. arXiv preprint arXiv:1508.01211, 2015.
+
+Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling. arXiv preprint arXiv:1312.3005, 2013.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger ¨ Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.
+
+Jan Chorowski, Dzmitry Bahdanau, Dmitriy Serdyuk, KyungHyun Cho, and Yoshua Bengio. Attention-based models for speech recognition. CoRR, abs/1506.07503, 2015. URL http: //arxiv.org/abs/1506.07503.
+
+Hal Daume III and Daniel Marcu. Learning as search optimization: Approximate large margin ´ methods for structured prediction. In Proceedings of the 22nd international conference on Machine learning, pp. 169–176. ACM, 2005.
+
+Hal Daume Iii, John Langford, and Daniel Marcu. Search-based structured prediction. ´ Machine learning, 75(3):297–325, 2009.
+
+Jeffrey Donahue, Lisa Anne Hendricks, Sergio Guadarrama, Marcus Rohrbach, Subhashini Venugopalan, Kate Saenko, and Trevor Darrell. Long-term recurrent convolutional networks for visual recognition and description. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2625–2634, 2015.
+
+Vaibhava Goel and William J Byrne. Minimum bayes-risk automatic speech recognition. Computer Speech & Language, 14(2):115–135, 2000.
+
+Awni Y Hannun, Andrew L Maas, Daniel Jurafsky, and Andrew Y Ng. First-pass large vocabulary continuous speech recognition using bi-directional recurrent dnns. arXiv preprint arXiv:1408.2873, 2014.
+
+Tamir Hazan, Joseph Keshet, and David A McAllester. Direct loss minimization for structured prediction. In Advances in Neural Information Processing Systems, pp. 1594–1602, 2010.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Andrej Karpathy and Li Fei-Fei. Deep visual-semantic alignments for generating image descriptions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3128– 3137, 2015.
+
+Diederik P Kingma and Jimmy Ba. A method for stochastic optimization. In International Conference on Learning Representation, 2015.
+
+Ryan Kiros, Ruslan Salakhutdinov, and Richard S Zemel. Unifying visual-semantic embeddings with multimodal neural language models. arXiv preprint arXiv:1411.2539, 2014.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Chin-Yew Lin and Eduard Hovy. Automatic evaluation of summaries using n-gram co-occurrence statistics. In Proceedings of the 2003 Conference of the North American Chapter of the Association for Computational Linguistics on Human Language Technology-Volume 1, pp. 71–78. Association for Computational Linguistics, 2003.
+
+Francis Maes, Ludovic Denoyer, and Patrick Gallinari. Structured prediction with reinforcement learning. Machine learning, 77(2-3):271–301, 2009.
+
+W Thomas Miller, Paul J Werbos, and Richard S Sutton. Neural networks for control. MIT press, 1995.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Andrew Y Ng, Daishi Harada, and Stuart Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In ICML, volume 99, pp. 278–287, 1999.
+
+Franz Josef Och. Minimum error rate training in statistical machine translation. In Proceedings of the 41st Annual Meeting on Association for Computational Linguistics-Volume 1, pp. 160–167. Association for Computational Linguistics, 2003.
+
+Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting on association for computational linguistics, pp. 311–318. Association for Computational Linguistics, 2002.
+
+Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015.
+
+Stephane Ross, Geoffrey J Gordon, and J Andrew Bagnell. A reduction of imitation learning and ´ structured prediction to no-regret online learning. arXiv preprint arXiv:1011.0686, 2010.
+
+Alexander M Rush, Sumit Chopra, and Jason Weston. A neural attention model for abstractive sentence summarization. arXiv preprint arXiv:1509.00685, 2015.
+
+Mike Schuster and Kuldip K Paliwal. Bidirectional recurrent neural networks. Signal Processing, IEEE Transactions on, 45(11):2673–2681, 1997.
+
+Shiqi Shen, Yong Cheng, Zhongjun He, Wei He, Hua Wu, Maosong Sun, and Yang Liu. Minimum risk training for neural machine translation. arXiv preprint arXiv:1512.02433, 2015.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, pp. 3104–3112, 2014.
+
+Richard S Sutton. Learning to predict by the methods of temporal differences. Machine learning, 3 (1):9–44, 1988.
+
+Richard S Sutton and Andrew G Barto. Introduction to reinforcement learning, volume 135. MIT Press Cambridge, 1998.
+
+Richard S Sutton, David A McAllester, Satinder P Singh, Yishay Mansour, et al. Policy gradient methods for reinforcement learning with function approximation. In NIPS, volume 99, pp. 1057– 1063, 1999.
+
+Richard Stuart Sutton. Temporal credit assignment in reinforcement learning. 1984.
+
+Gerald Tesauro. Td-gammon, a self-teaching backgammon program, achieves master-level play. Neural computation, 6(2):215–219, 1994.
+
+Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688.
+
+John N Tsitsiklis and Benjamin Van Roy. An analysis of temporal-difference learning with function approximation. Automatic Control, IEEE Transactions on, 42(5):674–690, 1997.
+
+Bart van Merrienboer, Dzmitry Bahdanau, Vincent Dumoulin, Dmitriy Serdyuk, David Warde- ¨ Farley, Jan Chorowski, and Yoshua Bengio. Blocks and fuel: Frameworks for deep learning. arXiv:1506.00619 [cs, stat], June 2015.
+
+Oriol Vinyals, Alexander Toshev, Samy Bengio, and Dumitru Erhan. Show and tell: A neural image caption generator. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3156–3164, 2015.
+
+Andreas Vlachos. An investigation of imitation learning algorithms for structured prediction. In EWRL, pp. 143–154. Citeseer, 2012.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+Sam Wiseman and Alexander M Rush. Sequence-to-sequence learning as beam-search optimization. arXiv preprint arXiv:1606.02960, 2016.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron C. Courville, Ruslan Salakhutdinov, Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 2048–2057, 2015.
+
+Wojciech Zaremba, Tomas Mikolov, Armand Joulin, and Rob Fergus. Learning simple algorithms from examples. arXiv preprint arXiv:1511.07275, 2015.
+
+Table 5: Results of an ablation study. We tried varying the actor update speed $\gamma _ { \theta }$ , the critic update speed $\gamma _ { \phi }$ , the value penalty coefficient $\lambda$ , whether or not reward shaping is used, whether or not temporal difference (TD) learning is used for the critic. Reported are the best training and validation BLEU score obtained in the course of the first 10 training epochs. Some of the validation scores would still improve with longer training. Greedy search was used for decoding.   
+
+<table><tr><td>Y0</td><td>Y</td><td>入</td><td>reward shaping</td><td>TD</td><td>train BLEU</td><td>valid BLEU</td></tr><tr><td colspan="7">baseline</td></tr><tr><td>0.001</td><td>0.001</td><td>10-3</td><td>yes</td><td>yes</td><td>33.73</td><td>23.16</td></tr><tr><td colspan="7">with different γ</td></tr><tr><td>0.001</td><td>0.01</td><td>10-3</td><td>yes</td><td>yes</td><td>33.52</td><td>23.03</td></tr><tr><td>0.001</td><td>0.1</td><td>10-3</td><td>yes</td><td>yes</td><td>32.63</td><td>22.80</td></tr><tr><td>0.001</td><td>1</td><td>10-3</td><td>yes</td><td>yes</td><td>9.59</td><td>8.14</td></tr><tr><td colspan="7">with different ye</td></tr><tr><td>1</td><td>0.001</td><td>10-3</td><td>yes</td><td>yes</td><td>32.9</td><td>22.88</td></tr><tr><td colspan="7">without reward shaping</td></tr><tr><td>0.001</td><td>0.001</td><td>10-3</td><td>no</td><td>yes</td><td>32.74</td><td>22.61</td></tr><tr><td colspan="7">without temporal difference learning</td></tr><tr><td>0.001</td><td>0.001</td><td>10-3</td><td>yes</td><td>no</td><td>23.2</td><td>16.36</td></tr><tr><td colspan="7">with different 入</td></tr><tr><td>0.001</td><td>0.001</td><td>3*10-3</td><td>yes</td><td>yes</td><td>32.4</td><td>22.48</td></tr><tr><td>0.001</td><td>0.001</td><td>10-4</td><td>yes</td><td>yes</td><td>34.10</td><td>23.15</td></tr><tr><td>0.001</td><td>0.001</td><td>10-6</td><td>yes</td><td>yes</td><td>35.00</td><td>23.10</td></tr><tr><td>0.001</td><td>0.001</td><td>10-8</td><td>yes</td><td>yes</td><td>33.6</td><td>22.72</td></tr><tr><td>0.001</td><td>0.001</td><td>0</td><td>yes</td><td>yes</td><td>27.41</td><td>20.55</td></tr></table>
+
+# A HYPERPARAMETERS
+
+For machine translation experiments the variance penalty coefficient $\lambda$ was set to $1 0 ^ { - 4 }$ , and the delay coefficients $\gamma _ { \theta }$ and $\gamma _ { \phi }$ were both set to $1 0 ^ { - 4 }$ . For REINFORCE with the critic we did not use a delayed actor, i.e. $\gamma _ { \theta }$ was set to 1. For the spelling correction task we used the same $\gamma _ { \theta }$ and $\gamma _ { \phi }$ but a different $\lambda = 1 0 ^ { - 3 }$ . When we used a combined training criterion, the weight of the log-likelihood gradient $\lambda _ { L L }$ was always 0.1. All initial weights were sampled from a centered uniform distribution with width 0.1.
+
+In some of our experiments we provided the actor states as additional inputs to the critic. Specifically, we did so in our spelling correction experiments and in our WMT 14 machine translation study. All the other results were obtained without this technique.
+
+For decoding with beam search we substracted the length of a candidate times $\rho$ from the loglikelihood cost. The exact value of $\rho$ was selected on the validation set and was equal to 0.8 for models trained by log-likelihood and REINFORCE and to 1.0 for models trained by actor-critic and REINFORCE-critic.
+
+For some of the hyperparameters we performed an ablation study. The results are reported in Table 5.
+
+# B DATA
+
+For the IWSLT 2014 data the sizes of validation and tests set were 6,969 and 6,750, respectively. We limited the number of words in the English and German vocabularies to the 22,822 and 32,009 most frequent words, respectively, and replaced all other words with a special token. The maximum sentence length in our dataset was 50. For WMT14 we used vocabularies of 30,000 words for both English and French, and the maximum sentence length was also 50.
+
+# C GENERATED Q-VALUES
+
+In Table C we provide an example of value predictions that the critic outputs for candidate next words. One can see that the critic has indeed learnt to assign larger values for the appropriate next words. While the critic does not always produce sensible estimates and can often predict a high return for irrelevant rare words, this is greatly reduced using the variance penalty term from Equation (10).
+
+Figure 3: The best 3 words according to the critic at intermediate steps of generating a translation. The numbers in parentheses are the value predictions $\hat { Q }$ . The German original is “uber eine davon ¨ will ich hier erzahlen .” The reference translation is “and there’s one I want to talk about”. ¨   
+
+<table><tr><td rowspan=1 colspan=1>Word</td><td rowspan=1 colspan=1>Words with largest Q</td></tr><tr><td rowspan=1 colspan=1>oneofthemi</td><td></td></tr><tr><td rowspan=1 colspan=1>Wanttotellyou</td><td></td></tr><tr><td rowspan=1 colspan=1>abouthereD</td><td></td></tr></table>
+
+D PROOF OF EQUATION (7)
+
+$$
+\begin{array} { r l r } & { } & { \phi ( { \bf x } ) = \phi ^ { \prime } - \phi ^ { \prime } \frac { 1 } { 2 } \frac { \partial \xi } { \partial t } \frac { \partial \xi } { \partial t } \frac { \partial \xi } { \partial t } \big ( \mathrm { d } \mathrm { d } t \big ) - \sum _ { j = 1 } ^ { N } \mu \frac { \mathrm { d } \mathrm { d } \mathrm { d } \mathrm { d } t } { \partial t } \mathrm { d } \mathrm { d } \mathrm { d } t \big [ \mathrm { d } \mathrm { d } \mathrm { d } t \big [ \mathrm { H } _ { 2 } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm } { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm  { H } \mathrm { H } \mathrm { H } \mathrm { H } \mathrm { H }  \\ & { } &  \mathrm { \Omega } \le \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac { \mathrm { d } } { \mathrm { d } } \frac  \ \end{array}
+$$

parse/train/SJDaqqveg/SJDaqqveg_content_list.json

@@ -0,0 +1,1883 @@
+[
+    {
+        "type": "text",
+        "text": "AN ACTOR-CRITIC ALGORITHM FOR SEQUENCE PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            560,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau Philemon Brakel Kelvin Xu Anirudh Goyal Universite de Montr ´ eal ´ ",
+        "bbox": [
+            184,
+            172,
+            449,
+            214
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ryan Lowe Joelle Pineau∗ McGill University ",
+        "bbox": [
+            629,
+            172,
+            818,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Aaron Courville† Universite de Montr´ eal´ ",
+        "bbox": [
+            184,
+            236,
+            336,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio∗ Universite de Montr ´ eal ´ ",
+        "bbox": [
+            627,
+            236,
+            781,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            301,
+            544,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present an approach to training neural networks to generate sequences using actor-critic methods from reinforcement learning (RL). Current log-likelihood training methods are limited by the discrepancy between their training and testing modes, as models must generate tokens conditioned on their previous guesses rather than the ground-truth tokens. We address this problem by introducing a critic network that is trained to predict the value of an output token, given the policy of an actor network. This results in a training procedure that is much closer to the test phase, and allows us to directly optimize for a task-specific score such as BLEU. Crucially, since we leverage these techniques in the supervised learning setting rather than the traditional RL setting, we condition the critic network on the ground-truth output. We show that our method leads to improved performance on both a synthetic task, and for German-English machine translation. Our analysis paves the way for such methods to be applied in natural language generation tasks, such as machine translation, caption generation, and dialogue modelling. ",
+        "bbox": [
+            233,
+            335,
+            766,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            563,
+            336,
+            578
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In many important applications of machine learning, the task is to develop a system that produces a sequence of discrete tokens given an input. Recent work has shown that recurrent neural networks (RNNs) can deliver excellent performance in many such tasks when trained to predict the next output token given the input and previous tokens. This approach has been applied successfully in machine translation (Sutskever et al., 2014; Bahdanau et al., 2015), caption generation (Kiros et al., 2014; Donahue et al., 2015; Vinyals et al., 2015; Xu et al., 2015; Karpathy & Fei-Fei, 2015), and speech recognition (Chorowski et al., 2015; Chan et al., 2015). ",
+        "bbox": [
+            174,
+            595,
+            825,
+            694
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The standard way to train RNNs to generate sequences is to maximize the log-likelihood of the “correct” token given a history of the previous “correct” ones, an approach often called teacher forcing. At evaluation time, the output sequence is often produced by an approximate search for the most likely candidate according to the learned distribution. During this search, the model is conditioned on its own guesses, which may be incorrect and thus lead to a compounding of errors (Bengio et al., 2015). This can become especially problematic for longer sequences. Due to this discrepancy between training and testing conditions, it has been shown that maximum likelihood training can be suboptimal (Bengio et al., 2015; Ranzato et al., 2015). In these works, the authors argue that the network should be trained to continue generating correctly given the outputs already produced by the model, rather than the ground-truth reference outputs from the data. This gives rise to the challenging problem of determining the target for the next network output. Bengio et al. (2015) use the token $k$ from the ground-truth answer as the target for the network at step $k$ , whereas Ranzato et al. (2015) rely on the REINFORCE algorithm (Williams, 1992) to decide whether or not the tokens from a sampled prediction lead to a high task-specific score, such as BLEU (Papineni et al., 2002) or ROUGE (Lin & Hovy, 2003). ",
+        "bbox": [
+            173,
+            700,
+            825,
+            881
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose and study an alternative procedure for training sequence prediction networks that aims to directly improve their test time metrics (which are typically not the log-likelihood). In particular, we train an additional network called the critic to output the value of each token, which we define as the expected task-specific score that the network will receive if it outputs the token and continues to sample outputs according to its probability distribution. Furthermore, we show how the predicted values can be used to train the main sequence prediction network, which we refer to as the actor. The theoretical foundation of our method is that, under the assumption that the critic computes exact values, the expression that we use to train the actor is an unbiased estimate of the gradient of the expected task-specific score. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our approach draws inspiration and borrows the terminology from the field of reinforcement learning (RL) (Sutton & Barto, 1998), in particular from the actor-critic approach (Sutton, 1984; Sutton et al., 1999; Barto et al., 1983). RL studies the problem of acting efficiently based only on weak supervision in the form of a reward given for some of the agent’s actions. In our case, the reward is analogous to the task-specific score associated with a prediction. However, the tasks we consider are those of supervised learning, and we make use of this crucial difference by allowing the critic to use the ground-truth answer as an input. In other words, the critic has access to a sequence of expert actions that are known to lead to high (or even optimal) returns. To train the critic, we adapt the temporal difference methods from the RL literature (Sutton, 1988) to our setup. While RL methods with non-linear function approximators are not new (Tesauro, 1994; Miller et al., 1995), they have recently surged in popularity, giving rise to the field of ‘deep RL’ (Mnih et al., 2015). We show that some of the techniques recently developed in deep RL, such as having a target network, may also be beneficial for sequence prediction. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The contributions of the paper can be summarized as follows: 1) we describe how RL methodology like the actor-critic approach can be applied to supervised learning problems with structured outputs; and 2) we investigate the performance and behavior of the new method on both a synthetic task and a real-world task of machine translation, demonstrating the improvements over maximum-likelihood and REINFORCE brought by the actor-critic training. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            326,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider the problem of learning to produce an output sequence $Y = ( y _ { 1 } , \\dots , y _ { T } )$ , $y _ { t } \\in { \\mathcal { A } }$ given an input $X$ , where $\\mathcal { A }$ is the alphabet of output tokens. We will often use notation $Y _ { f \\ldots l }$ to refer to subsequences of the form $( y _ { f } , \\ldots , y _ { l } )$ . Two sets of input-output pairs $( X , Y )$ are assumed to be available for both training and testing. The trained predictor $h$ is evaluated by computing the average task-specific score $R ( { \\hat { Y } } , Y )$ on the test set, where ${ \\hat { Y } } = h ( X )$ is the prediction. To simplify the formulas we always use $T$ to denote the length of an output sequence, ignoring the fact that the output sequences may have different length. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            680
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks A recurrent neural network (RNN) produces a sequence of state vectors $( s _ { 1 } , \\ldots , s _ { T } )$ given a sequence of input vectors $( e _ { 1 } , \\dots , e _ { T } )$ by starting from an initial $s _ { 0 }$ state and applying $T$ times the transition function $f$ $\\vdots s _ { t } = f ( s _ { t - 1 } , e _ { t } )$ . Popular choices for the mapping $f$ are the Long Short-Term Memory (Hochreiter & Schmidhuber, 1997) and the Gated Recurrent Units (Cho et al., 2014), the latter of which we use for our models. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To build a probabilistic model for sequence generation with an RNN, one adds a stochastic output layer $g$ (typically a softmax for discrete outputs) that generates outputs $y _ { t } \\in \\mathcal A$ and can feed these outputs back by replacing them with their embedding $e ( y _ { t } )$ : ",
+        "bbox": [
+            174,
+            771,
+            825,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6224376036f238f0d7ba98edf48ad6d5e671a2b9dfad1a7741d68a6d294c6604.jpg",
+        "text": "$$\n\\begin{array} { r } { y _ { t } \\sim g ( s _ { t - 1 } ) } \\\\ { s _ { t } = f ( s _ { t - 1 } , e ( y _ { t } ) ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            819,
+            568,
+            857
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Thus, the RNN defines a probability distribution $p ( y _ { t } | y _ { 1 } , \\dots , y _ { t - 1 } )$ of the next output token $y _ { t }$ given the previous tokens $\\left( y _ { 1 } , \\ldots , y _ { t - 1 } \\right)$ . Upon adding a special end-of-sequence token $\\varnothing$ to the alphabet $\\mathcal { A }$ , the RNN can define the distribution $p ( Y )$ over all possible sequences as $p ( Y ) =$ $\\bar { p ( y _ { 1 } ) } p ( y _ { 2 } | y _ { 1 } ) \\ldots p ( y _ { T } | y _ { 1 } , \\ldots , y _ { T - 1 } ) p ( \\emptyset | y _ { 1 } , \\ldots , y _ { T } )$ . ",
+        "bbox": [
+            174,
+            867,
+            823,
+            925
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "RNNs for sequence prediction To use RNNs for sequence prediction, they must be augmented to generate $Y$ conditioned on an input $X$ . The simplest way to do this is to start with an initial state $s _ { 0 } = s _ { 0 } ( X )$ (Sutskever et al., 2014; Cho et al., 2014). Alternatively, one can encode $X$ as a variable-length sequence of vectors $( h _ { 1 } , \\ldots , h _ { L } )$ and condition the RNN on this sequence using an attention mechanism. In our models, the sequence of vectors is produced by either a bidirectional RNN (Schuster & Paliwal, 1997) or a convolutional encoder (Rush et al., 2015). ",
+        "bbox": [
+            174,
+            102,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use a soft attention mechanism (Bahdanau et al., 2015) that computes a weighted sum of a sequence of vectors. The attention weights determine the relative importance of each vector. More formally, we consider the following equations for RNNs with attention: ",
+        "bbox": [
+            174,
+            194,
+            825,
+            237
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49b7e71be18f5f57ae5b1ba7dcc98ebbc06ac657a1b61d8b4c2e301b30572c44.jpg",
+        "text": "$$\n\\begin{array} { r } { y _ { t } \\sim g ( s _ { t - 1 } , c _ { t - 1 } ) } \\\\ { s _ { t } = f ( s _ { t - 1 } , c _ { t - 1 } , e ( y _ { t } ) ) } \\\\ { \\alpha _ { t } = \\beta ( s _ { t } , ( h _ { 1 } , \\dots , h _ { L } ) ) } \\\\ { c _ { t } = \\displaystyle \\sum _ { j = 1 } ^ { L } \\alpha _ { t , j } h _ { j } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            253,
+            583,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta$ is the attention mechanism that produces the attention weights $\\alpha _ { t }$ and $c _ { t }$ is the context vector, or ‘glimpse’, for time step $t$ . The attention weights are computed by an MLP that takes as input the current RNN state and each individual vector to focus on. The weights are typically (as in our work) constrained to be positive and sum to 1 by using the softmax function. ",
+        "bbox": [
+            173,
+            371,
+            825,
+            428
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A conditioned RNN can be trained for sequence prediction by gradient ascent on the log-likelihood $\\log p ( { Y } | { X } )$ for the input-output pairs $( X , Y )$ from the training set. To produce a prediction $\\hat { Y }$ for a test input sequence $X$ , an approximate beam search for the maximum of $p ( \\cdot | X )$ is usually conducted. During this search the probabilities $p ( \\cdot | \\hat { y } _ { 1 } , \\dots , \\hat { y } _ { t - 1 } )$ are considered, where the previous tokens $\\hat { y } _ { 1 } , \\dotsc , \\hat { y } _ { t - 1 }$ comprise a candidate beginning of the prediction $\\hat { Y }$ . ",
+        "bbox": [
+            173,
+            433,
+            825,
+            508
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Value functions We view the conditioned RNN as a stochastic policy that generates actions and receives the task score (e.g., BLEU score) as the return. We furthermore consider the case when the return $R$ is partially received at the intermediate steps in the form of rewards $r _ { t }$ : $R ( { \\hat { Y } } , Y ) =$ $\\begin{array} { r } { \\sum _ { t = 1 } ^ { T } r _ { t } ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\dots t - 1 } , Y ) } \\end{array}$ . This is more general than the case of receiving the full return at the end of the sequence, as we can simply define all rewards other than $r _ { T }$ to be zero. Receiving intermediate rewards may ease the learning for the critic, and we use reward shaping as explained in Section 3. Given the policy, possible actions and reward function, the value represents the expected future return as a function of the current state of the system, which in our case is uniquely defined by the sequence of actions taken so far, $\\hat { Y } _ { 1 \\dots t - 1 }$ . ",
+        "bbox": [
+            173,
+            535,
+            826,
+            670
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define the value of an unfinished prediction $\\hat { Y } _ { 1 \\dots t }$ as follows: ",
+        "bbox": [
+            173,
+            675,
+            596,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7198623fabc7b759d93e0f8a5757e56f5905b7d8b2f8002646dccd907ab8e5b7.jpg",
+        "text": "$$\nV ( \\hat { Y } _ { 1 . . . t } ; X , Y ) = \\underset { \\hat { Y } _ { t + 1 . . . T } \\sim p ( \\cdot | \\hat { Y } _ { 1 . . . t } , X ) } { \\mathbb { E } } \\sum _ { \\tau = t + 1 } ^ { T } r _ { \\tau } ( \\hat { y } _ { \\tau } ; \\hat { Y } _ { 1 . . . \\tau - 1 } , Y ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            709,
+            712,
+            753
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define the value of a candidate next token $a$ for an unfinished prediction $\\hat { Y } _ { 1 \\dots t - 1 }$ as the expected future return after generating token $a$ : ",
+        "bbox": [
+            174,
+            773,
+            826,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62c5a5a99b3cfb59f4f7a71c687b553c2bd9b07502c5a83c628b394628da7ae5.jpg",
+        "text": "$$\n\\langle \\hat { Y } _ { 1 \\dots t - 1 } , X , Y \\rangle = \\underset { \\hat { Y } _ { t + 1 \\dots T } \\sim p ( \\cdot \\vert \\hat { Y } _ { 1 \\dots t - 1 } , a , X ) } { \\mathbb { E } } \\left( r _ { t } ( a ; \\hat { Y } _ { 1 \\dots t - 1 } , Y ) + \\underset { \\tau = t + 1 } { \\overset { T } { \\sum } } r _ { \\tau } ( \\hat { y } _ { \\tau } ; \\hat { Y } _ { 1 \\dots t - 1 } a \\hat { Y } _ { t + 1 \\dots \\tau } , Y ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            202,
+            819,
+            861,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We will refer to the candidate next tokens as actions. For notational simplicity, we henceforth drop $X$ and $Y$ from the signature of $p$ , $V$ , $Q$ , $R$ and $r _ { t }$ , assuming it is clear from the context which of $X$ and $Y$ is meant. We will also use $V$ without arguments for the expected reward of a random prediction. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Actor-Critic Training for Sequence Prediction ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            164,
+            565,
+            179
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Require: A critic $\\hat { Q } ( a ; \\hat { Y } _ { 1 \\dots t } , Y )$ and an actor $\\boldsymbol { p } ( \\boldsymbol { a } | \\hat { Y } _ { 1 \\ldots t } , \\boldsymbol { X } )$ with weights $\\phi$ and $\\theta$ respectively. ",
+        "bbox": [
+            176,
+            183,
+            799,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize delayed actor $p$ and target critic $\\hat { Q } ^ { \\prime }$ with same weights: $\\theta ^ { \\prime } = \\theta$ , $\\phi ^ { \\prime } = \\phi$ .   \n2: while Not Converged do   \n3: Receive a random example $( X , Y )$ .   \n4: Generate a sequence of actions $\\hat { Y }$ from $p ^ { ' }$ .   \n5: Compute targets for the critic ",
+        "bbox": [
+            179,
+            202,
+            738,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5a005067bcfb021e613e02b79b32e0d8f70658c1cde2af41f8ad8b83f1556cf7.jpg",
+        "text": "$$\nq _ { t } = r _ { t } ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\dots t - 1 } , Y ) + \\sum _ { a \\in \\cal A } p ^ { ' } ( a | \\hat { Y } _ { 1 \\dots t } , X ) \\hat { Q } ^ { \\prime } ( a ; \\hat { Y } _ { 1 \\dots t } , Y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            280,
+            720,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "6: Update the critic weights $\\phi$ using the gradient ",
+        "bbox": [
+            181,
+            325,
+            519,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bbfc857df3188dc31f3f62d863c68384ecb482e17189676b34c06f1a0b31b65f.jpg",
+        "text": "$$\n\\begin{array} { r } { \\displaystyle \\frac { d } { d \\phi } \\left( \\displaystyle \\sum _ { t = 1 } ^ { T } \\left( \\hat { Q } ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\dots t - 1 } , Y ) - q _ { t } \\right) ^ { 2 } + \\lambda _ { C } C _ { t } \\right) } \\\\ { \\mathrm { ~ w h e r e ~ } C _ { t } = \\displaystyle \\sum _ { a } \\left( \\hat { Q } ( a ; \\hat { Y } _ { 1 \\dots t - 1 } ) - \\frac { 1 } { | A | } \\sum _ { b } \\hat { Q } ( b ; \\hat { Y } _ { 1 \\dots t - 1 } ) \\right) ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            347,
+            722,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "7: Update actor weights $\\theta$ using the following gradient estimate ",
+        "bbox": [
+            179,
+            446,
+            617,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c59d46198aa4eac766f88aadfddd693b1f3df90bd63b9da35df80cd6b3d2c62.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\frac { d \\widehat { V ( X , Y ) } } { d \\theta } = \\displaystyle \\sum _ { t = 1 } ^ { T } \\sum _ { a \\in \\mathcal { A } } \\frac { d p ( a | \\hat { Y } _ { 1 \\ldots t - 1 } , X ) } { d \\theta } \\hat { Q } ( a ; \\hat { Y } _ { 1 \\ldots t - 1 } , Y ) } \\\\ & { \\quad \\quad \\quad + \\lambda _ { L L } \\displaystyle \\sum _ { t = 1 } ^ { T } \\frac { d p ( y _ { t } | Y _ { 1 \\ldots t - 1 } , X ) } { d \\theta } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            468,
+            714,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "8: Update delayed actor and target critic, with constants $\\gamma _ { \\theta } \\ll 1$ , $\\gamma _ { \\phi } \\ll 1$ ",
+        "bbox": [
+            179,
+            568,
+            679,
+            584
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9e8bb27ad65c7f48e9125397a71a2698d45b65d1322bbce2f67e7eaac42bcfa.jpg",
+        "text": "$$\n\\theta ^ { \\prime } = \\gamma _ { \\theta } \\theta + ( 1 - \\gamma _ { \\theta } ) \\theta ^ { \\prime } , \\phi ^ { \\prime } = \\gamma _ { \\phi } \\phi + ( 1 - \\gamma _ { \\phi } ) \\phi ^ { \\prime }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            588,
+            679,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "9: end while ",
+        "bbox": [
+            179,
+            613,
+            271,
+            627
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Complete Actor-Critic Algorithm for Sequence Prediction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            643,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize critic $\\hat { Q } ( a ; \\hat { Y } _ { 1 \\ldots t } , Y )$ and actor $\\boldsymbol { p } ( \\boldsymbol { a } | \\hat { Y } _ { 1 \\ldots t } , \\boldsymbol { X } )$ with random weights $\\phi$ and $\\theta$ respectively.   \n2: Pre-train the actor to predict $y _ { t + 1 }$ given $Y _ { 1 \\dots t }$ by maximizing $\\log p ( y _ { t + 1 } | Y _ { 1 \\dots t } , X )$ .   \n3: Pre-train the critic to estimate $Q$ by running Algorithm 1 with fixed actor.   \n4: Run Algorithm 1. ",
+        "bbox": [
+            179,
+            782,
+            826,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 ACTOR-CRITIC FOR SEQUENCE PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            578,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $\\theta$ be the parameters of the conditioned RNN, which we will also refer to as the actor. Our training algorithm is based on the following way of rewriting the gradient of the expected return $\\textstyle { \\frac { d V } { d \\theta } }$ : ",
+        "bbox": [
+            173,
+            132,
+            825,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29ae4e03b558f8805cdb3b7bf3a22cd45650e67cb838344515765bcbe99b57d4.jpg",
+        "text": "$$\n\\frac { d V } { d \\theta } = \\underset { \\hat { Y } \\sim p ( \\hat { Y } | X ) } { \\mathbb { E } } \\sum _ { t = 1 } ^ { T } \\sum _ { a \\in \\mathcal { A } } \\frac { d p ( a | \\hat { Y } _ { 1 \\dots t - 1 } ) } { d \\theta } Q ( a ; \\hat { Y } _ { 1 \\dots t - 1 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            167,
+            681,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This equality is known in RL under the names policy gradient theorem (Sutton et al., 1999) and stochastic actor-critic (Sutton, 1984). 1 Note that we use the probability rather than the log probability in this formula (which is more typical in RL applications) as we are summing over actions rather than taking an expectation. Intuitively, this equality corresponds to increasing the probability of actions that give high values, and decreasing the probability of actions that give low values. Since this gradient expression is an expectation, it is trivial to build an unbiased estimate for it: ",
+        "bbox": [
+            173,
+            217,
+            826,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43d16b301c41b5eeac6cf04b4586b49699e493ab998116ec3d65a9e2f57fdab7.jpg",
+        "text": "$$\n\\widehat { \\frac { d V } { d \\theta } } = \\sum _ { k = 1 } ^ { M } \\sum _ { t = 1 } ^ { T } \\sum _ { a \\in \\mathcal { A } } \\frac { d p ( a | \\hat { Y } _ { 1 \\ldots t - 1 } ^ { k } ) } { d \\theta } Q ( a ; \\hat { Y } _ { 1 \\ldots t - 1 } ^ { k } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            305,
+            658,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\hat { Y } } ^ { k }$ are $M$ random samples from $p ( \\hat { Y } )$ . By replacing $Q$ with a parameteric estimate $\\hat { Q }$ one can obtain a biased estimate with relatively low variance. The parameteric estimate $\\hat { Q }$ is called the critic. ",
+        "bbox": [
+            176,
+            356,
+            823,
+            388
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The above formula is similar in spirit to the REINFORCE learning rule that Ranzato et al. (2015) use in the same context: ",
+        "bbox": [
+            174,
+            393,
+            825,
+            422
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5d10e3f1eca12595c812e4e5d6af6ecb1a000cb7babdfdc3bd78131ddfcf9db.jpg",
+        "text": "$$\n\\widehat { \\frac { d V } { d \\theta } } = \\sum _ { k = 1 } ^ { M } \\sum _ { t = 1 } ^ { T } \\frac { d \\log p ( \\hat { y } _ { t } ^ { k } | \\hat { Y } _ { 1 . . . t - 1 } ^ { k } ) } { d \\theta } \\left[ \\sum _ { \\tau = t } ^ { T } r _ { \\tau } ( \\hat { y } _ { \\tau } ^ { k } ; \\hat { Y } _ { 1 . . . \\tau - 1 } ^ { k } ) - b _ { t } ( X ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            425,
+            723,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the scalar $b _ { t } ( X )$ is called baseline or control variate. The difference is that in REINFORCE the inner sum over all actions is replaced by its 1-sample estimate, namely $\\frac { d \\log p ( \\hat { y } _ { t } | \\hat { Y } _ { 1 \\dots t - 1 } ) } { d \\theta } Q ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\dots t - 1 } )$ , where the log probability $\\begin{array} { r } { \\frac { d \\log p ( \\hat { y } _ { t } | \\ldots ) } { d \\theta } = \\frac { 1 } { p ( \\hat { y } _ { t } | \\ldots ) } \\frac { d p ( \\hat { y } _ { t } | \\ldots ) } { d \\theta } } \\end{array}$ dp(ˆyt|...) is introduced to correct for the sampling of $\\hat { y } _ { t }$ . Furthermore, instead of the value $Q ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\dots t - 1 } )$ , REINFORCE uses the cumulative reward $\\begin{array} { r } { \\sum _ { \\tau = t } ^ { T } r _ { \\tau } \\big ( \\hat { y } _ { \\tau } ; \\hat { Y } _ { 1 \\dots \\tau - 1 } \\big ) } \\end{array}$ following the action $\\hat { y } _ { t }$ , which again can be seen as a 1-sample estimate of $Q$ . Due to these simplifications and the potential high variance in the cumulative reward, the REINFORCE gradient estimator has very high variance. In order to improve upon it, we consider the actor-critic estimate from Equation 8, which has a lower variance at the cost of significant bias, since the critic is not perfect and trained simultaneously with the actor. The success depends on our ability to control the bias by designing the critic network and using an appropriate training criterion for it. ",
+        "bbox": [
+            173,
+            473,
+            826,
+            641
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To implement the critic, we propose to use a separate RNN parameterized by $\\phi$ . The critic RNN is run in parallel with the actor, consumes the tokens $\\hat { y } _ { t }$ that the actor outputs and produces the estimates $\\hat { Q } ( a ; \\hat { Y } _ { 1 \\dots t } )$ for all $a \\in { \\mathcal { A } }$ . A key difference between the critic and the actor is that the correct answer $Y$ is given to the critic as an input, similarly to how the actor is conditioned on $X$ . Indeed, the return $R ( { \\hat { Y } } , Y )$ is a deterministic function of $Y$ , and we argue that using $Y$ to compute $\\hat { Q }$ should be of great help. We can do this because the values are only required during training and we do not use the critic at test time. We also experimented with providing the actor states $s _ { t }$ as additional inputs to the critic. See Figure 1 for a visual representation of our actor-critic architecture. ",
+        "bbox": [
+            173,
+            647,
+            826,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Temporal-difference learning A crucial component of our approach is policy evaluation, that is the training of the critic to produce useful estimates of $\\hat { Q }$ . With a na¨ıve Monte-Carlo method, one could use the future return $\\begin{array} { r } { \\sum _ { \\tau = t } ^ { T } r _ { \\tau } \\big ( \\hat { y } _ { \\tau } ; \\hat { Y } _ { 1 \\dots \\tau - 1 } \\big ) } \\end{array}$ as a target to $\\hat { Q } ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\dots t - 1 } )$ , and use the critic parameters $\\phi$ to minimize the square error between these two values. However, like with REINFORCE, using such a target yields to very high variance which quickly grows with the number of steps $T$ . We use a temporal difference (TD) method for policy evaluation (Sutton, 1988). Namely, we use the right-hand side $\\begin{array} { r } { q _ { t } = r _ { t } ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\dots t - 1 } ) + \\sum _ { a \\in A } p ( a | \\hat { Y } _ { 1 \\dots t } ) \\hat { Q } ( a ; \\hat { Y } _ { 1 \\dots t } ) } \\end{array}$ of the Bellman equation as the target for the left-hand $\\hat { Q } ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\dots t - 1 } )$ . ",
+        "bbox": [
+            173,
+            777,
+            826,
+            901
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc09049fb7515d82206802c88aaa6163ac07adcd4214ab8715fbcd872b64cd51.jpg",
+        "text": "$$\n\\underbrace { \\overbrace { \\underbrace { \\left( \\begin{array} { l } { { \\mathrm {  ~ { \\cal ~ E } ~ } } \\mathrm { { c o c r } ~ } } \\mathrm { { p } } _ { \\theta } \\right)} ^ { \\mathrm { A c t o r } { \\mathrm {  ~ { \\cal ~ p } } } _ { \\theta } } } \\\\ { \\mathrm {  ~ { \\cal ~ E } ~ } \\mathrm { { c o d e r } ~ } } \\end{array}  } _ { \\mathrm {  ~ { \\scriptstyle ~ \\underbrace { \\hat { \\underbrace {  ~ \\psi } ~ } } ~ } , ~ \\hat { \\psi } _ { 1 } , ~ \\hat { y } _ { 2 } , \\cdots ~ , ~ \\hat { y } _ { T } } } \\underbrace { \\overbrace { \\mathrm {  ~ { \\cal ~ E } ~ } \\mathrm { { r i t } } \\mathrm { { i } } { \\mathrm { c } } ~ { \\cal { Q } } _ { \\phi } } ^ { \\mathrm { C r i t i c } ~ { \\cal { Q } } _ { \\phi } } } _ { \\mathrm {  ~ { \\scriptstyle ~ \\in ~ { c o d e r } ~ } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            101,
+            700,
+            203
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "",
+        "image_caption": [
+            "Figure 1: Both the actor and the critic are encoder-decoder networks. The actor receives an input sequence $X$ and produces samples $\\hat { Y }$ which are evaluated by the critic. The critic takes in the ground-truth sequence $Y$ as input to the encoder, and takes the input summary (calculated using an attention mechanism) and the actor’s prediction $\\hat { y } _ { t }$ as input at time step $t$ of the decoder. The values $Q _ { 1 } , Q _ { 2 } , \\cdots , Q _ { T }$ computed by the critic are used to approximate the gradient of the expected returns with respect to the parameters of the actor. This gradient is used to train the actor to optimize these expected task specific returns (e.g., BLEU score). The critic may also receive the hidden state activations of the actor as input. "
+        ],
+        "image_footnote": [],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Applying deep RL techniques It has been shown in the RL literature that if $\\hat { Q }$ is non-linear (like in our case), the TD policy evaluation might diverge (Tsitsiklis & Van Roy, 1997). Previous work has shown that this problem can be alleviated by using an additional target network $\\hat { Q } ^ { \\prime }$ to compute $q _ { t }$ , which is updated less often and/or more slowly than $\\hat { Q }$ . Similarly to (Lillicrap et al., 2015), we update the parameters $\\phi ^ { \\prime }$ of the target critic by linearly interpolating them with the parameters of the trained one. Attempts to remove the target network by propagating the gradient through $q _ { t }$ resulted in a lower square error $( \\hat { Q } ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\dots T } ) - q _ { t } ) ^ { 2 }$ , but the resulting $\\hat { Q }$ values proved very unreliable as training signals for the actor. ",
+        "bbox": [
+            173,
+            354,
+            825,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The fact that both actor and critic use outputs of each other for training creates a potentially dangerous feedback loop. To address this, we sample predictions from a delayed actor (Lillicrap et al., 2015), whose weights are slowly updated to follow the actor that is actually trained. ",
+        "bbox": [
+            176,
+            479,
+            823,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dealing with large action spaces One of the challenges of our work is that the action space is very large (as is typically the case in NLP tasks with large vocabularies). This can be alleviated by putting constraints on the critic values for actions that are rarely sampled. We found experimentally that shrinking the values of these rare actions is necessary for the algorithm to converge. Specifically, we add a term $C _ { t }$ for every step $t$ to the critic’s optimization objective which drives all value predictions of the critic closer to their mean: ",
+        "bbox": [
+            173,
+            536,
+            825,
+            619
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2272604cb6856c5586a37e827e13a3c26a17d50e0f606526ef0e38201b46b1ad.jpg",
+        "text": "$$\nC _ { t } = \\sum _ { a } \\left( \\hat { Q } ( a ; \\hat { Y } _ { 1 \\ldots t - 1 } ) - \\frac { 1 } { | A | } \\sum _ { b } \\hat { Q } ( b ; \\hat { Y } _ { 1 \\ldots t - 1 } ) \\right) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            623,
+            676,
+            667
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This corresponds to penalizing the variance of the outputs of the critic. Without this penalty the values of rare actions can be severely overestimated, which biases the gradient estimates and can cause divergence. A similar trick was used in the context of learning simple algorithms with Q-learning (Zaremba et al., 2015). ",
+        "bbox": [
+            173,
+            672,
+            825,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Reward shaping While we are ultimately interested in the maximization of the score of a complete prediction, simply awarding this score at the last step provides a very sparse training signal for the critic. For this reason we use potential-based reward shaping with potentials $\\Phi ( { \\hat { Y } } _ { 1 \\dots t } ) = R ( { \\hat { Y } } _ { 1 \\dots t } )$ for incomplete sequences and $\\hat { \\Phi } ( \\hat { Y } ) = 0$ for complete ones ( $\\mathrm { N g }$ et al., 1999). Namely, for a predicted sequence $\\hat { Y }$ we compute score values for all prefixes to obtain the sequence of scores $( R ( \\hat { Y } _ { 1 \\dots 1 } ) , \\bar { R ( Y _ { 1 \\dots 2 } ) } , \\dots , R ( \\hat { Y } _ { 1 \\dots T } ) )$ . The difference between the consecutive pairs of scores is then used as the reward at each step: $r _ { t } ( \\hat { y } _ { t } ; \\hat { Y } _ { 1 \\ldots t - 1 } ) = R ( \\hat { Y } _ { 1 \\ldots t } ) - R ( \\hat { Y } _ { 1 \\ldots t - 1 } )$ . Using the shaped reward $r _ { t }$ instead of awarding the whole score $R$ at the last step does not change the optimal policy $\\mathrm { N g }$ et al., 1999). ",
+        "bbox": [
+            173,
+            742,
+            826,
+            881
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Putting it all together Algorithm 1 describes the proposed method in detail. We consider adding the weighted log-likelihood gradient to the actor’s gradient estimate. This is in line with the prior work by (Ranzato et al., 2015) and (Shen et al., 2015). It is also motivated by our preliminary experiments that showed that using the actor-critic estimate alone can lead to an early determinization of the policy and vanishing gradients (also discussed in Section 6). Starting training with a randomly initialized actor and critic would be problematic, because neither the actor nor the critic would provide adequate training signals for one another. The actor would sample completely random predictions that receive very little reward, thus providing a very weak training signal for the critic. A random critic would be similarly useless for training the actor. Motivated by these considerations, we pre-train the actor using standard log-likelihood training. Furthermore, we pre-train the critic by feeding it samples from the pre-trained actor, while the actor’s parameters are frozen. The complete training procedure including pre-training is described by Algorithm 2. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            266,
+            344,
+            282
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In other recent RL-inspired work on sequence prediction, Ranzato et al. (2015) trained a translation model by gradually transitioning from maximum likelihood learning into optimizing BLEU or ROUGE scores using the REINFORCE algorithm. However, REINFORCE is known to have very high variance and does not exploit the availability of the ground-truth like the critic network does. The approach also relies on a curriculum learning scheme. Standard value-based RL algorithms like SARSA and OLPOMDP have also been applied to structured prediction (Maes et al., 2009). Again, these systems do not use the ground-truth for value prediction. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Imitation learning has also been applied to structured prediction (Vlachos, 2012). Methods of this type include the SEARN (Daume Iii et al., 2009) and ´ DAGGER (Ross et al., 2010) algorithms. These methods rely on an expert policy to provide action sequences that the policy learns to imitate. Unfortunately, it’s not always easy or even possible to construct an expert policy for a task-specific score. In our approach, the critic plays a role that is similar to the expert policy, but is learned without requiring prior knowledge about the task-specific score. The recently proposed ‘scheduled sampling’ (Bengio et al., 2015) can also be seen as imitation learning. In this method, ground-truth tokens are occasionally replaced by samples from the model itself during training. A limitation is that the token $k$ for the ground-truth answer is used as the target at step $k$ , which might not always be the optimal strategy. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            544
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There are also approaches that aim to approximate the gradient of the expected score. One such approach is ‘Direct Loss Minimization’ (Hazan et al., 2010) in which the inference procedure is adapted to take both the model likelihood and task-specific score into account. Another popular approach is to replace the domain over which the task score expectation is defined with a small subset of it, as is done in Minimum (Bayes) Risk Training (Goel & Byrne, 2000; Shen et al., 2015; Och, 2003). This small subset is typically an $n$ -best list or a sample (like in REINFORCE) that may or may not include the ground-truth as well. None of these methods provide intermediate targets for the actor during training, and Shen et al. (2015) report that as many as 100 samples were required for the best results. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            675
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another recently proposed method is to optimize a global sequence cost with respect to the selection and pruning behavior of the beam search procedure itself (Wiseman & Rush, 2016). This method follows the more general strategy called ‘learning as search optimization’ (Daume III & Marcu, 2005). ´ This is an interesting alternative to our approach; however, it is designed specifically for the precise inference procedure involved. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            752
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            776,
+            326,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To validate our approach, we performed two sets of experiments 2. First, we trained the proposed model to recover strings of natural text from their corrupted versions. Specifically, we consider each character in a natural language corpus and with some probability replace it with a random character. We call this synthetic task spelling correction. A desirable property of this synthetic task is that data is essentially infinite and overfitting is no concern. Our second series of experiments is done on the task of automatic machine translation using different models and datasets. ",
+        "bbox": [
+            174,
+            809,
+            825,
+            893
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In addition to maximum likelihood and actor-critic training we implemented two versions of the REINFORCE gradient estimator. In the first version, we use a linear baseline network that takes the actor states as input, exactly as in (Ranzato et al., 2015). We also propose a novel extension of REINFORCE that leverages the extra information available in the ground-truth output $Y$ . Specifically, we use the $\\hat { Q }$ estimates produced by the critic network as the baseline for the REINFORCE algorithm. The motivation behind this approach is that using the ground-truth output should produce a better baseline that lowers the variance of REINFORCE, resulting in higher task-specific scores. We refer to this method as REINFORCE-critic. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            217
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 SPELLING CORRECTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            237,
+            382,
+            251
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use text from the One Billion Word dataset for the spelling correction task (Chelba et al., 2013), which has pre-defined training and testing sets. The training data was abundant, and we never used any example twice. We evaluate trained models on a section of the test data that comprises 6075 sentences. To speed up experiments, we clipped all sentences to the first 10 or 30 characters. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            320
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the spelling correction actor network, we use an RNN with 100 Gated Recurrent Units (GRU) and a bidirectional GRU network for the encoder. We use the same attention mechanism as proposed in (Bahdanau et al., 2015), which effectively makes our actor network a smaller version of the model used in that work. For the critic network, we employed a model with the same architecture as the actor. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            397
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use character error rate (CER) to measure performance on the spelling task, which we define as the ratio between the total of Levenshtein distances between predictions and ground-truth outputs and the total length of the ground-truth outputs. This is a corpus-level metric for which a lower value is better. We use it as the return by negating per-sentence ratios. At the evaluation time greedy search is used to extract predictions from the model. ",
+        "bbox": [
+            173,
+            404,
+            825,
+            473
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use the ADAM optimizer (Kingma & Ba, 2015) to train all the networks with the parameters recommended in the original paper, with the exception of the scale parameter $\\alpha$ . The latter is first set to $1 0 ^ { - 3 }$ and then annealed to $1 0 ^ { - 4 }$ for log-likelihood training. For the pre-training stage of the actor-critic, we use $\\alpha \\stackrel { - } { = } 1 0 ^ { - 3 }$ and decrease it to $1 0 ^ { - 4 }$ for the joint actor-critic training. We pretrain the actor until its score on the development set stops improving. We pretrain the critic until its TD error stabilizes3. We used $M = 1$ sample for both actor-critic and REINFORCE. For exact hyperparameter settings we refer the reader to Appendix A. ",
+        "bbox": [
+            174,
+            481,
+            485,
+            675
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We start REINFORCE training from a pretrained actor, but we do not use the curriculum learning employed in MIXER. The critic is trained in the same way for both REINFORCE and actorcritic, including the pretraining stage. We report results obtained with the reward shaping described in Section 3, as we found that it slightly improves REINFORCE performance. ",
+        "bbox": [
+            174,
+            683,
+            485,
+            794
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1 presents our results on the spelling correction task. We observe an improvement in CER over log-likelihood training for all four settings considered. Without simultaneous loglikelihood training, actor-critic training results in a better CER than REINFORCE-critic in three ",
+        "bbox": [
+            174,
+            801,
+            483,
+            883
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/460c085511c4b0dfbef2c0396b6671eaf4b5021d48d37b120350a5315592f68a.jpg",
+        "image_caption": [
+            "Figure 2: Progress of log-likelihood (LL), REINFORCE (RF) and actor-critic (AC) training in terms of BLEU score on the training (train) and validation (valid) datasets. $\\mathrm { L L ^ { * } }$ stands for the annealing phase of log-likelihood training. The curves start from the epoch of log-likelihood pretraining from which the parameters were initialized. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            502,
+            810,
+            737
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/148d984576a5c1164216cb9e9a36dc7fd9d9768b4439ff3cdb8350a80b114c27.jpg",
+        "table_caption": [
+            "Table 1: Character error rate of different methods on the spelling correction task. In the table $L$ is the length of input strings, $\\eta$ is the probability of replacing a character with a random one. LL stands for the log-likelihood training, AC and RF-C and for the actor-critic and the REINFORCE-critic respectively, $\\mathrm { \\ A C + L L }$ and RF- $\\mathrm { { C + L L } }$ for the combinations of AC and RF-C with LL. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Setup</td><td colspan=\"5\">CharacterErrorRate</td></tr><tr><td>LL</td><td>AC</td><td>RF-C</td><td>AC+LL</td><td>RF-C+LL</td></tr><tr><td>L=10,n=0.3</td><td>17.81</td><td>17.24</td><td>17.82</td><td>16.65</td><td>16.97</td></tr><tr><td>L =30,n = 0.3</td><td>18.4</td><td>17.31</td><td>18.16</td><td>17.1</td><td>17.47</td></tr><tr><td>L = 10,n = 0.5</td><td>38.12</td><td>35.89</td><td>35.84</td><td>34.6</td><td>35</td></tr><tr><td>L = 30,n = 0.5</td><td>40.87</td><td>37.0</td><td>37.6</td><td>36.36</td><td>36.6</td></tr></table>",
+        "bbox": [
+            267,
+            167,
+            723,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/7de197cdfdb461981152aca71495394ec8c0468d97ed574bc3dde847628fdd2e.jpg",
+        "table_caption": [
+            "Table 2: Our IWSLT 2014 machine translation results with a convolutional encoder compared to the previous work by Ranzato et al. Please see 1 for an explanation of abbreviations. The asterisk identifies results from (Ranzato et al., 2015). The numbers reported with $\\leq$ were approximately read from Figure 6 of (Ranzato et al., 2015) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Decoding method</td><td colspan=\"6\">Model</td></tr><tr><td>LL*</td><td>MIXER*</td><td>LL</td><td>RF</td><td>RF-C</td><td>AC</td></tr><tr><td>greedy search</td><td>17.74</td><td>20.73</td><td>19.33</td><td>20.92</td><td>22.24</td><td>21.66</td></tr><tr><td>beam search</td><td>≤20.3</td><td>≤ 21.9</td><td>21.46</td><td>21.35</td><td>22.58</td><td>22.45</td></tr></table>",
+        "bbox": [
+            243,
+            338,
+            751,
+            400
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "out of four settings. In the fourth case, actor-critic and REINFORCE-critic have similar performance. Adding the log-likelihood gradient with a cofficient $\\lambda _ { L L } = 0 . 1$ helps both of the methods, but actor-critic still retains a margin of improvement over REINFORCE-critic. ",
+        "bbox": [
+            176,
+            426,
+            825,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 MACHINE TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            488,
+            388,
+            502
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For our first translation experiment, we use data from the German-English machine translation track of the IWSLT 2014 evaluation campaign (Cettolo et al., 2014), as used in Ranzato et al. (2015), and closely follow the pre-processing described in that work. The training data comprises about 153,000 German-English sentence pairs. In addition we considered a larger WMT14 English-French dataset Cho et al. (2014) with more than 12 million examples. For further information about the data we refer the reader to Appendix B. ",
+        "bbox": [
+            173,
+            515,
+            825,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The return is defined as a smoothed and rescaled version of the BLEU score. Specifically, we start all n-gram counts from 1 instead of 0, and multiply the resulting score by the length of the ground-truth translation. Smoothing is a common practice when sentence-level BLEU score is considered, and it has been used to apply REINFORCE in similar settings (Ranzato et al., 2015). ",
+        "bbox": [
+            174,
+            606,
+            825,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "IWSLT 2014 with a convolutional encoder In our first experiment we use a convolutional encoder in the actor to make our results more comparable with Ranzato et al. (2015). For the same reason, we use 256 hidden units in the networks. For the critic, we replaced the convolutional network with a bidirectional GRU network. For training this model we mostly used the same hyperparameter values as in the spelling correction experiments, with a few differences highlighted in Appendix A. For decoding we used greedy search and beam search with a beam size of 10. We found that penalizing candidate sentences that are too short was required to obtain the best results. Similarly to (Hannun et al., 2014), we subtracted $\\rho T$ from the negative log-likelihood of each candidate sentence, where $T$ is the candidate’s length, and $\\rho$ is a hyperparameter tuned on the validation set. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results are summarized in Table 2. We report a significant improvement of 2.3 BLEU points over the log-likelihood baseline when greedy search is used for decoding. Surprisingly, the best performing method is REINFORCE with critic, with an additional 0.6 BLEU point advantage over the actor-critic. When beam-search is used, the ranking of the compared approaches is the same, but the margin between the proposed methods and log-likelihood training becomes smaller. The final performances of the actor-critic and the REINFORCE-critic with greedy search are also 0.7 and 1.3 BLEU points respectively better than what Ranzato et al. (2015) report for their MIXER approach. This comparison should be treated with caution, because our log-likelihood baseline is 1.6 BLEU points stronger than its equivalent from (Ranzato et al., 2015). The performance of REINFORCE with a simple baseline matches the score reported for MIXER in Ranzato et al. (2015). ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/7dec7dd6ab1680842f4007df91ec66adba49a9a8cdb56839213e15a001031415.jpg",
+        "table_caption": [
+            "Table 3: Our IWSLT 2014 machine translation results with a bidirectional recurrent encoder compared to the previous work. Please see Table 1 for an explanation of abbreviations. The asterisk identifies results from (Wiseman & Rush, 2016). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Decoding method</td><td colspan=\"7\">Model</td></tr><tr><td>LL*</td><td>BSO*</td><td>LL</td><td>RF-C</td><td>RF-C+LL</td><td>AC</td><td>AC+LL</td></tr><tr><td>greedy search</td><td>22.53</td><td>23.83</td><td>25.82</td><td>27.42</td><td>27.7</td><td>27.27</td><td>27.49</td></tr><tr><td>beam search</td><td>23.87</td><td>25.48</td><td>27.56</td><td>27.75</td><td>28.3</td><td>27.75</td><td>28.53</td></tr></table>",
+        "bbox": [
+            207,
+            154,
+            787,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/2db4caafa08b908106452da4da45993516cba39f0b30d0d7a5552d40a860819a.jpg",
+        "table_caption": [
+            "Table 4: Our WMT 14 machine translation results compared to the previous work. Please see Table 1 for an explanation of abbreviations. The apostrophy and the asterisk identify results from (Bahdanau et al., 2015) and (Shen et al., 2015) respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Decoding method</td><td colspan=\"6\">Model</td></tr><tr><td>LL&#x27;</td><td>LL*</td><td>MRT *</td><td>LL</td><td>AC+LL</td><td>RF-C+LL</td></tr><tr><td>greedy search beam search</td><td>n/a 28.45</td><td>n/a 29.88</td><td>n/a 31.3</td><td>29.33 30.71</td><td>30.85 31.13</td><td>29.83 30.37</td></tr></table>",
+        "bbox": [
+            233,
+            292,
+            761,
+            354
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            390,
+            823,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To better understand the IWSLT 2014 results we provide the learning curves for the considered approaches in Figure 2. We can clearly see that the training methods that use generated predictions have a strong regularization effect — that is, better progress on the validation set in exchange for slower or negative progress on the training set. The effect is stronger for both REINFORCE varieties, especially for the one without a critic. The actor-critic training does a much better job of fitting the training set than REINFORCE and is the only method except log-likelihood that shows a clear overfitting, which is a healthy behaviour for such a small dataset. ",
+        "bbox": [
+            173,
+            425,
+            825,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In addition, we performed an ablation study. We found that using a target network was crucial; while the joint actor-critic training was still progressing with $\\gamma _ { \\theta } = 0 . 1$ , with $\\gamma _ { \\theta } = 1 . 0$ it did not work at all. Similarly important was the value penalty described in Equation (10). We found that good values of the $\\lambda$ coefficient were in the range $[ 1 0 ^ { \\dot { - } 3 } , 1 0 ^ { - 6 } ]$ . Other techniques, such as reward shaping and a delayed actor, brought moderate performance gains. We refer the reader to Appendix A for more details. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            614
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "IWSLT 2014 with a bidirectional GRU encoder In order to compare our results with those reported by Wiseman & Rush (2016) we repeated our IWSLT 2014 investigation with a different encoder, a bidirectional RNN with 256 GRU units. In this round of experiments we also tried to used combined training objectives in the same way as in our spelling correction experiments. The results are summarized in Table 3. One can see that the actor-critic training, especially its $\\mathrm { \\ A C + L L }$ version, yields significant improvements (1.7 with greedy search and 1.0 with beam search) upon the pure log-likelihood training, which are comparable to those brought by Beam Search Optimization (BSO), even though our log-likelihood baseline is much stronger. In this round of experiments actor-critic and REINFORCE-critic performed on par. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            770
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "WMT 14 Finally we report our results on a very popular large WMT14 English-French dataset (Cho et al., 2014) in Table 4. Our model closely follows the achitecture from (Bahdanau et al., 2015), however we achieved a higher baseline performance by annealing the learning rate $\\alpha$ and penalizing output sequences that were too short during beam search. The actor-critic training brings a significant 1.5 BLEU improvement with greedy search and a noticeable 0.4 BLEU improvement with beam search. In previous work Shen et al. (2015) report a higher improvement of 1.4 BLEU with beam search, however they use 100 samples for each training example, whereas we use just one. We note that in this experiment, which is perhaps the most realistic settings, the actor-critic enjoys a significant advantage over the REINFORCE-critic. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            310,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We proposed an actor-critic approach to sequence prediction. Our method takes the task objective into account during training and uses the ground-truth output to aid the critic in its prediction of intermediate targets for the actor. We showed that our method leads to significant improvements over maximum likelihood training on both a synthetic task and a machine translation benchmark. Compared to REINFORCE training on machine translation, actor-critic fits the training data much faster, although in some of our experiments we were able to significantly reduce the gap in the training speed and achieve a better test error using our critic network as the baseline for REINFORCE. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            229
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "One interesting observation we made from the machine translation results is that the training methods that use generated predictions have a strong regularization effect. Our understanding is that conditioning on the sampled outputs effectively increases the diversity of training data. This phenomenon makes it harder to judge whether the actor-critic training meets our expectations, because a noisier gradient estimate yielded a better test set performance. We argue that the spelling correction results obtained on a virtually infinite dataset in conjuction with better machine translation performance on the large WMT 14 dataset provide convincing evidence that the actor-training can be effective. In future work we will consider larger machine translation datasets. ",
+        "bbox": [
+            174,
+            237,
+            825,
+            348
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We ran into several optimization issues. The critic would sometimes assign very high values to actions with a very low probability according to the actor. We were able to resolve this by penalizing the critic’s variance. Additionally, the actor would sometimes have trouble to adapt to the demands of the critic. We noticed that the action distribution tends to saturate and become deterministic, causing the gradient to vanish. We found that combining an RL training objective with log-likelihood can help, but in general we think this issue deserves further investigation. For example, one can look for suitable training criteria that have a well-behaved gradient even when the policy has little or no stochasticity. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            467
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In a concurrent work Wu et al. (2016) show that a version of REINFORCE with the baseline computed using multiple samples can improve performance of a very strong machine translation system. This result, and our REINFORCE-critic experiments, suggest that often the variance of REINFORCE can be reduced enough to make its application practical. That said, we would like to emphasize that this paper attacks the problem of gradient estimation from a very different angle as it aims for low-variance but potentially high-bias estimates. The idea of using the ground-truth output that we proposed is an absolutely necessary first step in this direction. Future work could focus on further reducing the bias of the actor-critic estimate, for example, by using a multi-sample training criterion for the critic. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            598
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            326,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We thank the developers of Theano (Theano Development Team, 2016) and Blocks (van Merrienboer ¨ et al., 2015) for their great work. We thank NSERC, Compute Canada, Calcul Quebec, Canada ´ Research Chairs, CIFAR, CHISTERA project M2CR (PCIN-2015-226) and Samsung Institute of Advanced Techonology for their financial support. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            694
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            714,
+            285,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In Proceedings of the ICLR 2015, 2015. ",
+        "bbox": [
+            173,
+            737,
+            823,
+            765
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Barto, Richard S Sutton, and Charles W Anderson. Neuronlike adaptive elements that can solve difficult learning control problems. Systems, Man and Cybernetics, IEEE Transactions on, (5):834–846, 1983. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            814
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. arXiv preprint arXiv:1506.03099, 2015. ",
+        "bbox": [
+            174,
+            823,
+            823,
+            852
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mauro Cettolo, Jan Niehues, Sebastian Stuker, Luisa Bentivogli, and Marcello Federico. Report on ¨ the 11th iwslt evaluation campaign. In Proc. of IWSLT, 2014. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "William Chan, Navdeep Jaitly, Quoc V Le, and Oriol Vinyals. Listen, attend and spell. arXiv preprint arXiv:1508.01211, 2015. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling. arXiv preprint arXiv:1312.3005, 2013. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger ¨ Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014. ",
+        "bbox": [
+            174,
+            154,
+            823,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jan Chorowski, Dzmitry Bahdanau, Dmitriy Serdyuk, KyungHyun Cho, and Yoshua Bengio. Attention-based models for speech recognition. CoRR, abs/1506.07503, 2015. URL http: //arxiv.org/abs/1506.07503. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            247
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hal Daume III and Daniel Marcu. Learning as search optimization: Approximate large margin ´ methods for structured prediction. In Proceedings of the 22nd international conference on Machine learning, pp. 169–176. ACM, 2005. ",
+        "bbox": [
+            173,
+            255,
+            823,
+            297
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hal Daume Iii, John Langford, and Daniel Marcu. Search-based structured prediction. ´ Machine learning, 75(3):297–325, 2009. ",
+        "bbox": [
+            171,
+            305,
+            823,
+            335
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Donahue, Lisa Anne Hendricks, Sergio Guadarrama, Marcus Rohrbach, Subhashini Venugopalan, Kate Saenko, and Trevor Darrell. Long-term recurrent convolutional networks for visual recognition and description. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2625–2634, 2015. ",
+        "bbox": [
+            173,
+            343,
+            826,
+            400
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vaibhava Goel and William J Byrne. Minimum bayes-risk automatic speech recognition. Computer Speech & Language, 14(2):115–135, 2000. ",
+        "bbox": [
+            173,
+            407,
+            823,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Awni Y Hannun, Andrew L Maas, Daniel Jurafsky, and Andrew Y Ng. First-pass large vocabulary continuous speech recognition using bi-directional recurrent dnns. arXiv preprint arXiv:1408.2873, 2014. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            486
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tamir Hazan, Joseph Keshet, and David A McAllester. Direct loss minimization for structured prediction. In Advances in Neural Information Processing Systems, pp. 1594–1602, 2010. ",
+        "bbox": [
+            174,
+            494,
+            821,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            560
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrej Karpathy and Li Fei-Fei. Deep visual-semantic alignments for generating image descriptions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3128– 3137, 2015. ",
+        "bbox": [
+            173,
+            568,
+            826,
+            611
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. A method for stochastic optimization. In International Conference on Learning Representation, 2015. ",
+        "bbox": [
+            171,
+            618,
+            825,
+            648
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ryan Kiros, Ruslan Salakhutdinov, and Richard S Zemel. Unifying visual-semantic embeddings with multimodal neural language models. arXiv preprint arXiv:1411.2539, 2014. ",
+        "bbox": [
+            171,
+            655,
+            823,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            176,
+            691,
+            823,
+            736
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chin-Yew Lin and Eduard Hovy. Automatic evaluation of summaries using n-gram co-occurrence statistics. In Proceedings of the 2003 Conference of the North American Chapter of the Association for Computational Linguistics on Human Language Technology-Volume 1, pp. 71–78. Association for Computational Linguistics, 2003. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            800
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Francis Maes, Ludovic Denoyer, and Patrick Gallinari. Structured prediction with reinforcement learning. Machine learning, 77(2-3):271–301, 2009. ",
+        "bbox": [
+            173,
+            808,
+            823,
+            837
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "W Thomas Miller, Paul J Werbos, and Richard S Sutton. Neural networks for control. MIT press, 1995. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew Y Ng, Daishi Harada, and Stuart Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In ICML, volume 99, pp. 278–287, 1999. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Franz Josef Och. Minimum error rate training in statistical machine translation. In Proceedings of the 41st Annual Meeting on Association for Computational Linguistics-Volume 1, pp. 160–167. Association for Computational Linguistics, 2003. ",
+        "bbox": [
+            176,
+            140,
+            825,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting on association for computational linguistics, pp. 311–318. Association for Computational Linguistics, 2002. ",
+        "bbox": [
+            176,
+            191,
+            823,
+            236
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015. ",
+        "bbox": [
+            171,
+            242,
+            823,
+            272
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey J Gordon, and J Andrew Bagnell. A reduction of imitation learning and ´ structured prediction to no-regret online learning. arXiv preprint arXiv:1011.0686, 2010. ",
+        "bbox": [
+            174,
+            280,
+            823,
+            310
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alexander M Rush, Sumit Chopra, and Jason Weston. A neural attention model for abstractive sentence summarization. arXiv preprint arXiv:1509.00685, 2015. ",
+        "bbox": [
+            171,
+            318,
+            823,
+            347
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mike Schuster and Kuldip K Paliwal. Bidirectional recurrent neural networks. Signal Processing, IEEE Transactions on, 45(11):2673–2681, 1997. ",
+        "bbox": [
+            173,
+            354,
+            825,
+            383
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shiqi Shen, Yong Cheng, Zhongjun He, Wei He, Hua Wu, Maosong Sun, and Yang Liu. Minimum risk training for neural machine translation. arXiv preprint arXiv:1512.02433, 2015. ",
+        "bbox": [
+            171,
+            391,
+            825,
+            421
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, pp. 3104–3112, 2014. ",
+        "bbox": [
+            176,
+            429,
+            825,
+            473
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton. Learning to predict by the methods of temporal differences. Machine learning, 3 (1):9–44, 1988. ",
+        "bbox": [
+            171,
+            479,
+            825,
+            508
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Introduction to reinforcement learning, volume 135. MIT Press Cambridge, 1998. ",
+        "bbox": [
+            171,
+            517,
+            825,
+            546
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, David A McAllester, Satinder P Singh, Yishay Mansour, et al. Policy gradient methods for reinforcement learning with function approximation. In NIPS, volume 99, pp. 1057– 1063, 1999. ",
+        "bbox": [
+            173,
+            554,
+            825,
+            598
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard Stuart Sutton. Temporal credit assignment in reinforcement learning. 1984. ",
+        "bbox": [
+            173,
+            606,
+            725,
+            622
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Gerald Tesauro. Td-gammon, a self-teaching backgammon program, achieves master-level play. Neural computation, 6(2):215–219, 1994. ",
+        "bbox": [
+            171,
+            630,
+            825,
+            659
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            709
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "John N Tsitsiklis and Benjamin Van Roy. An analysis of temporal-difference learning with function approximation. Automatic Control, IEEE Transactions on, 42(5):674–690, 1997. ",
+        "bbox": [
+            169,
+            718,
+            823,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Bart van Merrienboer, Dzmitry Bahdanau, Vincent Dumoulin, Dmitriy Serdyuk, David Warde- ¨ Farley, Jan Chorowski, and Yoshua Bengio. Blocks and fuel: Frameworks for deep learning. arXiv:1506.00619 [cs, stat], June 2015. ",
+        "bbox": [
+            176,
+            755,
+            825,
+            799
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Alexander Toshev, Samy Bengio, and Dumitru Erhan. Show and tell: A neural image caption generator. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3156–3164, 2015. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            849
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Andreas Vlachos. An investigation of imitation learning algorithms for structured prediction. In EWRL, pp. 143–154. Citeseer, 2012. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sam Wiseman and Alexander M Rush. Sequence-to-sequence learning as beam-search optimization. arXiv preprint arXiv:1606.02960, 2016. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016. ",
+        "bbox": [
+            174,
+            140,
+            826,
+            196
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron C. Courville, Ruslan Salakhutdinov, Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 2048–2057, 2015. ",
+        "bbox": [
+            174,
+            207,
+            826,
+            263
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba, Tomas Mikolov, Armand Joulin, and Rob Fergus. Learning simple algorithms from examples. arXiv preprint arXiv:1511.07275, 2015. ",
+        "bbox": [
+            174,
+            272,
+            823,
+            300
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/bab97267d1fe0616fa16e35975558351bdad95bb3f04e356a907034ad9ba9032.jpg",
+        "table_caption": [
+            "Table 5: Results of an ablation study. We tried varying the actor update speed $\\gamma _ { \\theta }$ , the critic update speed $\\gamma _ { \\phi }$ , the value penalty coefficient $\\lambda$ , whether or not reward shaping is used, whether or not temporal difference (TD) learning is used for the critic. Reported are the best training and validation BLEU score obtained in the course of the first 10 training epochs. Some of the validation scores would still improve with longer training. Greedy search was used for decoding. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Y0</td><td>Y</td><td>入</td><td>reward shaping</td><td>TD</td><td>train BLEU</td><td>valid BLEU</td></tr><tr><td colspan=\"7\">baseline</td></tr><tr><td>0.001</td><td>0.001</td><td>10-3</td><td>yes</td><td>yes</td><td>33.73</td><td>23.16</td></tr><tr><td colspan=\"7\">with different γ</td></tr><tr><td>0.001</td><td>0.01</td><td>10-3</td><td>yes</td><td>yes</td><td>33.52</td><td>23.03</td></tr><tr><td>0.001</td><td>0.1</td><td>10-3</td><td>yes</td><td>yes</td><td>32.63</td><td>22.80</td></tr><tr><td>0.001</td><td>1</td><td>10-3</td><td>yes</td><td>yes</td><td>9.59</td><td>8.14</td></tr><tr><td colspan=\"7\">with different ye</td></tr><tr><td>1</td><td>0.001</td><td>10-3</td><td>yes</td><td>yes</td><td>32.9</td><td>22.88</td></tr><tr><td colspan=\"7\">without reward shaping</td></tr><tr><td>0.001</td><td>0.001</td><td>10-3</td><td>no</td><td>yes</td><td>32.74</td><td>22.61</td></tr><tr><td colspan=\"7\">without temporal difference learning</td></tr><tr><td>0.001</td><td>0.001</td><td>10-3</td><td>yes</td><td>no</td><td>23.2</td><td>16.36</td></tr><tr><td colspan=\"7\">with different 入</td></tr><tr><td>0.001</td><td>0.001</td><td>3*10-3</td><td>yes</td><td>yes</td><td>32.4</td><td>22.48</td></tr><tr><td>0.001</td><td>0.001</td><td>10-4</td><td>yes</td><td>yes</td><td>34.10</td><td>23.15</td></tr><tr><td>0.001</td><td>0.001</td><td>10-6</td><td>yes</td><td>yes</td><td>35.00</td><td>23.10</td></tr><tr><td>0.001</td><td>0.001</td><td>10-8</td><td>yes</td><td>yes</td><td>33.6</td><td>22.72</td></tr><tr><td>0.001</td><td>0.001</td><td>0</td><td>yes</td><td>yes</td><td>27.41</td><td>20.55</td></tr></table>",
+        "bbox": [
+            222,
+            181,
+            771,
+            457
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            501,
+            382,
+            517
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For machine translation experiments the variance penalty coefficient $\\lambda$ was set to $1 0 ^ { - 4 }$ , and the delay coefficients $\\gamma _ { \\theta }$ and $\\gamma _ { \\phi }$ were both set to $1 0 ^ { - 4 }$ . For REINFORCE with the critic we did not use a delayed actor, i.e. $\\gamma _ { \\theta }$ was set to 1. For the spelling correction task we used the same $\\gamma _ { \\theta }$ and $\\gamma _ { \\phi }$ but a different $\\lambda = 1 0 ^ { - 3 }$ . When we used a combined training criterion, the weight of the log-likelihood gradient $\\lambda _ { L L }$ was always 0.1. All initial weights were sampled from a centered uniform distribution with width 0.1. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            631
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In some of our experiments we provided the actor states as additional inputs to the critic. Specifically, we did so in our spelling correction experiments and in our WMT 14 machine translation study. All the other results were obtained without this technique. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            680
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For decoding with beam search we substracted the length of a candidate times $\\rho$ from the loglikelihood cost. The exact value of $\\rho$ was selected on the validation set and was equal to 0.8 for models trained by log-likelihood and REINFORCE and to 1.0 for models trained by actor-critic and REINFORCE-critic. ",
+        "bbox": [
+            176,
+            688,
+            825,
+            742
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For some of the hyperparameters we performed an ablation study. The results are reported in Table 5. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            765
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            254,
+            824
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For the IWSLT 2014 data the sizes of validation and tests set were 6,969 and 6,750, respectively. We limited the number of words in the English and German vocabularies to the 22,822 and 32,009 most frequent words, respectively, and replaced all other words with a special token. The maximum sentence length in our dataset was 50. For WMT14 we used vocabularies of 30,000 words for both English and French, and the maximum sentence length was also 50. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C GENERATED Q-VALUES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            405,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In Table C we provide an example of value predictions that the critic outputs for candidate next words. One can see that the critic has indeed learnt to assign larger values for the appropriate next words. While the critic does not always produce sensible estimates and can often predict a high return for irrelevant rare words, this is greatly reduced using the variance penalty term from Equation (10). ",
+        "bbox": [
+            174,
+            133,
+            826,
+            189
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/57cfaa7a6eba38281757771b7134e8305ebbe040f72b0a564c11111d6ecf0ef1.jpg",
+        "table_caption": [
+            "Figure 3: The best 3 words according to the critic at intermediate steps of generating a translation. The numbers in parentheses are the value predictions $\\hat { Q }$ . The German original is “uber eine davon ¨ will ich hier erzahlen .” The reference translation is “and there’s one I want to talk about”. ¨ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Word</td><td rowspan=1 colspan=1>Words with largest Q</td></tr><tr><td rowspan=1 colspan=1>oneofthemi</td><td></td></tr><tr><td rowspan=1 colspan=1>Wanttotellyou</td><td></td></tr><tr><td rowspan=1 colspan=1>abouthereD</td><td></td></tr></table>",
+        "bbox": [
+            330,
+            257,
+            665,
+            440
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D PROOF OF EQUATION (7) ",
+        "bbox": [
+            174,
+            101,
+            416,
+            119
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8609aa16fe43fe7332b14e93124fb2d3e5f2d69a8fd125faca47bad45a852888.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { \\phi ( { \\bf x } ) = \\phi ^ { \\prime } - \\phi ^ { \\prime } \\frac { 1 } { 2 } \\frac { \\partial \\xi } { \\partial t } \\frac { \\partial \\xi } { \\partial t } \\frac { \\partial \\xi } { \\partial t } \\big ( \\mathrm { d } \\mathrm { d } t \\big ) - \\sum _ { j = 1 } ^ { N } \\mu \\frac { \\mathrm { d } \\mathrm { d } \\mathrm { d } \\mathrm { d } t } { \\partial t } \\mathrm { d } \\mathrm { d } \\mathrm { d } t \\big [ \\mathrm { d } \\mathrm { d } \\mathrm { d } t \\big [ \\mathrm { H } _ { 2 } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm } { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm  { H } \\mathrm { H } \\mathrm { H } \\mathrm { H } \\mathrm { H }  \\\\ & { } &  \\mathrm { \\Omega } \\le \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac { \\mathrm { d } } { \\mathrm { d } } \\frac  \\ \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            145,
+            785,
+            468
+        ],
+        "page_idx": 16
+    }
+]

parse/train/mrsx7ninrtU/mrsx7ninrtU.md

@@ -0,0 +1,477 @@
+# Relational VAE: A Continuous Latent Variable Model for Graph Structured Data
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Graph Networks (GNs) enable the fusion of prior knowledge and relational reason  
+2 ing with flexible function approximations. In this work, a general GN-based model   
+3 is proposed which takes full advantage of the relational modeling capabilities of   
+4 GNs and extends these to probabilistic modeling with Variational Bayes (VB). To   
+5 that end, we combine complementary pre-existing approaches on VB for graph data   
+6 and propose an approach that relies on graph-structured latent and conditioning   
+7 variables. It is demonstrated that Neural Processes can also be viewed through the   
+8 lens of the proposed model. We show applications on the problem of structured   
+9 probability density modeling for simulated and real wind farm monitoring data, as   
+10 well as on the meta-learning of simulated Gaussian Process data. We release the   
+11 source code, along with the simulated datasets.
+
+# 12 1 Introduction
+
+13 Graph Neural Networks (GNNs) [1, 2] have been established as an effective tool for representation   
+14 learning on graph structured data. Graph structured data are routinely employed to represent entities   
+15 and relations among them. The present work focuses in representation of uncertainty and generative   
+16 modeling for attributed directed graph data with continuous attributes. The initiating motivation for   
+17 this work is the ubiquity of noisy structured data and systems with stochastic or partially observable   
+18 interactions of industrial relevance (e.g. wind farms and urban transportation networks).   
+19 In the context considered herein, modeled entities (nodes) and modeled relations (edges) may feature   
+20 a state, which may not be fully observed and/or stochastic. The same may also holds for global   
+21 (graph) attributes. At the same time, nodes and relations may possess a dynamic partially observed   
+22 state, which we may infer directly from data. Both the node states and edge states are not fully   
+23 observed and non-deterministic, which amply motivates probabilistic extensions of graph networks.   
+24 In essence, this work proposes a method that 1) exploits the relational structure of data and 2) allows   
+25 for learning flexible distributions over entity and relation attributes. Several partially overlapping   
+26 approaches for this problem exist. A short review of such prior approaches is offered in section 3.   
+27 Modeling entities and relations has been shown empirically to allow for stronger generalization   
+28 [3, 4, 5] in novel settings. The main contribution of this work is to propose an approach to transfer the   
+29 potent combinatorial generalization and modeling capabilities of GNNs to the problem of modeling   
+30 conditional distributions of structured data.
+
+# 2 Methods
+
+32 Attributed graphs Following [2], global attribute augmented graphs are denoted by $G \ =$   
+33 $( \mathcal { V } , \mathcal { E } , { \bf u } )$ where $\gamma ~ : ~ \{ \mathbf { v } _ { i } \} _ { i = 1 : N ^ { v } }$ with $\mathbf { v } _ { i } ~ \in ~ \mathbb { R } ^ { d ^ { v } }$ denoting the nodes (vertices) of the graph,   
+34 $\mathcal { E } : \{ ( \mathbf { e } _ { k } , s _ { k } , r _ { k } ) \} _ { k = 1 : N ^ { e } }$ designating the set of edges, with edge attributes $\mathbf { e } _ { k } \in \mathbb { R } ^ { d ^ { e } }$ , $s _ { k } , r _ { i } \in \mathbb { N } ^ { 1 }$   
+35 denote the head (sender) and tail (receiver) nodes of the modeled relation, while $\mathbf { u } \in \mathbb { R } ^ { d ^ { u } }$ is the   
+36 global attribute.   
+37 Graph Networks (GN) (or GraphNets) are composite functions that receive and return attributed   
+38 graphs. The full GN block consists of an edge update, a node update and a global update block. Each   
+39 block contains a corresponding function $\phi ^ { e } , \phi ^ { v } , \phi ^ { u }$ . The edge update function uses edge, node and   
+40 global data. The edge block is followed by an aggregation step $\rho ^ { e \to n }$ , where edge messages are   
+41 accumulated according to a permutation invariant function, e.g. a mean function. The node update   
+42 uses (optionally) the global state, the aggregated edge state and the current node state. Finally, a global   
+43 block aggregates with permutation invariant functions the edge and node properties $( \rho ^ { e \to u } , \bar { \rho ^ { v \to u } } )$ ,   
+44 and optionally uses the global state for updating the global variable state. Different parts of the full   
+45 GN computation may be omitted. Several Graph Neural Network architectures can be cast as special   
+46 cases of GNs by omitting certain features or by special choices of the different functions involved   
+47 [2]. In what follows, when referring to GNNs, the most general and expressive GN layer is implied   
+48 except otherwise specified.   
+49 In the proposed model, entities (nodes), relations (edges) and global attributes contain both determin  
+50 istic and stochastic variables. These variables in turn, may be observable or not directly observable.   
+51 Both observable and unobservable attributes may be deterministic or stochastic (static or evolving).   
+52 In what follows, a part of the observable quantities is referred to as conditioning or context. The node,   
+53 edge and global observable quantities are denoted as $\mathbf { v } ^ { h } , \mathbf { e } ^ { h } , \mathbf { u } ^ { h }$ where $h$ signifies that a variable   
+54 corresponds to conditioning. Conditioning variables may either correspond to conditioning with   
+55 known dynamic quantities or static quantities. Common instantiations of such conditioning are   
+56 positional encoding for vertices, relative position for edges between vertices and time of day as   
+57 a global variable. The node, edge and global variables that correspond to the rest of the states   
+58 (stochastic, evolving, unobserved) are denoted by $\mathbf { v } ^ { d } , \mathbf { e } ^ { d } , \mathbf { u } ^ { d }$ . In essence, the conditioning attributes   
+59 can be used to create a conditioning graph variable $G _ { h } = ( \mathcal { V } _ { h } , \mathcal { E } _ { h } , \mathbf { u } _ { h } )$ and a state graph variable   
+60 $G _ { x } = ( \nu _ { x } , \mathcal { E } _ { x } , \mathbf { u } _ { x } )$ . The full graph state, is denoted by $G _ { d } = ( \mathcal { V } _ { x } \cup \mathcal { V } _ { h } , \mathcal { E } _ { x } \cup \mathcal { E } _ { h } , \mathbf { u } _ { x } \cup \mathbf { u } _ { h } )$ where   
+61 ∪ denotes set union. Since part of the node, edge and global attributes may be stochastic, a graph   
+62 structured latent variable $G _ { z } ^ { \phantom { \dagger } } = ( \gamma _ { z } , \mathcal { E } _ { z } , \mathbf { u } _ { z } )$ is assumed. The graph structure may also be determined   
+63 through the edge variables as in [6], but we restrict our model to a pre-determined graph structure   
+64 in this work. The following model is proposed for the joint distribution of the graph structured   
+65 observations
+
+$$
+p ( G _ { x } ; G _ { h } ) = \int p ( G _ { x } | G _ { z } ; G _ { h } ) p ( G _ { z } ; G _ { h } ) d G _ { z }
+$$
+
+66 where $p ( G _ { z } ; G _ { h } ) = p ( \mathscr { V } _ { z } ; \mathscr { V } _ { h } ) p ( \mathscr { E } _ { z } ; \mathscr { E } _ { h } ) p ( \mathbf { u } _ { z } ; \mathbf { u } _ { h } )$ is the distribution of the latent variables given $G _ { h }$   
+67 A prior distribution conditioned on $G _ { h }$ is assumed for the latent variable, which is further factorized   
+68 along each edge and node latent separately, i.e.,
+
+$$
+\begin{array} { l } { { \displaystyle p ( G _ { z } ; G _ { h } ) = p ^ { ( \boldsymbol { \nu } ) } ( \mathscr { V } _ { z } ; \mathscr { V } _ { h } ) p ^ { ( \boldsymbol { \varepsilon } ) } ( \mathscr { E } _ { z } ; \mathscr { E } _ { h } ) p ^ { ( \mathbf { u } ) } ( \mathbf { u } _ { h } ; \mathbf { u } _ { z } ) } \ ~ } \\ { { \displaystyle ~ = \prod _ { i = 1 } ^ { N ^ { v } } p ( \mathbf { v } _ { i } ^ { z } ; \mathbf { v } _ { i } ^ { h } ) \cdot \prod _ { k = 1 } ^ { N ^ { e } } p ( \mathbf { e } _ { k } ^ { z } ; \mathbf { e } _ { k } ^ { h } ) \cdot p ( \mathbf { u } ^ { z } ; \mathbf { u } ^ { h } ) } . } \end{array}
+$$
+
+69 An approximate posterior (i.e., recognition model) is assumed for $G _ { z }$ as $q _ { \phi } ( G _ { z } | G _ { x } ; G _ { h } )$ together   
+70 with a generative model for $G _ { x }$ , $p _ { \pmb { \theta } } ( G _ { x } | G _ { z } ; G _ { h } )$ . In correspondence with the Variational Autoen  
+71 coder (VAE) [7], we seek to learn the generative model parameters $\pmb { \theta }$ and inference model param  
+72 eters $\phi$ simultaneously. Assuming independent identically distributed (i.i.d.) graph observations   
+73 $\{ G _ { x } ^ { ( 1 ) } , . . . G _ { x } ^ { ( i ) } \}$ , the Evidence Lower Bound (ELBO) for the marginal log-likelihood reads
+
+$$
+\begin{array} { r l } & { \mathcal { L } ( \pmb { \theta } , \phi ; G _ { x } ^ { ( i ) } , G _ { h } ^ { ( i ) } ) = \mathbb { E } _ { q _ { \theta } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) } \big [ \log p _ { \pmb { \theta } } ( G _ { x } ^ { ( i ) } | G _ { z } ; G _ { h } ^ { ( i ) } ) \big ] } \\ & { \qquad - D _ { K L } ( q _ { \phi } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) | | p _ { \pmb { \theta } } ( G _ { z } ; G _ { h } ^ { ( i ) } ) ) } \end{array}
+$$
+
+74 We seek to perform fast and scalable approximate inference over the $G _ { z }$ graph variable and at the   
+75 same time take advantage of the relational structure in the data. A particularly convenient choice   
+76 for parametrizing $G ^ { z }$ is to assume a parametric distribution over edges, nodes and globals. A GN is
+
+77 proposed for inferring the parameters. For a graph structured observation observation $G _ { x }$ , we write
+
+$$
+\begin{array} { l } { { \gamma ^ { z } \sim q _ { \phi } ^ { ( \nu ) } ( G _ { z } | G _ { x } ; G _ { h } ) = \mathcal N ( f _ { q _ { \phi } } ^ { \mu ( \nu ) } ( G _ { x } ; G _ { h } ) , f _ { q _ { \phi } } ^ { \sigma _ { ( \nu ) } ^ { 2 } } ( G _ { x } ; G _ { h } ) ) } } \\ { { \xi ^ { z } \sim q _ { \phi } ^ { ( \varepsilon ) } ( G _ { z } | G _ { x } ; G _ { h } ) = \mathcal N ( f _ { q _ { \phi } } ^ { \mu ( \varepsilon ) } ( G _ { x } ; G _ { h } ) , f _ { q _ { \phi } } ^ { \sigma _ { ( \varepsilon ) } ^ { 2 } } ( G _ { x } ; G _ { h } ) ) } } \\ { { { \bf { u } } _ { z } \sim q _ { \phi } ^ { ( \mathbf { u } ) } ( G _ { z } | G _ { x } ; G _ { h } ) = \mathcal N ( f _ { q _ { \phi } } ^ { \mu _ { ( \mathbf { u } ) } } ( G _ { x } ; G _ { h } ) , f _ { q _ { \phi } } ^ { \sigma _ { ( \mathbf { u } ) } ^ { 2 } } ( G _ { x } ; G _ { h } ) ) . } } \end{array}
+$$
+
+78 The functions $f _ { \cdot } ^ { \mu _ { ( \cdot ) } }$ an d f σ ( · )· a re implemented by a GN to allow for taking into account in a general   
+79 manner relational information while inferring over $\mathcal { V } _ { z } , \mathcal { E } _ { z }$ and $\mathbf { u } _ { z }$ . In practice a shared, single GN,   
+80 $f _ { q _ { \phi } } ( \cdot )$ is used. The parametrization for vertices, edges and global variables are the corresponding   
+81 states of the GN at the final message passing step. In a similar manner, a GN generator network,   
+82 $g _ { p _ { \theta } } ( \cdot )$ , is used for $p _ { \pmb { \theta } }$ . Since the prior and posterior are factorized over nodes, edges and the global   
+83 variable of each graph datapoint, the ELBO is split accordingly as
+
+$$
+\begin{array} { r l } & { \mathcal { L } ( \pmb { \theta } , \phi ; G _ { x } ^ { ( i ) } , G _ { h } ^ { ( i ) } ) = \mathbb { E } _ { q _ { \pmb { \theta } } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) } \left[ \log p _ { \pmb { \theta } } ( G _ { x } ^ { ( i ) } | G _ { z } ; G _ { h } ^ { ( i ) } ) \right] } \\ & { \quad \quad \quad \quad - \beta _ { \nu } D _ { K L } ( q _ { \phi } ^ { ( \gamma ) } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) | | p _ { \pmb { \theta } } ^ { ( \gamma ) } ( G _ { z } ; G _ { h } ^ { ( i ) } ) ) } \\ & { \quad \quad \quad \quad - \beta _ { \varepsilon } D _ { K L } ( q _ { \phi } ^ { ( \mathcal { E } ) } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) | | p _ { \pmb { \theta } } ^ { ( \mathcal { E } ) } ( G _ { z } ; G _ { h } ^ { ( i ) } ) ) } \\ & { \quad \quad \quad \quad - \beta _ { \mathbf { u } } D _ { K L } ( q _ { \phi } ^ { ( \mathbf { u } ) } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) | | p _ { \pmb { \theta } } ^ { ( \mathbf { u } ) } ( G _ { z } ; G _ { h } ^ { ( i ) } ) ) } \end{array}
+$$
+
+84 where $\beta _ { \nu } , \beta _ { \mathcal { E } } , \beta _ { \bf u }$ can be used for controlling disentanglement as in $\beta$ –VAE [8] or the rate-distortion   
+85 characteristics of the model [9] or for preventing posterior collapse and aiding training through   
+86 $K L$ -annealing [10, 11]. In a similar manner to VAEs, the approach to representing distributions over   
+87 graph data with a distribution that factorizes over $\nu , \varepsilon$ and u allows for defining alternative evidence   
+88 lower bounds for variational Bayes. Note that the distribution does not need to be factorized along the   
+89 elements of the latent vector. This allows straight-forward extensions using more flexible distributions   
+90 [12]. A generative model based on normalizing flows that uses shift-scale transformations [13] has   
+91 already been proposed in [14] for graph generation. The Relational VAE (RVAE) model proposed   
+92 can be extended as a hierarchical VAE [15] yielding a model akin to Doubly Stochastic Variational   
+93 Neural Process (DSNPV) [16], which uses global and node variables. Finally, Neural Processes   
+94 [17, 18] (NP) and other graph encoder-decoder models [6, 19, 20, 21, 22] are closely related to the   
+95 proposed model.
+
+# 96 3 Related work
+
+97 GNN Encoder-decoder models In Neural Relational Inference (NRI) [6] discrete edge latent vari  
+98 ables are inferred from node representations and a re-parametrized $G u m b e l - S o f t m a x$ distribution   
+99 is used[23, 24]. A coarse representation of the computational graphs of NRI, NPs and the RVAE   
+100 is shown in Figure 1. In [19] graphs are modeled from global continuous latent variables, which   
+101 are subsequently used for graph generation through an adjacency matrix. In GraphVAE [20] the   
+102 global variable together with a graph-structured conditioning variable is used for generation. In   
+103 Graphite [21] a latent variable for each node is inferred from the encoder, while the edge variables   
+104 (i.e., symmetric adjacency matrix) is inferred through efficient iterated message passing. Similarly,   
+105 the VariationalGAE[22] uses a separate latent variable for every node and a graph convolutional   
+106 encoder. Several of the aforementioned works take advantage of recent advances in low-variance   
+107 gradient estimates for distributions over latent variables, as in Variational Autoencoders (VAEs) via   
+108 the reparametrization trick [7, 25]. The overlapping traits of the aforementioned are the treatment   
+109 of edge, node and global variables. In Table 1 a summary of the relational modeling capabilities of   
+110 various graph encoder-decoder models is offered. Note that the table highlights only the relevant   
+111 parts to this work together with several important and influential design choices for graph representa  
+112 tion learning were not touched upon. For instance, the graph convolutional models of some of the   
+113 aforementioned works offer the important advantage of scalability and small computation cost.   
+114 In this work, the above mentioned approaches, are generalized and unified in the proposed Relational   
+115 Variational Autoencoder (RVAE) model. Note that it is not difficult to yield explicit graph connectivity   
+116 in RVAE as in NRI [6] since the type and existence of a connection can be seen as a categorical   
+117 variable. See also Figure 1 (b), where a sketch of NRI is offered. Inferring graph connectivity or   
+118 generating graphs, however, falls out of the scope of this work. In RVAE the focus is generative   
+119 modeling of graph structured data with an apriori known connectivity, with attributed nodes and   
+120 edges, which optionally may include a global attribute that influences both entities and relations.   
+121 Neural processes In Neural Processes (NP)[17, 18], we consider a set of mappings $F : \mathcal { X }  \mathcal { V }$   
+122 where $\bar { \mathcal { X } } : \{ x _ { i } \}$ , $x _ { i } \in \mathbb { R } ^ { N _ { x } } , \mathcal { Y } : \{ y _ { i } \}$ , $y _ { i } \in \mathbb { R } ^ { N _ { y } }$ . A particular draw of a function $f \sim F$ , is modeled   
+123 as $f ( x _ { i } ) = g _ { \boldsymbol { \theta } } ( x _ { i } , z )$ where $z \sim p ( z )$ is a high dimensional random vector (e.g. a standard normal)   
+124 and $g _ { \theta }$ is a neural network and $\theta$ denotes the parameters of $g$ . Given a set of $n _ { m }$ input-output   
+125 observations $\mathcal { D } : \{ ( x _ { 1 : n _ { m } } , y _ { 1 : n _ { m } } ) _ { f _ { m } } \}$ from $m$ different realizations of $f$ (potentially different in   
+126 number), we want to learn a distribution over $z \sim p ( z | \mathcal { D } )$ . Under the NP approximation, assuming   
+127 observation noise $y _ { i } \sim \mathcal { N } ( g _ { \boldsymbol { \theta } } ( x _ { i } , z ) , \sigma ^ { 2 } )$ , the distribution of $y$ is defined as
+
+Table 1: Features of different related Bayesian graph network encoder-decoder models (see also Figure 1). For the NP models that contain a latent variable, it is straightforward to combine a deterministic global encoder for the context inputs at test time [26]. The attributes with subscript $z$ denote that the model performs optimization using an ELBO objective. The attributes with superscript $h$ denote whether the models may facilitate deterministic conditioning for the corresponding graph attribute at test time.   
+
+<table><tr><td></td><td colspan="3">Latent</td><td colspan="4">Conditioning</td></tr><tr><td>Name</td><td>V</td><td>&amp;</td><td>Uz</td><td>Vh</td><td>8h</td><td>Uh</td><td>Architecture notes</td></tr><tr><td>CNP [17]</td><td></td><td></td><td></td><td>√</td><td>1</td><td>√</td><td>DeepSet encoder,GN node block</td></tr><tr><td>AttCNP [27]</td><td></td><td></td><td></td><td>1</td><td>√</td><td>(</td><td>Attention encoder/decoder</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>Decoder edge cond. through cross-attention</td></tr><tr><td>ConvCNP [28]</td><td></td><td></td><td></td><td></td><td></td><td>（√</td><td>SetConv encoder</td></tr><tr><td></td><td>NP[18]</td><td></td><td></td><td></td><td></td><td></td><td>DeepSet encoder</td></tr><tr><td>GraphVAE [20]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>Graph conv. encoder</td></tr><tr><td>VariationalGAE [22]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>Graph convolutions Iterative decoder</td></tr><tr><td>Graphite [21]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>MP encoder/decoder</td></tr><tr><td>NRI [6] MPNP [29]</td><td></td><td></td><td></td><td></td><td></td><td>√</td><td>MP encoder/decoder</td></tr><tr><td>DSVNP [16]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>V²~p(V²|u²,V*，Vh*)</td></tr><tr><td>RVAE (this work)</td><td></td><td></td><td></td><td></td><td></td><td>一</td><td>MP encoder/decoder</td></tr></table>
+
+$$
+p ( z , y _ { 1 : n } | x _ { 1 : n } ) = p ( z ) \prod _ { j = 1 } ^ { n } { \mathcal { N } } ( y _ { i } | g ( x _ { i } , z ) , \sigma ^ { 2 } ) .
+$$
+
+128 In practice, the input-output observation cases $\mathcal { D }$ , are split as $\mathcal { D } ^ { C \cup T } = \mathcal { D } ^ { C } \cup \mathcal { D } ^ { T }$ , where $C$ denotes   
+129 a set of points with observations in $\mathcal { X }$ and $\mathcal { V }$ and $T$ denotes a set of points where we only observe   
+130 $\mathcal { X }$ (i.e., the inputs). This can be cast as a conditional generative model for $p ( y _ { T } | x _ { T } , x _ { C } , y _ { C } ) =$   
+131 $p _ { \boldsymbol { \theta } } ( y _ { T } | x _ { T } , z ) p ( z | x _ { C } , y _ { C } )$ , where the conditioning is the fully observed context pairs. The ELBO   
+132 used for optimization is
+
+$$
+\begin{array} { r l } & { \displaystyle \log p ( y _ { T } | x _ { T } , x _ { C } , y _ { C } ) \geq \mathbb { E } _ { q _ { \phi } ( z | \mathcal { D } ^ { C \cup T } ) } \Big [ \displaystyle \sum _ { i \in T } \log p _ { \theta } ( y _ { i } | z , x _ { i } ) + \log \frac { q ( z | \mathcal { D } ^ { C } ) } { q ( z | \mathcal { D } ^ { C \cup T } ) } \Big ] } \\ & { \displaystyle \mathbb { E } _ { q _ { \phi } ( z | \mathcal { D } ^ { C \cup T } ) } \Big [ \displaystyle \sum _ { i \in T } \log p _ { \theta } ( y _ { i } | z , x _ { i } ) \Big ] - D _ { K L } ( q _ { \phi } ( z | \mathcal { D } ^ { C \cup T } ) | | q _ { \phi } ( z | \mathcal { D } ^ { C } ) ) } \end{array}
+$$
+
+133 Note that the above variational objective has an intuitive interpretation, as a reconstruction loss (first   
+134 part) and a Kullback-Leibler divergence between the approximate posterior distributions predicted   
+135 when using both $C \cup T$ and when using only $C$ (the context set). In [30] a similar loss function was   
+136 proposed with the motivation of training VAEs that can be used with arbitrary conditioning masks. By   
+137 considering the set of observations as nodes in a disconnected graph, (i.e., $\mathcal { V } : \{ \mathbf { v } _ { i } | ( x _ { i } , y _ { i } ) \} _ { i = 1 : N ^ { v } } )$   
+138 and training while masking the context output nodes $y _ { C }$ , the same objective is retrieved. Therefore,   
+139 following the nomenclature of [2], we can instantiate a NP from the proposed model, by using   
+140 arbitrary conditioning as described in [30], a DeepSet [31] as an encoder and only a node-block as a   
+141 decoder as shown in Figure 1.   
+142 The NP framework has been extended to take advantage of special inductive biases, such as the   
+143 relation of observation and target nodes in Attentive Conditional Neural Processes (AttNP) [27] or   
+144 the translation equivariance in Convolutional Conditional Neural Processes (ConvCNP) [28]. More   
+145 recently, relational inductive biases were employed in Message Passing Neural Processes (MPNP)   
+146 [29]. The aforementioned models, feature a global latent variable $\mathbf { u } _ { z }$ which is inferred from the   
+147 context points and parametrizes the distribution over functions. With the exception of MPMP, the   
+148 aforementioned works target non-relational data. Nevertheless, MPMPs does not directly implement   
+149 edge-bound uncertainty or edge-level conditioning, which is the most pronounced difference to RVAE.   
+150 Similar to this work, in DSNPV [16] a NP that allows for both node and global latent variables   
+151 was proposed, which in addition, employs a hierarchical VAE [15]. The motivation of DSNPV is   
+152 to include node-context information, which in the conditional RVAE is also supported by design   
+153 through $\nu _ { h }$ . RVAE attempts to merge the complementary strengths of the aforementioned models   
+154 in representation of uncertainty, with a focus towards modeling graph structured continuous data.   
+155 Finally, in contrast to Functional Neural Processes [32] we do not deal with inferring a graph of   
+156 dependencies among latent variables, yet hierarchical RVAE adaptations may also manage such tasks.   
+157 Graph Gaussian processes Sharing the motivation of this work, i.e., taking advantage of relational   
+158 information and learning joint distributions of graph structured data, in [33] GPs were defined over   
+159 graphs with undirected binary (positive or negative) edges and applied to semi-supervised learning   
+160 problems. In [34] the authors applied GPs trained with variational approximations for semi-supervised   
+161 learning on graphs that contain non-attributed edges. In [35] GP-based approaches are fused with   
+162 deep learning for learning graph (e.g. network) structured signals.
+
+![](images/f9b2f90cfee33fc44edc539654a97951af1663b693c359d8d3329e80114e4a3c.jpg)  
+Figure 1: (a) Proposed architecture with a single message passing step in the encoder and decoder (b) the Neural Relational Inference model of [6]. (c) The Neural Process model [18]. For direct correspondence between the present work and [6] and [18] the notations of the other works are included in the figure (e.g. $\rho ^ { \mathbf { v }  \mathbf { u } } = \mathbf { a }$ in the Neural Process model).
+
+# 4 Results
+
+# 4.1 Wind farm operational data
+
+165 A real-world industrial application, where relational structure is inherent in the observed data, is   
+166 found in modeling of operational data of wind turbines positioned in a farm. The wind turbines   
+167 (nodes) feature static variables, such as their power production characteristics and their position,   
+168 as well as dynamic variables such as their current operational state. The actual operational state   
+169 of a turbine is only known up to a certain precision from historical data, (i.e., Supervisory Control   
+170 and Data Acquisition (SCADA) data), which is usually limited to 10 minute statistics. Due to   
+171 the stochasticity of the wind excitation, compounded by incomplete information due to coarse   
+172 measurements, there is uncertainty associated with the actual operational state of a wind turbine.   
+173 Wind turbines arranged in a wind farm interact through the so-called wakes, which are travelling   
+174 vortices that affect the power production and vibrations of downstream turbines. The magnitude   
+175 of wake effects is related to large scale turbulence (which is a global dynamic variable), to wind   
+176 orientation (which is a global dynamic variable), to upwind turbine nacelle orientation (which is a   
+177 node dynamic variable), the relative position between the two turbines (an edge static variable), the   
+178 rotor diameter and the distance between the two turbines. The interaction is one-way directional but   
+179 can change directionality depending on the wind orientation. The effect of wakes is stochastic due to   
+180 turbulence. For robust wind power prediction, monitoring, control, and maintenance planning, we   
+181 want to infer the distribution of operational characteristics of a wind farm conditioned on turbine   
+182 characteristics and farm layout. Of crucial importance is the inclusion of stochastic variables in   
+183 the interactions (i.e., edges) of the considered graph. Static graph edges, used as part of the graph   
+184 conditioning, are constructed by considering the spatial proximity and relative position of pairs of   
+185 turbines. The goal is to generalize directly to unseen farm configurations while learning directly on   
+186 real condition monitoring data (zero-shot generalization) but at the same time to yield uncertainty   
+187 estimates.   
+188 Graph machine learning in wind farm modeling In [36] a GNN was trained on simulated data   
+189 for wind power prediction. Recently, in [37] GNNs were applied as a surrogate model to more   
+190 accurate fluid dynamic simulations. With the architectural advancements proposed in this work, we   
+191 extend the wind farm relational modeling literature by providing a solution for representation of   
+192 uncertainty in wind turbine interactions. Moreover, we empirically show in real wind farm data that   
+193 significant accuracy improvements are possible through the incorporation of the proposed relational   
+194 modeling and variational Bayes approach.
+
+![](images/59c35cc8b2e77c5e7a065a0bb9e074613b9092de99fed3c3a6901f5eec69b2db.jpg)  
+Figure 2: Imputation qualitative results for wind speed. The imputed points are marked with a dark $1 / N ^ { T } \sum _ { i = 1 } ^ { N ^ { T } } ( | \mathbf { v } _ { i } ^ { T } - \hat { \mathbf { v } _ { i } } ^ { T } | ) / | \mathbf { v } _ { i } ^ { T } |$ mean awhere $\mathbf { v } _ { i } ^ { T }$ lute percentage error is repis the actual value of node $i$ rt, $N ^ { T }$ which is computed asthe number of target turbines and $\hat { \mathbf { v } } _ { i }$ is the CRVAE prediction.
+
+# 195 4.2 Real wind farm SCADA dataset
+
+196 Conditional RVAE models (CRVAE) were trained with with a 80/20 train/test split on a dataset that   
+197 includes 6 months of 10-minute average SCADA data readings. Since the goal is to compare the   
+198 fitting capability of the models and not model selection, no validation set was employed. Early   
+199 stopping with patience of 2500 steps was used (test set evaluation every 500 steps). The larger RVAE   
+200 models that also yield the best performance had not converged at the 10th epoch. The $20 \%$ of turbine   
+201 data are randomly masked during training. A batch size of 16 was used for all models. In order   
+202 to make a fair comparison no regularization or KL-annealing was used. A small learning rate of   
+203 $5 \cdot 1 0 ^ { - 5 }$ and the Adam optimizer [38] with default parameters was used for all the runs. The final   
+204 ELBOs for all models are shown in Table 2. A mean aggregation function and composite aggregation   
+205 function consisting of a concatenation of mean,max and min aggregators were used. Due to the   
+206 concatenation operation, the composite aggregators result in slightly larger networks. Aligned with   
+207 recent results on GN performance when using composite aggregation functions [39] we find that   
+208 networks with the $m e a n - m a x - m i n$ aggregator indeed yield better performance. The motivation,   
+209 however, for using composite aggregators, is also due to the physics of the problem. By using   
+210 such aggregators it is easier to discriminate the un-waked part of the farm and the waked turbines.   
+211 More concretely, turbines at the upstream boundary of the farm have larger power production and   
+212 this directional effect can easily be masked using the mean aggregation. The CRVAE models are   
+213 compared to a two-layer MLP-based CVAE trained with the arbitrary conditioning objective [30] of   
+214 varying sizes, with the largest CVAE model number of parameters corresponding to the number of   
+215 parameters of the best performing RCVAE. The largest CVAE model was the worst-performing of   
+216 the evaluated CVAE models.   
+217 The CVAE model with the smallest size has slightly better performance compared to the RVAE model   
+218 that performs no message passing on the encoder part, and therefore ignores relational inductive   
+219 biases when inferring $G _ { z }$ . All but one of the CRVAE models strongly outperform the CVAE models   
+220 by a large margin which is attributed to the effective use of relational inductive biases. To further   
+221 support this claim, in the supplemental material (section A.1) gradient sensitivities are plotted and it   
+222 is observed that the imputation results for masked turbines depend on upstream turbines. Qualitative   
+223 imputation results are shown in Figure 2.   
+224 Effect of inferring edge latents $\mathcal { E } _ { z }$ The introduction of   
+225 continuous edge-related latent variables is overlooked in a   
+226 large part of the literature. Wake effect modeling is an appli  
+227 cation that may benefit from edge latent variables. We test   
+228 the effect of edge latent variables by setting $\beta \varepsilon = 0$ while   
+229 still using $G _ { h }$ . The results of this experiment are shown in   
+230 Table 3. The inclusion of the KL term with respect to edge   
+231 latent variables seems to improve the reconstruction error   
+232 achieved by the model.
+
+Table 2: Test set ELBO on Anholt SCADA dataset after 10 epochs. Numbers in parentheses are the standard deviations of the ELBO estimates in the test set (higher is better). The same node, edge and global latent sizes were used $( N ^ { G _ { z } } )$ . “(comp.)” stands for the composite mean-max-min aggregator. All MLPs are 3 layer ReLU MLPs. The ·∗ superscript denotes results that were not derived from early stopping.   
+
+<table><tr><td></td><td></td><td></td><td colspan="2">MP Steps</td><td></td><td></td><td></td></tr><tr><td>Model</td><td>mlp units</td><td>NGz size</td><td>enc.</td><td>dec.</td><td>agg.</td><td># params</td><td>ELBO</td></tr><tr><td>CRVAE</td><td>64</td><td>32</td><td>0</td><td>1</td><td>mean</td><td>184,717</td><td>1.96, (0.30)</td></tr><tr><td></td><td>64</td><td>32</td><td>1</td><td>1</td><td>mean</td><td>341,517</td><td>6.99(0.29)</td></tr><tr><td></td><td>64</td><td>32</td><td>2</td><td>2</td><td>mean</td><td>498,317</td><td>7.48(0.61)*</td></tr><tr><td></td><td>64</td><td>32</td><td>2</td><td>2</td><td>(comp.)</td><td>522,893</td><td>8.11(0.48)*</td></tr><tr><td></td><td>64</td><td>32</td><td>3</td><td>3</td><td>(comp.)</td><td>679,693</td><td>7.70(0.53)*</td></tr><tr><td>CVAE</td><td>128</td><td>64</td><td>1</td><td>1</td><td>1</td><td>77,194</td><td>2.12(0.10)</td></tr><tr><td></td><td>256</td><td>64</td><td></td><td></td><td></td><td>252,554</td><td>1.17(0.16)</td></tr><tr><td></td><td>384</td><td>96</td><td>1</td><td>1</td><td>1</td><td>563,146</td><td>1.23(0.09)</td></tr></table>
+
+Table 3: Effect of edge latent variables. Results based on 3 runs for each case.   
+
+<table><tr><td>Case</td><td>log p(Vx|Gz; Gh)</td><td>Range</td></tr><tr><td>βε=1.</td><td>4.16</td><td>±0.43</td></tr><tr><td>βε=0.</td><td>1.80</td><td>±1.21</td></tr></table>
+
+# 4.3 Wind farm simulation dataset
+
+The steady-state wind farm wake simulator FLORIS [40] was used. A dataset of wake effect simulations and preprocessing tools for demonstrating the wind farm modeling approach adopted herein is released as part of this work. In what follows we test the generalization capabilities of a trained RVAE to novel geometric configurations. A single farm configuration is used for training and another one is used for testing. Both farms are simulated with random wind characteristics such as direction and average wind speed. An example output from the simulation can be found in the supplemental material. The train and test farm configurations can also be found in the supplemental material.
+
+242 Qualitative results The RVAE model is able to capture the orientation-dependent wake deficit for   
+243 each turbine separately on the test wind farm as shown in Figure 3. Furthermore, we use a single   
+244 turbine as a probe and position it on a regular grid while keeping a turbine on a fixed position (0,0).   
+245 By inspecting the wind speed predicted at the probe turbine, we can map the wake deficit in 2D   
+246 behind the source turbine. This is shown in Figure 4. The spatial dependence of the wake deficit   
+247 is also shown as computed from FLORIS and the error in RVAE estimation. For distances larger   
+248 than $2 0 0 m$ the wind deficit is accurately predicted. Note that this result is from a model trained on   
+249 operational data from a single simulated windfarm. When the turbines are very close $( < 2 0 0 m )$ the   
+250 wakes are not predicted correctly, but this is an expected effect since the RVAE never encounters   
+251 turbines at these distances. Wake effects estimated with the RVAE are slightly lower than those   
+252 derived from the simulation as shown in Figure 3. However, the RVAE seems to capture the intricate   
+253 wind orientation-dependent effects which depend on the farm layout.
+
+![](images/87f6d9ba7058695e4094797f2696b02e9a820b723ef89e0b8fa9b11d7ab31be8.jpg)  
+Figure 3: Wind deficits on the simulated test farm and estimates from the trained RVAE. Each point associated with a turbine is plotted in a 2D polar coordinate system centered on the turbine. Each point is plotted towards the orientation of the incoming wind. The distance from the origin is proportional to the wake deficit, estimated as $m a x ( v ) - v$ where $v$ is mean power and mean wind.
+
+![](images/6b971b0c04d9fe82c4183b0a3ca6b4e4e6ab2811ac83fa2b7a8ab9a1daf33942.jpg)  
+Figure 4: Learned spatial distribution of wake related wind speed deficit, evaluated as $w _ { ( 0 , 0 ) } - w _ { ( x , y ) }$ where $w _ { ( 0 , 0 ) }$ is the the wind speed at the up-wind turbine and $( x , y )$ denotes the wind speed for a probe turbine positioned at $w _ { ( x , y ) }$ .
+
+# 254 4.4 1D regression
+
+255 In order to further demonstrate the versatility of the RVAE in modeling structured data, and in   
+256 order to make the connection to NPs [18] clearer, in what follows an RVAE adapted for node data   
+257 imputation is presented [30]. The dataset consists of sets of points sampled from a zero-mean 1D   
+258 Gaussian process with a squared exponential kernel. The pairs of input points $\left\{ ( x _ { 1 : n _ { m } } , y _ { 1 : n _ { m } } ) _ { m } \right\}$   
+259 are used as node features to construct a set of context and target graphs, where $m$ corresponds to   
+260 different GP realizations. Each graph contains a set of edges $\mathbf { e } _ { i }$ which encode the relative position   
+261 of the observation points. The edge features between observations at points $x _ { i } , x _ { j }$ are defined as   
+262 $f ( x _ { i } , x _ { j } ) = e ^ { - c \cdot | x _ { i } - x _ { j } | ^ { 2 } }$ where $c$ is a function of the cutoff distance for edge creation. Note that   
+263 the construction of such edge features endows the model with translation equivariance. In contrast   
+264 to MPNPs, [29], the edges are the same in the context and target graphs. The loss function used   
+265 is the same as in Equation 10. Both $p _ { \phi }$ and $q _ { \theta }$ are implemented as GNs. The outputs of the GNs   
+266 parameterize a Gaussian, i.e.,
+
+$$
+\begin{array} { r } { q _ { \phi } ( z | \mathcal { D } ) = \mathcal { N } ( \mu _ { \phi } ( \mathcal { D } ) , \sigma _ { \phi } ^ { 2 } ( \mathcal { D } ) ) , \quad p _ { \theta } ( y | \mathcal { D } ) = \mathcal { N } ( \mu _ { \theta } ( \mathcal { D } ) , \sigma _ { \theta } ^ { 2 } ( \mathcal { D } ) ) . } \end{array}
+$$
+
+267 The $y$ values of $\mathcal { D } ^ { T }$ are replaced with 0 when fed through the encoder and an additional binary feature   
+268 $b$ for the node, which denotes masking, is appended to the node tuple. The $b$ feature is zero for the   
+269 unmasked nodes and 1 for the masked nodes. The masked input is denoted by $\mathcal { D } ^ { T \backslash b }$ . The union of   
+270 the masked target input with the context dataset is denoted by $D ^ { T \setminus b \cup C }$ . Instead of using two different   
+271 functions for the prior of $p ( z | \mathcal { D } ^ { T \setminus b \cup C } )$ as in [30], and posterior network $q ( \boldsymbol { z } | \mathcal { D } ^ { T \cup C } )$ and in order to   
+272 keep the conditional RVAE model closer to the NP formulation, the approximate posterior (i.e., the   
+273 encoder of the RVAE) is used also for the learned prior. The decoder $p _ { \theta }$ receives as node conditioning   
+274 (and optionally edge conditioning) the $x _ { T }$ values and the global latent variable $\mathbf { u } ^ { z }$ . Each realization   
+275 of $\mathbf { u } ^ { z }$ corresponds to a different context set which in turn corresponds to a different sampled $G P$   
+276 More information about he training setup can be found in the appendix.   
+277 The NP is implemented by defining a DeepSet encoder, a global latent variable of the same size   
+278 as the NP MLP. The same latent variable size for nodes and edges was used for each experiment,   
+279 which is the same as the core size. All aggregation functions are mean aggregations. Experiments   
+280 were performed with different number of message passing steps, and inclusion of either the relative   
+281 observation position as an edge feature or the absolute node position $x _ { i }$ for each feature. The models   
+282 are tested in un-seen GP realizations and the negative log-likelihood of predictions are reported in   
+283 Table 4. The RVAE models compute edge, node and global variables. The test datasets contain points   
+284 with $x \in [ 0 , 1 ]$ and $x \in [ 1 , 2 ]$ ranges in order to test the generalization capability of the proposed   
+285 model in translation. Since the edge-blocks only ever receive translation equivariant inputs from   
+286 the dataset, the RVAE models generalize well in the $x \in [ 1 , 2 ]$ range. This is presented only as an   
+287 example of how special equivariant inductive biases may be implemented in RVAE. It is observed   
+288 that the full RVAE model does not perform well when only the node features are available. As with   
+289 NPs, it was empirically found that models yield better results with more training.
+
+Table 4: Test set log likelihoods on 1D GP regression with Conditional RVAE. The results are based on a set of 5000 unseen GP samples, each with 50 context and 50 target points. The models were trained only on points with x in the [0, 1] range. Values in parentheses are standard deviations of the mini-batches. RVAE denotes a model where all latent variables are used (edge node and global).   
+
+<table><tr><td>Model</td><td>size (mlp/z/MP Steps)</td><td colspan="2">Only cond. on nodes Gh =(Vh,·,·）</td><td colspan="2">Cond. on edges and nodes Gh=(Vh,Eh,)</td></tr><tr><td></td><td></td><td>x ∈ [0,1]</td><td>x∈[1,2]</td><td>x ∈ [0,1]</td><td>x∈[1,2]</td></tr><tr><td>CRVAE</td><td>64/64/0</td><td>−17.94(3.11)</td><td>-24.59(4.10)</td><td>0.33(0.04)</td><td>-0.21(0.13)</td></tr><tr><td></td><td>64/64/1</td><td>-12.55(2.51)</td><td>−9.79(2.51)</td><td>0.36(0.07)</td><td>0.08(0.06)</td></tr><tr><td></td><td>64/64/2</td><td>1</td><td></td><td>0.98(0.09)</td><td>0.67(0.08)</td></tr><tr><td>NP</td><td>64/64/NA</td><td>−1.34(0.07)</td><td>−11.13(3.08)</td><td>NA</td><td>NA</td></tr><tr><td></td><td>128/128/NA</td><td>−1.08(0.11)</td><td>-31.74(14.08)</td><td>NA</td><td>NA</td></tr></table>
+
+# 290 Conclusions and broader impact
+
+291 This work introduces an attributed graph approach to the probabilistic modeling of relations within   
+292 entities and their properties. The approach is verified and validated on wake effect simulations and   
+293 actual data from wind turbines placed within a wind farm; a characteristic example that may be   
+294 modeled as a graph. We also find some connections to the NP literature which we demonstrate by   
+295 adapting the proposed method to perform a typical NP benchmark which is 1D regression for GP   
+296 data.   
+297 We introduce a method for data-driven wake effect modeling for wind farms that accounts for uncer  
+298 tainty. The proposed method fuses physical intuition, flexible function approximation through GNs,   
+299 and variational Bayes through re-parametrized gradients. Better and more computationally efficient   
+300 wake effect modeling can lead to improvements in terms of accuracy and computational efficiency in   
+301 analysis for wind farm siting [41] farm layout optimization [42], wind farm control optimization [43]   
+302 and ultimately power production improvements, as well as more robust to uncertainties maintenance   
+303 planning. Ultimately, the aforementioned lead to wind energy being a more attractive clean energy   
+304 solution.   
+305 Graph data are naturally used to model social, transportation and communication networks. Possible   
+306 negative implications of any graph ML work relate to possible malicious uses of analysis in such   
+307 networks, such as de-anonymization in social networks [44], and vulnerability exploitation on   
+308 transportation networks.
+
+References   
+[1] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272. PMLR, 2017.   
+[2] Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018.   
+[3] Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter Battaglia. Learning to simulate complex physics with graph networks. In Hal Daumé III and Aarti Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 8459–8468. PMLR, 13–18 Jul 2020.   
+[4] Tobias Pfaff, Meire Fortunato, Alvaro Sanchez-Gonzalez, and Peter W Battaglia. Learning mesh-based simulation with graph networks. arXiv preprint arXiv:2010.03409, 2020.   
+[5] Vinicius Zambaldi, David Raposo, Adam Santoro, Victor Bapst, Yujia Li, Igor Babuschkin, Karl Tuyls, David Reichert, Timothy Lillicrap, Edward Lockhart, et al. Relational deep reinforcement learning. arXiv preprint arXiv:1806.01830, 2018.   
+[6] Thomas Kipf, Ethan Fetaya, Kuan-Chieh Wang, Max Welling, and Richard Zemel. Neural relational inference for interacting systems. In International Conference on Machine Learning, pages 2688–2697. PMLR, 2018.   
+[7] Diederik P Kingma and Max Welling. Auto-encoding bariational bayes. arXiv preprint arXiv:1312.6114, 2013.   
+[8] 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. 2016.   
+[9] Alexander Alemi, Ben Poole, Ian Fischer, Joshua Dillon, Rif A. Saurous, and Kevin Murphy. Fixing a broken ELBO. In Jennifer Dy and Andreas Krause, editors, Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 159–168. PMLR, 10–15 Jul 2018.   
+[10] Samuel R Bowman, Luke Vilnis, Oriol Vinyals, Andrew M Dai, Rafal Jozefowicz, and Samy Bengio. Generating sentences from a continuous space. arXiv preprint arXiv:1511.06349, 2015.   
+[11] Hao Fu, Chunyuan Li, Xiaodong Liu, Jianfeng Gao, Asli Celikyilmaz, and Lawrence Carin. Cyclical annealing schedule: A simple approach to mitigating kl vanishing. arXiv preprint arXiv:1903.10145, 2019.   
+[12] Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In Francis Bach and David Blei, editors, Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pages 1530–1538, Lille, France, 07–09 Jul 2015. PMLR.   
+[13] Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.   
+[14] Jenny Liu, Aviral Kumar, Jimmy Ba, Jamie Kiros, and Kevin Swersky. Graph normalizing flows. arXiv preprint arXiv:1905.13177, 2019.   
+[15] Casper Kaae Sønderby, Tapani Raiko, Lars Maaløe, Søren Kaae Sønderby, and Ole Winther. Ladder variational autoencoders. arXiv preprint arXiv:1602.02282, 2016.   
+[16] Qi Wang and Herke Van Hoof. Doubly stochastic variational inference for neural processes with hierarchical latent variables. In International Conference on Machine Learning, pages 10018–10028. PMLR, 2020.   
+[17] Marta Garnelo, Dan Rosenbaum, Christopher Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo Rezende, and SM Ali Eslami. Conditional neural processes. In International Conference on Machine Learning, pages 1704–1713. PMLR, 2018.   
+[18] Marta Garnelo, Jonathan Schwarz, Dan Rosenbaum, Fabio Viola, Danilo J Rezende, SM Eslami, and Yee Whye Teh. Neural processes. arXiv preprint arXiv:1807.01622, 2018.   
+[19] Mohammadamin Tavakoli and Pierre Baldi. Continuous representation of molecules using graph variational autoencoder. arXiv preprint arXiv:2004.08152, 2020.   
+[20] Martin Simonovsky and Nikos Komodakis. Graphvae: Towards generation of small graphs using variational autoencoders. In International Conference on Artificial Neural Networks, pages 412–422. Springer, 2018.   
+[21] Aditya Grover, Aaron Zweig, and Stefano Ermon. Graphite: Iterative generative modeling of graphs. In International conference on machine learning, pages 2434–2444. PMLR, 2019.   
+[22] Thomas N Kipf and Max Welling. Variational graph auto-encoders. arXiv preprint arXiv:1611.07308, 2016.   
+[23] Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016.   
+[24] Chris J Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A continuous relaxation of discrete random variables. arXiv preprint arXiv:1611.00712, 2016.   
+[25] Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In International conference on machine learning, pages 1278–1286. PMLR, 2014.   
+[26] Yann Dubois, Jonathan Gordon, and Andrew YK Foong. Neural process family. http://yanndubs. github.io/Neural-Process-Family/, September 2020.   
+[27] Hyunjik Kim, Andriy Mnih, Jonathan Schwarz, Marta Garnelo, Ali Eslami, Dan Rosenbaum, Oriol Vinyals, and Yee Whye Teh. Attentive neural processes. arXiv preprint arXiv:1901.05761, 2019.   
+[28] Jonathan Gordon, Wessel P Bruinsma, Andrew YK Foong, James Requeima, Yann Dubois, and Richard E Turner. Convolutional conditional neural processes. arXiv preprint arXiv:1910.13556, 2019.   
+[29] Ben Day, Cat˘ alina Cangea, Arian R Jamasb, and Pietro Liò. Message passing neural processes. ˘ arXiv preprint arXiv:2009.13895, 2020.   
+[30] Oleg Ivanov, Michael Figurnov, and Dmitry Vetrov. Variational autoencoder with arbitrary conditioning. arXiv preprint arXiv:1806.02382, 2018.   
+[31] Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan Salakhutdinov, and Alexander Smola. Deep sets. arXiv preprint arXiv:1703.06114, 2017.   
+[32] Christos Louizos, Xiahan Shi, Klamer Schutte, and Max Welling. The functional neural process. arXiv preprint arXiv:1906.08324, 2019.   
+[33] Wei Chu Vikas Sindhwani, Zoubin Ghahramani, and S Sathiya Keerthi. Relational learning with gaussian processes. In Advances in Neural Information Processing Systems 19: Proceedings of the 2006 Conference, volume 19, page 289. MIT Press, 2007.   
+[34] Yin Cheng Ng, Nicolò Colombo, and Ricardo Silva. Bayesian semi-supervised learning with graph gaussian processes. arXiv preprint arXiv:1809.04379, 2018.   
+[35] Naiqi Li, Wenjie Li, Jifeng Sun, Yinghua Gao, Yong Jiang, and Shu-Tao Xia. Stochastic deep gaussian processes over graphs. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 5875–5886. Curran Associates, Inc., 2020.   
+[36] Junyoung Park and Jinkyoo Park. Physics-induced graph neural network: An application to wind-farm power estimation. Energy, 187:115883, 2019.   
+[37] James Bleeg. A graph neural network surrogate model for the prediction of turbine interaction loss. In Journal of Physics: Conference Series, volume 1618, page 062054. IOP Publishing, 2020.   
+[38] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[39] Gabriele Corso, Luca Cavalleri, Dominique Beaini, Pietro Liò, and Petar Velickovi ˇ c. Principal neighbour- ´ hood aggregation for graph nets. arXiv preprint arXiv:2004.05718, 2020.   
+[40] NREL. FLORIS. Version 2.2.0, 2020.   
+[41] JK Lundquist, KK DuVivier, D Kaffine, and JM Tomaszewski. Costs and consequences of wind turbine wake effects arising from uncoordinated wind energy development. Nature Energy, 4(1):26–34, 2019.   
+[42] Nicolas Kirchner Bossi and Fernando Porté-Agel. Multi-objective wind farm layout optimization with unconstrained area shape. In Wind Energy Science Conference 2019 (WESC 2019), number POST_TALK, 2019.   
+[43] Michael F Howland, Sanjiva K Lele, and John O Dabiri. Wind farm power optimization through wake steering. Proceedings of the National Academy of Sciences, 116(29):14495–14500, 2019.   
+[44] Shouling Ji, Prateek Mittal, and Raheem Beyah. Graph data anonymization, de-anonymization attacks, and de-anonymizability quantification: A survey. IEEE Communications Surveys & Tutorials, 19(2):1305–1326, 2016.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] As noted in section 3 the main limitation of RVAE is that it cannot be used directly as a graph generation model.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [TODO]The code and dataset will be shared within the deadline for providing supplemental materials.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] see subsection 4.4 and subsection 4.2   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A] For experiments in Table 1 and Table 2 the standard deviation of the batch statistics for a single run are reported since the differences of the models were pronounced. For the results in Table 3 the statistics reported are based on 3 independent runs.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] All reported experiments were run on a personal desktop running Ubuntu 20.04, with an nVidia RTX2080 GPU and 16GB of RAM.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] Orsted energy, formerly known as Dong energy provided us with a proprietary SCADA dataset for the Anholt farm.   
+(b) Did you mention the license of the assets? [Yes] The Anholt SCADA dataset was made available to us under an non-disclosure agreement. The simulated wind farm dataset will be released under the CC-BY 4.0 license.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/mrsx7ninrtU/mrsx7ninrtU_content_list.json

@@ -0,0 +1,924 @@
+[
+    {
+        "type": "text",
+        "text": "Relational VAE: A Continuous Latent Variable Model for Graph Structured Data ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            122,
+            825,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Graph Networks (GNs) enable the fusion of prior knowledge and relational reason  \n2 ing with flexible function approximations. In this work, a general GN-based model   \n3 is proposed which takes full advantage of the relational modeling capabilities of   \n4 GNs and extends these to probabilistic modeling with Variational Bayes (VB). To   \n5 that end, we combine complementary pre-existing approaches on VB for graph data   \n6 and propose an approach that relies on graph-structured latent and conditioning   \n7 variables. It is demonstrated that Neural Processes can also be viewed through the   \n8 lens of the proposed model. We show applications on the problem of structured   \n9 probability density modeling for simulated and real wind farm monitoring data, as   \n10 well as on the meta-learning of simulated Gaussian Process data. We release the   \n11 source code, along with the simulated datasets. ",
+        "bbox": [
+            148,
+            349,
+            766,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "12 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            530,
+            312,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "13 Graph Neural Networks (GNNs) [1, 2] have been established as an effective tool for representation   \n14 learning on graph structured data. Graph structured data are routinely employed to represent entities   \n15 and relations among them. The present work focuses in representation of uncertainty and generative   \n16 modeling for attributed directed graph data with continuous attributes. The initiating motivation for   \n17 this work is the ubiquity of noisy structured data and systems with stochastic or partially observable   \n18 interactions of industrial relevance (e.g. wind farms and urban transportation networks).   \n19 In the context considered herein, modeled entities (nodes) and modeled relations (edges) may feature   \n20 a state, which may not be fully observed and/or stochastic. The same may also holds for global   \n21 (graph) attributes. At the same time, nodes and relations may possess a dynamic partially observed   \n22 state, which we may infer directly from data. Both the node states and edge states are not fully   \n23 observed and non-deterministic, which amply motivates probabilistic extensions of graph networks.   \n24 In essence, this work proposes a method that 1) exploits the relational structure of data and 2) allows   \n25 for learning flexible distributions over entity and relation attributes. Several partially overlapping   \n26 approaches for this problem exist. A short review of such prior approaches is offered in section 3.   \n27 Modeling entities and relations has been shown empirically to allow for stronger generalization   \n28 [3, 4, 5] in novel settings. The main contribution of this work is to propose an approach to transfer the   \n29 potent combinatorial generalization and modeling capabilities of GNNs to the problem of modeling   \n30 conditional distributions of structured data. ",
+        "bbox": [
+            147,
+            561,
+            825,
+            645
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            651,
+            825,
+            816
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 Methods ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            838,
+            277,
+            854
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "32 Attributed graphs Following [2], global attribute augmented graphs are denoted by $G \\ =$   \n33 $( \\mathcal { V } , \\mathcal { E } , { \\bf u } )$ where $\\gamma ~ : ~ \\{ \\mathbf { v } _ { i } \\} _ { i = 1 : N ^ { v } }$ with $\\mathbf { v } _ { i } ~ \\in ~ \\mathbb { R } ^ { d ^ { v } }$ denoting the nodes (vertices) of the graph,   \n34 $\\mathcal { E } : \\{ ( \\mathbf { e } _ { k } , s _ { k } , r _ { k } ) \\} _ { k = 1 : N ^ { e } }$ designating the set of edges, with edge attributes $\\mathbf { e } _ { k } \\in \\mathbb { R } ^ { d ^ { e } }$ , $s _ { k } , r _ { i } \\in \\mathbb { N } ^ { 1 }$   \n35 denote the head (sender) and tail (receiver) nodes of the modeled relation, while $\\mathbf { u } \\in \\mathbb { R } ^ { d ^ { u } }$ is the   \n36 global attribute.   \n37 Graph Networks (GN) (or GraphNets) are composite functions that receive and return attributed   \n38 graphs. The full GN block consists of an edge update, a node update and a global update block. Each   \n39 block contains a corresponding function $\\phi ^ { e } , \\phi ^ { v } , \\phi ^ { u }$ . The edge update function uses edge, node and   \n40 global data. The edge block is followed by an aggregation step $\\rho ^ { e \\to n }$ , where edge messages are   \n41 accumulated according to a permutation invariant function, e.g. a mean function. The node update   \n42 uses (optionally) the global state, the aggregated edge state and the current node state. Finally, a global   \n43 block aggregates with permutation invariant functions the edge and node properties $( \\rho ^ { e \\to u } , \\bar { \\rho ^ { v \\to u } } )$ ,   \n44 and optionally uses the global state for updating the global variable state. Different parts of the full   \n45 GN computation may be omitted. Several Graph Neural Network architectures can be cast as special   \n46 cases of GNs by omitting certain features or by special choices of the different functions involved   \n47 [2]. In what follows, when referring to GNNs, the most general and expressive GN layer is implied   \n48 except otherwise specified.   \n49 In the proposed model, entities (nodes), relations (edges) and global attributes contain both determin  \n50 istic and stochastic variables. These variables in turn, may be observable or not directly observable.   \n51 Both observable and unobservable attributes may be deterministic or stochastic (static or evolving).   \n52 In what follows, a part of the observable quantities is referred to as conditioning or context. The node,   \n53 edge and global observable quantities are denoted as $\\mathbf { v } ^ { h } , \\mathbf { e } ^ { h } , \\mathbf { u } ^ { h }$ where $h$ signifies that a variable   \n54 corresponds to conditioning. Conditioning variables may either correspond to conditioning with   \n55 known dynamic quantities or static quantities. Common instantiations of such conditioning are   \n56 positional encoding for vertices, relative position for edges between vertices and time of day as   \n57 a global variable. The node, edge and global variables that correspond to the rest of the states   \n58 (stochastic, evolving, unobserved) are denoted by $\\mathbf { v } ^ { d } , \\mathbf { e } ^ { d } , \\mathbf { u } ^ { d }$ . In essence, the conditioning attributes   \n59 can be used to create a conditioning graph variable $G _ { h } = ( \\mathcal { V } _ { h } , \\mathcal { E } _ { h } , \\mathbf { u } _ { h } )$ and a state graph variable   \n60 $G _ { x } = ( \\nu _ { x } , \\mathcal { E } _ { x } , \\mathbf { u } _ { x } )$ . The full graph state, is denoted by $G _ { d } = ( \\mathcal { V } _ { x } \\cup \\mathcal { V } _ { h } , \\mathcal { E } _ { x } \\cup \\mathcal { E } _ { h } , \\mathbf { u } _ { x } \\cup \\mathbf { u } _ { h } )$ where   \n61 ∪ denotes set union. Since part of the node, edge and global attributes may be stochastic, a graph   \n62 structured latent variable $G _ { z } ^ { \\phantom { \\dagger } } = ( \\gamma _ { z } , \\mathcal { E } _ { z } , \\mathbf { u } _ { z } )$ is assumed. The graph structure may also be determined   \n63 through the edge variables as in [6], but we restrict our model to a pre-determined graph structure   \n64 in this work. The following model is proposed for the joint distribution of the graph structured   \n65 observations ",
+        "bbox": [
+            148,
+            869,
+            826,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            90,
+            825,
+            135
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            152,
+            825,
+            318
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            324,
+            825,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e45cb14b2efa3c47146082c5ba7b758827d90a7c1e01b7eea81834143514ff4f.jpg",
+        "text": "$$\np ( G _ { x } ; G _ { h } ) = \\int p ( G _ { x } | G _ { z } ; G _ { h } ) p ( G _ { z } ; G _ { h } ) d G _ { z }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            559,
+            653,
+            592
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "66 where $p ( G _ { z } ; G _ { h } ) = p ( \\mathscr { V } _ { z } ; \\mathscr { V } _ { h } ) p ( \\mathscr { E } _ { z } ; \\mathscr { E } _ { h } ) p ( \\mathbf { u } _ { z } ; \\mathbf { u } _ { h } )$ is the distribution of the latent variables given $G _ { h }$   \n67 A prior distribution conditioned on $G _ { h }$ is assumed for the latent variable, which is further factorized   \n68 along each edge and node latent separately, i.e., ",
+        "bbox": [
+            148,
+            597,
+            823,
+            640
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5cd0d82a56e613f4d63d2c31111ea8d784ca85478a2306554c16aae443b38bcf.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle p ( G _ { z } ; G _ { h } ) = p ^ { ( \\boldsymbol { \\nu } ) } ( \\mathscr { V } _ { z } ; \\mathscr { V } _ { h } ) p ^ { ( \\boldsymbol { \\varepsilon } ) } ( \\mathscr { E } _ { z } ; \\mathscr { E } _ { h } ) p ^ { ( \\mathbf { u } ) } ( \\mathbf { u } _ { h } ; \\mathbf { u } _ { z } ) } \\ ~ } \\\\ { { \\displaystyle ~ = \\prod _ { i = 1 } ^ { N ^ { v } } p ( \\mathbf { v } _ { i } ^ { z } ; \\mathbf { v } _ { i } ^ { h } ) \\cdot \\prod _ { k = 1 } ^ { N ^ { e } } p ( \\mathbf { e } _ { k } ^ { z } ; \\mathbf { e } _ { k } ^ { h } ) \\cdot p ( \\mathbf { u } ^ { z } ; \\mathbf { u } ^ { h } ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            647,
+            681,
+            715
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "69 An approximate posterior (i.e., recognition model) is assumed for $G _ { z }$ as $q _ { \\phi } ( G _ { z } | G _ { x } ; G _ { h } )$ together   \n70 with a generative model for $G _ { x }$ , $p _ { \\pmb { \\theta } } ( G _ { x } | G _ { z } ; G _ { h } )$ . In correspondence with the Variational Autoen  \n71 coder (VAE) [7], we seek to learn the generative model parameters $\\pmb { \\theta }$ and inference model param  \n72 eters $\\phi$ simultaneously. Assuming independent identically distributed (i.i.d.) graph observations   \n73 $\\{ G _ { x } ^ { ( 1 ) } , . . . G _ { x } ^ { ( i ) } \\}$ , the Evidence Lower Bound (ELBO) for the marginal log-likelihood reads ",
+        "bbox": [
+            145,
+            723,
+            826,
+            797
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/562af18949dcbc9e6d00de888db125fd862b4d3d0973b62a869e3c8d2f87f8b2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } ( \\pmb { \\theta } , \\phi ; G _ { x } ^ { ( i ) } , G _ { h } ^ { ( i ) } ) = \\mathbb { E } _ { q _ { \\theta } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) } \\big [ \\log p _ { \\pmb { \\theta } } ( G _ { x } ^ { ( i ) } | G _ { z } ; G _ { h } ^ { ( i ) } ) \\big ] } \\\\ & { \\qquad - D _ { K L } ( q _ { \\phi } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) | | p _ { \\pmb { \\theta } } ( G _ { z } ; G _ { h } ^ { ( i ) } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            806,
+            710,
+            857
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "74 We seek to perform fast and scalable approximate inference over the $G _ { z }$ graph variable and at the   \n75 same time take advantage of the relational structure in the data. A particularly convenient choice   \n76 for parametrizing $G ^ { z }$ is to assume a parametric distribution over edges, nodes and globals. A GN is ",
+        "bbox": [
+            147,
+            868,
+            825,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "77 proposed for inferring the parameters. For a graph structured observation observation $G _ { x }$ , we write ",
+        "bbox": [
+            142,
+            90,
+            823,
+            107
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d71a46c270a3b2e619b5c156f7a213ecb9e097f4d1f59b3195fd499f294cec37.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\gamma ^ { z } \\sim q _ { \\phi } ^ { ( \\nu ) } ( G _ { z } | G _ { x } ; G _ { h } ) = \\mathcal N ( f _ { q _ { \\phi } } ^ { \\mu ( \\nu ) } ( G _ { x } ; G _ { h } ) , f _ { q _ { \\phi } } ^ { \\sigma _ { ( \\nu ) } ^ { 2 } } ( G _ { x } ; G _ { h } ) ) } } \\\\ { { \\xi ^ { z } \\sim q _ { \\phi } ^ { ( \\varepsilon ) } ( G _ { z } | G _ { x } ; G _ { h } ) = \\mathcal N ( f _ { q _ { \\phi } } ^ { \\mu ( \\varepsilon ) } ( G _ { x } ; G _ { h } ) , f _ { q _ { \\phi } } ^ { \\sigma _ { ( \\varepsilon ) } ^ { 2 } } ( G _ { x } ; G _ { h } ) ) } } \\\\ { { { \\bf { u } } _ { z } \\sim q _ { \\phi } ^ { ( \\mathbf { u } ) } ( G _ { z } | G _ { x } ; G _ { h } ) = \\mathcal N ( f _ { q _ { \\phi } } ^ { \\mu _ { ( \\mathbf { u } ) } } ( G _ { x } ; G _ { h } ) , f _ { q _ { \\phi } } ^ { \\sigma _ { ( \\mathbf { u } ) } ^ { 2 } } ( G _ { x } ; G _ { h } ) ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            112,
+            707,
+            194
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "78 The functions $f _ { \\cdot } ^ { \\mu _ { ( \\cdot ) } }$ an d f σ ( · )· a re implemented by a GN to allow for taking into account in a general   \n79 manner relational information while inferring over $\\mathcal { V } _ { z } , \\mathcal { E } _ { z }$ and $\\mathbf { u } _ { z }$ . In practice a shared, single GN,   \n80 $f _ { q _ { \\phi } } ( \\cdot )$ is used. The parametrization for vertices, edges and global variables are the corresponding   \n81 states of the GN at the final message passing step. In a similar manner, a GN generator network,   \n82 $g _ { p _ { \\theta } } ( \\cdot )$ , is used for $p _ { \\pmb { \\theta } }$ . Since the prior and posterior are factorized over nodes, edges and the global   \n83 variable of each graph datapoint, the ELBO is split accordingly as ",
+        "bbox": [
+            147,
+            199,
+            825,
+            290
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2db2295452235f098d8ca2c07f9792a760124df6b2d4a32bb2e4046853bbf2fb.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } ( \\pmb { \\theta } , \\phi ; G _ { x } ^ { ( i ) } , G _ { h } ^ { ( i ) } ) = \\mathbb { E } _ { q _ { \\pmb { \\theta } } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) } \\left[ \\log p _ { \\pmb { \\theta } } ( G _ { x } ^ { ( i ) } | G _ { z } ; G _ { h } ^ { ( i ) } ) \\right] } \\\\ & { \\quad \\quad \\quad \\quad - \\beta _ { \\nu } D _ { K L } ( q _ { \\phi } ^ { ( \\gamma ) } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) | | p _ { \\pmb { \\theta } } ^ { ( \\gamma ) } ( G _ { z } ; G _ { h } ^ { ( i ) } ) ) } \\\\ & { \\quad \\quad \\quad \\quad - \\beta _ { \\varepsilon } D _ { K L } ( q _ { \\phi } ^ { ( \\mathcal { E } ) } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) | | p _ { \\pmb { \\theta } } ^ { ( \\mathcal { E } ) } ( G _ { z } ; G _ { h } ^ { ( i ) } ) ) } \\\\ & { \\quad \\quad \\quad \\quad - \\beta _ { \\mathbf { u } } D _ { K L } ( q _ { \\phi } ^ { ( \\mathbf { u } ) } ( G _ { z } | G _ { x } ^ { ( i ) } ; G _ { h } ^ { ( i ) } ) | | p _ { \\pmb { \\theta } } ^ { ( \\mathbf { u } ) } ( G _ { z } ; G _ { h } ^ { ( i ) } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            295,
+            732,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "84 where $\\beta _ { \\nu } , \\beta _ { \\mathcal { E } } , \\beta _ { \\bf u }$ can be used for controlling disentanglement as in $\\beta$ –VAE [8] or the rate-distortion   \n85 characteristics of the model [9] or for preventing posterior collapse and aiding training through   \n86 $K L$ -annealing [10, 11]. In a similar manner to VAEs, the approach to representing distributions over   \n87 graph data with a distribution that factorizes over $\\nu , \\varepsilon$ and u allows for defining alternative evidence   \n88 lower bounds for variational Bayes. Note that the distribution does not need to be factorized along the   \n89 elements of the latent vector. This allows straight-forward extensions using more flexible distributions   \n90 [12]. A generative model based on normalizing flows that uses shift-scale transformations [13] has   \n91 already been proposed in [14] for graph generation. The Relational VAE (RVAE) model proposed   \n92 can be extended as a hierarchical VAE [15] yielding a model akin to Doubly Stochastic Variational   \n93 Neural Process (DSNPV) [16], which uses global and node variables. Finally, Neural Processes   \n94 [17, 18] (NP) and other graph encoder-decoder models [6, 19, 20, 21, 22] are closely related to the   \n95 proposed model. ",
+        "bbox": [
+            143,
+            397,
+            825,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "96 3 Related work ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            583,
+            316,
+            599
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "97 GNN Encoder-decoder models In Neural Relational Inference (NRI) [6] discrete edge latent vari  \n98 ables are inferred from node representations and a re-parametrized $G u m b e l - S o f t m a x$ distribution   \n99 is used[23, 24]. A coarse representation of the computational graphs of NRI, NPs and the RVAE   \n100 is shown in Figure 1. In [19] graphs are modeled from global continuous latent variables, which   \n101 are subsequently used for graph generation through an adjacency matrix. In GraphVAE [20] the   \n102 global variable together with a graph-structured conditioning variable is used for generation. In   \n103 Graphite [21] a latent variable for each node is inferred from the encoder, while the edge variables   \n104 (i.e., symmetric adjacency matrix) is inferred through efficient iterated message passing. Similarly,   \n105 the VariationalGAE[22] uses a separate latent variable for every node and a graph convolutional   \n106 encoder. Several of the aforementioned works take advantage of recent advances in low-variance   \n107 gradient estimates for distributions over latent variables, as in Variational Autoencoders (VAEs) via   \n108 the reparametrization trick [7, 25]. The overlapping traits of the aforementioned are the treatment   \n109 of edge, node and global variables. In Table 1 a summary of the relational modeling capabilities of   \n110 various graph encoder-decoder models is offered. Note that the table highlights only the relevant   \n111 parts to this work together with several important and influential design choices for graph representa  \n112 tion learning were not touched upon. For instance, the graph convolutional models of some of the   \n113 aforementioned works offer the important advantage of scalability and small computation cost.   \n114 In this work, the above mentioned approaches, are generalized and unified in the proposed Relational   \n115 Variational Autoencoder (RVAE) model. Note that it is not difficult to yield explicit graph connectivity   \n116 in RVAE as in NRI [6] since the type and existence of a connection can be seen as a categorical   \n117 variable. See also Figure 1 (b), where a sketch of NRI is offered. Inferring graph connectivity or   \n118 generating graphs, however, falls out of the scope of this work. In RVAE the focus is generative   \n119 modeling of graph structured data with an apriori known connectivity, with attributed nodes and   \n120 edges, which optionally may include a global attribute that influences both entities and relations.   \n121 Neural processes In Neural Processes (NP)[17, 18], we consider a set of mappings $F : \\mathcal { X }  \\mathcal { V }$   \n122 where $\\bar { \\mathcal { X } } : \\{ x _ { i } \\}$ , $x _ { i } \\in \\mathbb { R } ^ { N _ { x } } , \\mathcal { Y } : \\{ y _ { i } \\}$ , $y _ { i } \\in \\mathbb { R } ^ { N _ { y } }$ . A particular draw of a function $f \\sim F$ , is modeled   \n123 as $f ( x _ { i } ) = g _ { \\boldsymbol { \\theta } } ( x _ { i } , z )$ where $z \\sim p ( z )$ is a high dimensional random vector (e.g. a standard normal)   \n124 and $g _ { \\theta }$ is a neural network and $\\theta$ denotes the parameters of $g$ . Given a set of $n _ { m }$ input-output   \n125 observations $\\mathcal { D } : \\{ ( x _ { 1 : n _ { m } } , y _ { 1 : n _ { m } } ) _ { f _ { m } } \\}$ from $m$ different realizations of $f$ (potentially different in   \n126 number), we want to learn a distribution over $z \\sim p ( z | \\mathcal { D } )$ . Under the NP approximation, assuming   \n127 observation noise $y _ { i } \\sim \\mathcal { N } ( g _ { \\boldsymbol { \\theta } } ( x _ { i } , z ) , \\sigma ^ { 2 } )$ , the distribution of $y$ is defined as ",
+        "bbox": [
+            140,
+            613,
+            825,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            90,
+            826,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/10ad2e48aee42de662b385616a97e049f2d6417d8ae470dd29a0480e66c1780f.jpg",
+        "table_caption": [
+            "Table 1: Features of different related Bayesian graph network encoder-decoder models (see also Figure 1). For the NP models that contain a latent variable, it is straightforward to combine a deterministic global encoder for the context inputs at test time [26]. The attributes with subscript $z$ denote that the model performs optimization using an ELBO objective. The attributes with superscript $h$ denote whether the models may facilitate deterministic conditioning for the corresponding graph attribute at test time. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Latent</td><td colspan=\"4\">Conditioning</td></tr><tr><td>Name</td><td>V</td><td>&amp;</td><td>Uz</td><td>Vh</td><td>8h</td><td>Uh</td><td>Architecture notes</td></tr><tr><td>CNP [17]</td><td></td><td></td><td></td><td>√</td><td>1</td><td>√</td><td>DeepSet encoder,GN node block</td></tr><tr><td>AttCNP [27]</td><td></td><td></td><td></td><td>1</td><td>√</td><td>(</td><td>Attention encoder/decoder</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>Decoder edge cond. through cross-attention</td></tr><tr><td>ConvCNP [28]</td><td></td><td></td><td></td><td></td><td></td><td>（√</td><td>SetConv encoder</td></tr><tr><td></td><td>NP[18]</td><td></td><td></td><td></td><td></td><td></td><td>DeepSet encoder</td></tr><tr><td>GraphVAE [20]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>Graph conv. encoder</td></tr><tr><td>VariationalGAE [22]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>Graph convolutions Iterative decoder</td></tr><tr><td>Graphite [21]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>MP encoder/decoder</td></tr><tr><td>NRI [6] MPNP [29]</td><td></td><td></td><td></td><td></td><td></td><td>√</td><td>MP encoder/decoder</td></tr><tr><td>DSVNP [16]</td><td></td><td></td><td></td><td></td><td></td><td></td><td>V²~p(V²|u²,V*，Vh*)</td></tr><tr><td>RVAE (this work)</td><td></td><td></td><td></td><td></td><td></td><td>一</td><td>MP encoder/decoder</td></tr></table>",
+        "bbox": [
+            173,
+            234,
+            813,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            457,
+            825,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72994697792c71c09f1de48a21563508e791c74a908d41134a615f537e300727.jpg",
+        "text": "$$\np ( z , y _ { 1 : n } | x _ { 1 : n } ) = p ( z ) \\prod _ { j = 1 } ^ { n } { \\mathcal { N } } ( y _ { i } | g ( x _ { i } , z ) , \\sigma ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            561,
+            651,
+            604
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "128 In practice, the input-output observation cases $\\mathcal { D }$ , are split as $\\mathcal { D } ^ { C \\cup T } = \\mathcal { D } ^ { C } \\cup \\mathcal { D } ^ { T }$ , where $C$ denotes   \n129 a set of points with observations in $\\mathcal { X }$ and $\\mathcal { V }$ and $T$ denotes a set of points where we only observe   \n130 $\\mathcal { X }$ (i.e., the inputs). This can be cast as a conditional generative model for $p ( y _ { T } | x _ { T } , x _ { C } , y _ { C } ) =$   \n131 $p _ { \\boldsymbol { \\theta } } ( y _ { T } | x _ { T } , z ) p ( z | x _ { C } , y _ { C } )$ , where the conditioning is the fully observed context pairs. The ELBO   \n132 used for optimization is ",
+        "bbox": [
+            142,
+            611,
+            825,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0fcbea3d811573f3c9bede9fb6760b5c9fb916aec55ba779e746137ae629ad53.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\displaystyle \\log p ( y _ { T } | x _ { T } , x _ { C } , y _ { C } ) \\geq \\mathbb { E } _ { q _ { \\phi } ( z | \\mathcal { D } ^ { C \\cup T } ) } \\Big [ \\displaystyle \\sum _ { i \\in T } \\log p _ { \\theta } ( y _ { i } | z , x _ { i } ) + \\log \\frac { q ( z | \\mathcal { D } ^ { C } ) } { q ( z | \\mathcal { D } ^ { C \\cup T } ) } \\Big ] } \\\\ & { \\displaystyle \\mathbb { E } _ { q _ { \\phi } ( z | \\mathcal { D } ^ { C \\cup T } ) } \\Big [ \\displaystyle \\sum _ { i \\in T } \\log p _ { \\theta } ( y _ { i } | z , x _ { i } ) \\Big ] - D _ { K L } ( q _ { \\phi } ( z | \\mathcal { D } ^ { C \\cup T } ) | | q _ { \\phi } ( z | \\mathcal { D } ^ { C } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            689,
+            805,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "133 Note that the above variational objective has an intuitive interpretation, as a reconstruction loss (first   \n134 part) and a Kullback-Leibler divergence between the approximate posterior distributions predicted   \n135 when using both $C \\cup T$ and when using only $C$ (the context set). In [30] a similar loss function was   \n136 proposed with the motivation of training VAEs that can be used with arbitrary conditioning masks. By   \n137 considering the set of observations as nodes in a disconnected graph, (i.e., $\\mathcal { V } : \\{ \\mathbf { v } _ { i } | ( x _ { i } , y _ { i } ) \\} _ { i = 1 : N ^ { v } } )$   \n138 and training while masking the context output nodes $y _ { C }$ , the same objective is retrieved. Therefore,   \n139 following the nomenclature of [2], we can instantiate a NP from the proposed model, by using   \n140 arbitrary conditioning as described in [30], a DeepSet [31] as an encoder and only a node-block as a   \n141 decoder as shown in Figure 1.   \n142 The NP framework has been extended to take advantage of special inductive biases, such as the   \n143 relation of observation and target nodes in Attentive Conditional Neural Processes (AttNP) [27] or   \n144 the translation equivariance in Convolutional Conditional Neural Processes (ConvCNP) [28]. More   \n145 recently, relational inductive biases were employed in Message Passing Neural Processes (MPNP)   \n146 [29]. The aforementioned models, feature a global latent variable $\\mathbf { u } _ { z }$ which is inferred from the   \n147 context points and parametrizes the distribution over functions. With the exception of MPMP, the   \n148 aforementioned works target non-relational data. Nevertheless, MPMPs does not directly implement   \n149 edge-bound uncertainty or edge-level conditioning, which is the most pronounced difference to RVAE.   \n150 Similar to this work, in DSNPV [16] a NP that allows for both node and global latent variables   \n151 was proposed, which in addition, employs a hierarchical VAE [15]. The motivation of DSNPV is   \n152 to include node-context information, which in the conditional RVAE is also supported by design   \n153 through $\\nu _ { h }$ . RVAE attempts to merge the complementary strengths of the aforementioned models   \n154 in representation of uncertainty, with a focus towards modeling graph structured continuous data.   \n155 Finally, in contrast to Functional Neural Processes [32] we do not deal with inferring a graph of   \n156 dependencies among latent variables, yet hierarchical RVAE adaptations may also manage such tasks.   \n157 Graph Gaussian processes Sharing the motivation of this work, i.e., taking advantage of relational   \n158 information and learning joint distributions of graph structured data, in [33] GPs were defined over   \n159 graphs with undirected binary (positive or negative) edges and applied to semi-supervised learning   \n160 problems. In [34] the authors applied GPs trained with variational approximations for semi-supervised   \n161 learning on graphs that contain non-attributed edges. In [35] GP-based approaches are fused with   \n162 deep learning for learning graph (e.g. network) structured signals. ",
+        "bbox": [
+            140,
+            786,
+            826,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/f9b2f90cfee33fc44edc539654a97951af1663b693c359d8d3329e80114e4a3c.jpg",
+        "image_caption": [
+            "Figure 1: (a) Proposed architecture with a single message passing step in the encoder and decoder (b) the Neural Relational Inference model of [6]. (c) The Neural Process model [18]. For direct correspondence between the present work and [6] and [18] the notations of the other works are included in the figure (e.g. $\\rho ^ { \\mathbf { v }  \\mathbf { u } } = \\mathbf { a }$ in the Neural Process model). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            88,
+            794,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            404,
+            825,
+            609
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            626,
+            825,
+            709
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Results ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            729,
+            266,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Wind farm operational data ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            761,
+            408,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "165 A real-world industrial application, where relational structure is inherent in the observed data, is   \n166 found in modeling of operational data of wind turbines positioned in a farm. The wind turbines   \n167 (nodes) feature static variables, such as their power production characteristics and their position,   \n168 as well as dynamic variables such as their current operational state. The actual operational state   \n169 of a turbine is only known up to a certain precision from historical data, (i.e., Supervisory Control   \n170 and Data Acquisition (SCADA) data), which is usually limited to 10 minute statistics. Due to   \n171 the stochasticity of the wind excitation, compounded by incomplete information due to coarse   \n172 measurements, there is uncertainty associated with the actual operational state of a wind turbine.   \n173 Wind turbines arranged in a wind farm interact through the so-called wakes, which are travelling   \n174 vortices that affect the power production and vibrations of downstream turbines. The magnitude   \n175 of wake effects is related to large scale turbulence (which is a global dynamic variable), to wind   \n176 orientation (which is a global dynamic variable), to upwind turbine nacelle orientation (which is a   \n177 node dynamic variable), the relative position between the two turbines (an edge static variable), the   \n178 rotor diameter and the distance between the two turbines. The interaction is one-way directional but   \n179 can change directionality depending on the wind orientation. The effect of wakes is stochastic due to   \n180 turbulence. For robust wind power prediction, monitoring, control, and maintenance planning, we   \n181 want to infer the distribution of operational characteristics of a wind farm conditioned on turbine   \n182 characteristics and farm layout. Of crucial importance is the inclusion of stochastic variables in   \n183 the interactions (i.e., edges) of the considered graph. Static graph edges, used as part of the graph   \n184 conditioning, are constructed by considering the spatial proximity and relative position of pairs of   \n185 turbines. The goal is to generalize directly to unseen farm configurations while learning directly on   \n186 real condition monitoring data (zero-shot generalization) but at the same time to yield uncertainty   \n187 estimates.   \n188 Graph machine learning in wind farm modeling In [36] a GNN was trained on simulated data   \n189 for wind power prediction. Recently, in [37] GNNs were applied as a surrogate model to more   \n190 accurate fluid dynamic simulations. With the architectural advancements proposed in this work, we   \n191 extend the wind farm relational modeling literature by providing a solution for representation of   \n192 uncertainty in wind turbine interactions. Moreover, we empirically show in real wind farm data that   \n193 significant accuracy improvements are possible through the incorporation of the proposed relational   \n194 modeling and variational Bayes approach. ",
+        "bbox": [
+            143,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            92,
+            825,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            299,
+            825,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/59c35cc8b2e77c5e7a065a0bb9e074613b9092de99fed3c3a6901f5eec69b2db.jpg",
+        "image_caption": [
+            "Figure 2: Imputation qualitative results for wind speed. The imputed points are marked with a dark $1 / N ^ { T } \\sum _ { i = 1 } ^ { N ^ { T } } ( | \\mathbf { v } _ { i } ^ { T } - \\hat { \\mathbf { v } _ { i } } ^ { T } | ) / | \\mathbf { v } _ { i } ^ { T } |$ mean awhere $\\mathbf { v } _ { i } ^ { T }$ lute percentage error is repis the actual value of node $i$ rt, $N ^ { T }$ which is computed asthe number of target turbines and $\\hat { \\mathbf { v } } _ { i }$ is the CRVAE prediction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            405,
+            825,
+            505
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "195 4.2 Real wind farm SCADA dataset ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            595,
+            434,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "196 Conditional RVAE models (CRVAE) were trained with with a 80/20 train/test split on a dataset that   \n197 includes 6 months of 10-minute average SCADA data readings. Since the goal is to compare the   \n198 fitting capability of the models and not model selection, no validation set was employed. Early   \n199 stopping with patience of 2500 steps was used (test set evaluation every 500 steps). The larger RVAE   \n200 models that also yield the best performance had not converged at the 10th epoch. The $20 \\%$ of turbine   \n201 data are randomly masked during training. A batch size of 16 was used for all models. In order   \n202 to make a fair comparison no regularization or KL-annealing was used. A small learning rate of   \n203 $5 \\cdot 1 0 ^ { - 5 }$ and the Adam optimizer [38] with default parameters was used for all the runs. The final   \n204 ELBOs for all models are shown in Table 2. A mean aggregation function and composite aggregation   \n205 function consisting of a concatenation of mean,max and min aggregators were used. Due to the   \n206 concatenation operation, the composite aggregators result in slightly larger networks. Aligned with   \n207 recent results on GN performance when using composite aggregation functions [39] we find that   \n208 networks with the $m e a n - m a x - m i n$ aggregator indeed yield better performance. The motivation,   \n209 however, for using composite aggregators, is also due to the physics of the problem. By using   \n210 such aggregators it is easier to discriminate the un-waked part of the farm and the waked turbines.   \n211 More concretely, turbines at the upstream boundary of the farm have larger power production and   \n212 this directional effect can easily be masked using the mean aggregation. The CRVAE models are   \n213 compared to a two-layer MLP-based CVAE trained with the arbitrary conditioning objective [30] of   \n214 varying sizes, with the largest CVAE model number of parameters corresponding to the number of   \n215 parameters of the best performing RCVAE. The largest CVAE model was the worst-performing of   \n216 the evaluated CVAE models.   \n217 The CVAE model with the smallest size has slightly better performance compared to the RVAE model   \n218 that performs no message passing on the encoder part, and therefore ignores relational inductive   \n219 biases when inferring $G _ { z }$ . All but one of the CRVAE models strongly outperform the CVAE models   \n220 by a large margin which is attributed to the effective use of relational inductive biases. To further   \n221 support this claim, in the supplemental material (section A.1) gradient sensitivities are plotted and it   \n222 is observed that the imputation results for masked turbines depend on upstream turbines. Qualitative   \n223 imputation results are shown in Figure 2.   \n224 Effect of inferring edge latents $\\mathcal { E } _ { z }$ The introduction of   \n225 continuous edge-related latent variables is overlooked in a   \n226 large part of the literature. Wake effect modeling is an appli  \n227 cation that may benefit from edge latent variables. We test   \n228 the effect of edge latent variables by setting $\\beta \\varepsilon = 0$ while   \n229 still using $G _ { h }$ . The results of this experiment are shown in   \n230 Table 3. The inclusion of the KL term with respect to edge   \n231 latent variables seems to improve the reconstruction error   \n232 achieved by the model. ",
+        "bbox": [
+            138,
+            621,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            92,
+            825,
+            189
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/7c234176bb1bea40f3672c4afb90f3ed2cf97e51d81c5efe52b8aae63eb18b97.jpg",
+        "table_caption": [
+            "Table 2: Test set ELBO on Anholt SCADA dataset after 10 epochs. Numbers in parentheses are the standard deviations of the ELBO estimates in the test set (higher is better). The same node, edge and global latent sizes were used $( N ^ { G _ { z } } )$ . “(comp.)” stands for the composite mean-max-min aggregator. All MLPs are 3 layer ReLU MLPs. The ·∗ superscript denotes results that were not derived from early stopping. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td colspan=\"2\">MP Steps</td><td></td><td></td><td></td></tr><tr><td>Model</td><td>mlp units</td><td>NGz size</td><td>enc.</td><td>dec.</td><td>agg.</td><td># params</td><td>ELBO</td></tr><tr><td>CRVAE</td><td>64</td><td>32</td><td>0</td><td>1</td><td>mean</td><td>184,717</td><td>1.96, (0.30)</td></tr><tr><td></td><td>64</td><td>32</td><td>1</td><td>1</td><td>mean</td><td>341,517</td><td>6.99(0.29)</td></tr><tr><td></td><td>64</td><td>32</td><td>2</td><td>2</td><td>mean</td><td>498,317</td><td>7.48(0.61)*</td></tr><tr><td></td><td>64</td><td>32</td><td>2</td><td>2</td><td>(comp.)</td><td>522,893</td><td>8.11(0.48)*</td></tr><tr><td></td><td>64</td><td>32</td><td>3</td><td>3</td><td>(comp.)</td><td>679,693</td><td>7.70(0.53)*</td></tr><tr><td>CVAE</td><td>128</td><td>64</td><td>1</td><td>1</td><td>1</td><td>77,194</td><td>2.12(0.10)</td></tr><tr><td></td><td>256</td><td>64</td><td></td><td></td><td></td><td>252,554</td><td>1.17(0.16)</td></tr><tr><td></td><td>384</td><td>96</td><td>1</td><td>1</td><td>1</td><td>563,146</td><td>1.23(0.09)</td></tr></table>",
+        "bbox": [
+            223,
+            276,
+            771,
+            434
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            454,
+            553,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ec650ffd8465f4aa5a107af9aaec7b73574bb0624cb3569348f807dec7f84a20.jpg",
+        "table_caption": [
+            "Table 3: Effect of edge latent variables. Results based on 3 runs for each case. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Case</td><td>log p(Vx|Gz; Gh)</td><td>Range</td></tr><tr><td>βε=1.</td><td>4.16</td><td>±0.43</td></tr><tr><td>βε=0.</td><td>1.80</td><td>±1.21</td></tr></table>",
+        "bbox": [
+            565,
+            507,
+            823,
+            560
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Wind farm simulation dataset ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            594,
+            419,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The steady-state wind farm wake simulator FLORIS [40] was used. A dataset of wake effect simulations and preprocessing tools for demonstrating the wind farm modeling approach adopted herein is released as part of this work. In what follows we test the generalization capabilities of a trained RVAE to novel geometric configurations. A single farm configuration is used for training and another one is used for testing. Both farms are simulated with random wind characteristics such as direction and average wind speed. An example output from the simulation can be found in the supplemental material. The train and test farm configurations can also be found in the supplemental material. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            731
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "242 Qualitative results The RVAE model is able to capture the orientation-dependent wake deficit for   \n243 each turbine separately on the test wind farm as shown in Figure 3. Furthermore, we use a single   \n244 turbine as a probe and position it on a regular grid while keeping a turbine on a fixed position (0,0).   \n245 By inspecting the wind speed predicted at the probe turbine, we can map the wake deficit in 2D   \n246 behind the source turbine. This is shown in Figure 4. The spatial dependence of the wake deficit   \n247 is also shown as computed from FLORIS and the error in RVAE estimation. For distances larger   \n248 than $2 0 0 m$ the wind deficit is accurately predicted. Note that this result is from a model trained on   \n249 operational data from a single simulated windfarm. When the turbines are very close $( < 2 0 0 m )$ the   \n250 wakes are not predicted correctly, but this is an expected effect since the RVAE never encounters   \n251 turbines at these distances. Wake effects estimated with the RVAE are slightly lower than those   \n252 derived from the simulation as shown in Figure 3. However, the RVAE seems to capture the intricate   \n253 wind orientation-dependent effects which depend on the farm layout. ",
+        "bbox": [
+            143,
+            746,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/87f6d9ba7058695e4094797f2696b02e9a820b723ef89e0b8fa9b11d7ab31be8.jpg",
+        "image_caption": [
+            "Figure 3: Wind deficits on the simulated test farm and estimates from the trained RVAE. Each point associated with a turbine is plotted in a 2D polar coordinate system centered on the turbine. Each point is plotted towards the orientation of the incoming wind. The distance from the origin is proportional to the wake deficit, estimated as $m a x ( v ) - v$ where $v$ is mean power and mean wind. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            316,
+            94,
+            669,
+            266
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b971b0c04d9fe82c4183b0a3ca6b4e4e6ab2811ac83fa2b7a8ab9a1daf33942.jpg",
+        "image_caption": [
+            "Figure 4: Learned spatial distribution of wake related wind speed deficit, evaluated as $w _ { ( 0 , 0 ) } - w _ { ( x , y ) }$ where $w _ { ( 0 , 0 ) }$ is the the wind speed at the up-wind turbine and $( x , y )$ denotes the wind speed for a probe turbine positioned at $w _ { ( x , y ) }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            359,
+            745,
+            527
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "254 4.4 1D regression ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            608,
+            308,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "255 In order to further demonstrate the versatility of the RVAE in modeling structured data, and in   \n256 order to make the connection to NPs [18] clearer, in what follows an RVAE adapted for node data   \n257 imputation is presented [30]. The dataset consists of sets of points sampled from a zero-mean 1D   \n258 Gaussian process with a squared exponential kernel. The pairs of input points $\\left\\{ ( x _ { 1 : n _ { m } } , y _ { 1 : n _ { m } } ) _ { m } \\right\\}$   \n259 are used as node features to construct a set of context and target graphs, where $m$ corresponds to   \n260 different GP realizations. Each graph contains a set of edges $\\mathbf { e } _ { i }$ which encode the relative position   \n261 of the observation points. The edge features between observations at points $x _ { i } , x _ { j }$ are defined as   \n262 $f ( x _ { i } , x _ { j } ) = e ^ { - c \\cdot | x _ { i } - x _ { j } | ^ { 2 } }$ where $c$ is a function of the cutoff distance for edge creation. Note that   \n263 the construction of such edge features endows the model with translation equivariance. In contrast   \n264 to MPNPs, [29], the edges are the same in the context and target graphs. The loss function used   \n265 is the same as in Equation 10. Both $p _ { \\phi }$ and $q _ { \\theta }$ are implemented as GNs. The outputs of the GNs   \n266 parameterize a Gaussian, i.e., ",
+        "bbox": [
+            140,
+            632,
+            825,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd04d4964209cc8ba9a77a834cf0ae56ace94470f7c7223fef3fe00b8ccc4efa.jpg",
+        "text": "$$\n\\begin{array} { r } { q _ { \\phi } ( z | \\mathcal { D } ) = \\mathcal { N } ( \\mu _ { \\phi } ( \\mathcal { D } ) , \\sigma _ { \\phi } ^ { 2 } ( \\mathcal { D } ) ) , \\quad p _ { \\theta } ( y | \\mathcal { D } ) = \\mathcal { N } ( \\mu _ { \\theta } ( \\mathcal { D } ) , \\sigma _ { \\theta } ^ { 2 } ( \\mathcal { D } ) ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            809,
+            714,
+            829
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "267 The $y$ values of $\\mathcal { D } ^ { T }$ are replaced with 0 when fed through the encoder and an additional binary feature   \n268 $b$ for the node, which denotes masking, is appended to the node tuple. The $b$ feature is zero for the   \n269 unmasked nodes and 1 for the masked nodes. The masked input is denoted by $\\mathcal { D } ^ { T \\backslash b }$ . The union of   \n270 the masked target input with the context dataset is denoted by $D ^ { T \\setminus b \\cup C }$ . Instead of using two different   \n271 functions for the prior of $p ( z | \\mathcal { D } ^ { T \\setminus b \\cup C } )$ as in [30], and posterior network $q ( \\boldsymbol { z } | \\mathcal { D } ^ { T \\cup C } )$ and in order to   \n272 keep the conditional RVAE model closer to the NP formulation, the approximate posterior (i.e., the   \n273 encoder of the RVAE) is used also for the learned prior. The decoder $p _ { \\theta }$ receives as node conditioning   \n274 (and optionally edge conditioning) the $x _ { T }$ values and the global latent variable $\\mathbf { u } ^ { z }$ . Each realization   \n275 of $\\mathbf { u } ^ { z }$ corresponds to a different context set which in turn corresponds to a different sampled $G P$   \n276 More information about he training setup can be found in the appendix.   \n277 The NP is implemented by defining a DeepSet encoder, a global latent variable of the same size   \n278 as the NP MLP. The same latent variable size for nodes and edges was used for each experiment,   \n279 which is the same as the core size. All aggregation functions are mean aggregations. Experiments   \n280 were performed with different number of message passing steps, and inclusion of either the relative   \n281 observation position as an edge feature or the absolute node position $x _ { i }$ for each feature. The models   \n282 are tested in un-seen GP realizations and the negative log-likelihood of predictions are reported in   \n283 Table 4. The RVAE models compute edge, node and global variables. The test datasets contain points   \n284 with $x \\in [ 0 , 1 ]$ and $x \\in [ 1 , 2 ]$ ranges in order to test the generalization capability of the proposed   \n285 model in translation. Since the edge-blocks only ever receive translation equivariant inputs from   \n286 the dataset, the RVAE models generalize well in the $x \\in [ 1 , 2 ]$ range. This is presented only as an   \n287 example of how special equivariant inductive biases may be implemented in RVAE. It is observed   \n288 that the full RVAE model does not perform well when only the node features are available. As with   \n289 NPs, it was empirically found that models yield better results with more training. ",
+        "bbox": [
+            140,
+            837,
+            825,
+            912
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            166,
+            825,
+            347
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/eff8014dfa6670206106b65a615a8c711fe70ef64cdd9cd3cdc4dcd5c996d1d8.jpg",
+        "table_caption": [
+            "Table 4: Test set log likelihoods on 1D GP regression with Conditional RVAE. The results are based on a set of 5000 unseen GP samples, each with 50 context and 50 target points. The models were trained only on points with x in the [0, 1] range. Values in parentheses are standard deviations of the mini-batches. RVAE denotes a model where all latent variables are used (edge node and global). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>size (mlp/z/MP Steps)</td><td colspan=\"2\">Only cond. on nodes Gh =(Vh,·,·）</td><td colspan=\"2\">Cond. on edges and nodes Gh=(Vh,Eh,)</td></tr><tr><td></td><td></td><td>x ∈ [0,1]</td><td>x∈[1,2]</td><td>x ∈ [0,1]</td><td>x∈[1,2]</td></tr><tr><td>CRVAE</td><td>64/64/0</td><td>−17.94(3.11)</td><td>-24.59(4.10)</td><td>0.33(0.04)</td><td>-0.21(0.13)</td></tr><tr><td></td><td>64/64/1</td><td>-12.55(2.51)</td><td>−9.79(2.51)</td><td>0.36(0.07)</td><td>0.08(0.06)</td></tr><tr><td></td><td>64/64/2</td><td>1</td><td></td><td>0.98(0.09)</td><td>0.67(0.08)</td></tr><tr><td>NP</td><td>64/64/NA</td><td>−1.34(0.07)</td><td>−11.13(3.08)</td><td>NA</td><td>NA</td></tr><tr><td></td><td>128/128/NA</td><td>−1.08(0.11)</td><td>-31.74(14.08)</td><td>NA</td><td>NA</td></tr></table>",
+        "bbox": [
+            196,
+            429,
+            797,
+            554
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "290 Conclusions and broader impact ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            595,
+            447,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "291 This work introduces an attributed graph approach to the probabilistic modeling of relations within   \n292 entities and their properties. The approach is verified and validated on wake effect simulations and   \n293 actual data from wind turbines placed within a wind farm; a characteristic example that may be   \n294 modeled as a graph. We also find some connections to the NP literature which we demonstrate by   \n295 adapting the proposed method to perform a typical NP benchmark which is 1D regression for GP   \n296 data.   \n297 We introduce a method for data-driven wake effect modeling for wind farms that accounts for uncer  \n298 tainty. The proposed method fuses physical intuition, flexible function approximation through GNs,   \n299 and variational Bayes through re-parametrized gradients. Better and more computationally efficient   \n300 wake effect modeling can lead to improvements in terms of accuracy and computational efficiency in   \n301 analysis for wind farm siting [41] farm layout optimization [42], wind farm control optimization [43]   \n302 and ultimately power production improvements, as well as more robust to uncertainties maintenance   \n303 planning. Ultimately, the aforementioned lead to wind energy being a more attractive clean energy   \n304 solution.   \n305 Graph data are naturally used to model social, transportation and communication networks. Possible   \n306 negative implications of any graph ML work relate to possible malicious uses of analysis in such   \n307 networks, such as de-anonymization in social networks [44], and vulnerability exploitation on   \n308 transportation networks. ",
+        "bbox": [
+            150,
+            631,
+            825,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            720,
+            825,
+            832
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            838,
+            825,
+            893
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272. PMLR, 2017.   \n[2] Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018.   \n[3] Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter Battaglia. Learning to simulate complex physics with graph networks. In Hal Daumé III and Aarti Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 8459–8468. PMLR, 13–18 Jul 2020.   \n[4] Tobias Pfaff, Meire Fortunato, Alvaro Sanchez-Gonzalez, and Peter W Battaglia. Learning mesh-based simulation with graph networks. arXiv preprint arXiv:2010.03409, 2020.   \n[5] Vinicius Zambaldi, David Raposo, Adam Santoro, Victor Bapst, Yujia Li, Igor Babuschkin, Karl Tuyls, David Reichert, Timothy Lillicrap, Edward Lockhart, et al. Relational deep reinforcement learning. arXiv preprint arXiv:1806.01830, 2018.   \n[6] Thomas Kipf, Ethan Fetaya, Kuan-Chieh Wang, Max Welling, and Richard Zemel. Neural relational inference for interacting systems. In International Conference on Machine Learning, pages 2688–2697. PMLR, 2018.   \n[7] Diederik P Kingma and Max Welling. Auto-encoding bariational bayes. arXiv preprint arXiv:1312.6114, 2013.   \n[8] 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. 2016.   \n[9] Alexander Alemi, Ben Poole, Ian Fischer, Joshua Dillon, Rif A. Saurous, and Kevin Murphy. Fixing a broken ELBO. In Jennifer Dy and Andreas Krause, editors, Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 159–168. PMLR, 10–15 Jul 2018.   \n[10] Samuel R Bowman, Luke Vilnis, Oriol Vinyals, Andrew M Dai, Rafal Jozefowicz, and Samy Bengio. Generating sentences from a continuous space. arXiv preprint arXiv:1511.06349, 2015.   \n[11] Hao Fu, Chunyuan Li, Xiaodong Liu, Jianfeng Gao, Asli Celikyilmaz, and Lawrence Carin. Cyclical annealing schedule: A simple approach to mitigating kl vanishing. arXiv preprint arXiv:1903.10145, 2019.   \n[12] Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In Francis Bach and David Blei, editors, Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pages 1530–1538, Lille, France, 07–09 Jul 2015. PMLR.   \n[13] Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.   \n[14] Jenny Liu, Aviral Kumar, Jimmy Ba, Jamie Kiros, and Kevin Swersky. Graph normalizing flows. arXiv preprint arXiv:1905.13177, 2019.   \n[15] Casper Kaae Sønderby, Tapani Raiko, Lars Maaløe, Søren Kaae Sønderby, and Ole Winther. Ladder variational autoencoders. arXiv preprint arXiv:1602.02282, 2016.   \n[16] Qi Wang and Herke Van Hoof. Doubly stochastic variational inference for neural processes with hierarchical latent variables. In International Conference on Machine Learning, pages 10018–10028. PMLR, 2020.   \n[17] Marta Garnelo, Dan Rosenbaum, Christopher Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo Rezende, and SM Ali Eslami. Conditional neural processes. In International Conference on Machine Learning, pages 1704–1713. PMLR, 2018.   \n[18] Marta Garnelo, Jonathan Schwarz, Dan Rosenbaum, Fabio Viola, Danilo J Rezende, SM Eslami, and Yee Whye Teh. Neural processes. arXiv preprint arXiv:1807.01622, 2018.   \n[19] Mohammadamin Tavakoli and Pierre Baldi. Continuous representation of molecules using graph variational autoencoder. arXiv preprint arXiv:2004.08152, 2020.   \n[20] Martin Simonovsky and Nikos Komodakis. Graphvae: Towards generation of small graphs using variational autoencoders. In International Conference on Artificial Neural Networks, pages 412–422. Springer, 2018.   \n[21] Aditya Grover, Aaron Zweig, and Stefano Ermon. Graphite: Iterative generative modeling of graphs. In International conference on machine learning, pages 2434–2444. PMLR, 2019.   \n[22] Thomas N Kipf and Max Welling. Variational graph auto-encoders. arXiv preprint arXiv:1611.07308, 2016.   \n[23] Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016.   \n[24] Chris J Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A continuous relaxation of discrete random variables. arXiv preprint arXiv:1611.00712, 2016.   \n[25] Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In International conference on machine learning, pages 1278–1286. PMLR, 2014.   \n[26] Yann Dubois, Jonathan Gordon, and Andrew YK Foong. Neural process family. http://yanndubs. github.io/Neural-Process-Family/, September 2020.   \n[27] Hyunjik Kim, Andriy Mnih, Jonathan Schwarz, Marta Garnelo, Ali Eslami, Dan Rosenbaum, Oriol Vinyals, and Yee Whye Teh. Attentive neural processes. arXiv preprint arXiv:1901.05761, 2019.   \n[28] Jonathan Gordon, Wessel P Bruinsma, Andrew YK Foong, James Requeima, Yann Dubois, and Richard E Turner. Convolutional conditional neural processes. arXiv preprint arXiv:1910.13556, 2019.   \n[29] Ben Day, Cat˘ alina Cangea, Arian R Jamasb, and Pietro Liò. Message passing neural processes. ˘ arXiv preprint arXiv:2009.13895, 2020.   \n[30] Oleg Ivanov, Michael Figurnov, and Dmitry Vetrov. Variational autoencoder with arbitrary conditioning. arXiv preprint arXiv:1806.02382, 2018.   \n[31] Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan Salakhutdinov, and Alexander Smola. Deep sets. arXiv preprint arXiv:1703.06114, 2017.   \n[32] Christos Louizos, Xiahan Shi, Klamer Schutte, and Max Welling. The functional neural process. arXiv preprint arXiv:1906.08324, 2019.   \n[33] Wei Chu Vikas Sindhwani, Zoubin Ghahramani, and S Sathiya Keerthi. Relational learning with gaussian processes. In Advances in Neural Information Processing Systems 19: Proceedings of the 2006 Conference, volume 19, page 289. MIT Press, 2007.   \n[34] Yin Cheng Ng, Nicolò Colombo, and Ricardo Silva. Bayesian semi-supervised learning with graph gaussian processes. arXiv preprint arXiv:1809.04379, 2018.   \n[35] Naiqi Li, Wenjie Li, Jifeng Sun, Yinghua Gao, Yong Jiang, and Shu-Tao Xia. Stochastic deep gaussian processes over graphs. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 5875–5886. Curran Associates, Inc., 2020.   \n[36] Junyoung Park and Jinkyoo Park. Physics-induced graph neural network: An application to wind-farm power estimation. Energy, 187:115883, 2019.   \n[37] James Bleeg. A graph neural network surrogate model for the prediction of turbine interaction loss. In Journal of Physics: Conference Series, volume 1618, page 062054. IOP Publishing, 2020.   \n[38] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \n[39] Gabriele Corso, Luca Cavalleri, Dominique Beaini, Pietro Liò, and Petar Velickovi ˇ c. Principal neighbour- ´ hood aggregation for graph nets. arXiv preprint arXiv:2004.05718, 2020.   \n[40] NREL. FLORIS. Version 2.2.0, 2020.   \n[41] JK Lundquist, KK DuVivier, D Kaffine, and JM Tomaszewski. Costs and consequences of wind turbine wake effects arising from uncoordinated wind energy development. Nature Energy, 4(1):26–34, 2019.   \n[42] Nicolas Kirchner Bossi and Fernando Porté-Agel. Multi-objective wind farm layout optimization with unconstrained area shape. In Wind Energy Science Conference 2019 (WESC 2019), number POST_TALK, 2019.   \n[43] Michael F Howland, Sanjiva K Lele, and John O Dabiri. Wind farm power optimization through wake steering. Proceedings of the National Academy of Sciences, 116(29):14495–14500, 2019.   \n[44] Shouling Ji, Prateek Mittal, and Raheem Beyah. Graph data anonymization, de-anonymization attacks, and de-anonymizability quantification: A survey. IEEE Communications Surveys & Tutorials, 19(2):1305–1326, 2016. ",
+        "bbox": [
+            147,
+            65,
+            828,
+            920
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            158,
+            60,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            155,
+            92,
+            826,
+            214
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            238,
+            254,
+            255
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            265,
+            330,
+            277
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] As noted in section 3 the main limitation of RVAE is that it cannot be used directly as a graph generation model.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            240,
+            282,
+            825,
+            367
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            369,
+            467,
+            383
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            240,
+            387,
+            691,
+            416
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            421,
+            377,
+            434
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [TODO]The code and dataset will be shared within the deadline for providing supplemental materials.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] see subsection 4.4 and subsection 4.2   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A] For experiments in Table 1 and Table 2 the standard deviation of the batch statistics for a single run are reported since the differences of the models were pronounced. For the results in Table 3 the statistics reported are based on 3 independent runs.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] All reported experiments were run on a personal desktop running Ubuntu 20.04, with an nVidia RTX2080 GPU and 16GB of RAM. ",
+        "bbox": [
+            240,
+            438,
+            825,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            602,
+            766,
+            614
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] Orsted energy, formerly known as Dong energy provided us with a proprietary SCADA dataset for the Anholt farm.   \n(b) Did you mention the license of the assets? [Yes] The Anholt SCADA dataset was made available to us under an non-disclosure agreement. The simulated wind farm dataset will be released under the CC-BY 4.0 license.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            240,
+            619,
+            825,
+            756
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            760,
+            658,
+            773
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            240,
+            777,
+            825,
+            859
+        ],
+        "page_idx": 11
+    }
+]

parse/train/rJg8yhAqKm/rJg8yhAqKm.md

@@ -0,0 +1,421 @@
+# INFOBOT: TRANSFER AND EXPLORATION VIA THE INFORMATION BOTTLENECK
+
+Anirudh Goyal1, Riashat Islam2, Daniel Strouse3, Zafarali Ahmed2, Matthew Botvinick3, 5, Hugo Larochelle1, 4, Yoshua Bengio1, Sergey Levine6
+
+# ABSTRACT
+
+A central challenge in reinforcement learning is discovering effective policies for tasks where rewards are sparsely distributed. We postulate that in the absence of useful reward signals, an effective exploration strategy should seek out decision states. These states lie at critical junctions in the state space from where the agent can transition to new, potentially unexplored regions. We propose to learn about decision states from prior experience. By training a goal-conditioned policy with an information bottleneck, we can identify decision states by examining where the model actually leverages the goal state. We find that this simple mechanism effectively identifies decision states, even in partially observed settings. In effect, the model learns the sensory cues that correlate with potential subgoals. In new environments, this model can then identify novel subgoals for further exploration, guiding the agent through a sequence of potential decision states and through new regions of the state space.
+
+# 1 INTRODUCTION
+
+Deep reinforcement learning has enjoyed many recent successes in domains where large amounts of training time and a dense reward function are provided. However, learning to quickly perform well in environments with sparse rewards remains a major challenge. Providing agents with useful signals to pursue in lieu of environmental reward becomes crucial in these scenarios. In this work, we propose to incentivize agents to learn about and exploit multi-goal task structure in order to efficiently explore in new environments. We do so by first training agents to develop useful habits as well as the knowledge of when to break them, and then using that knowledge to efficiently probe new environments for reward.
+
+We focus on multi-goal environments and goal-conditioned policies (Foster and Dayan, 2002; Schaul et al., 2015; Plappert et al., 2018). In these scenarios, a goal $G$ is sampled from $p ( G )$ and the beginning of each episode and provided to the agent. The goal $G$ provides the agent with information about the environment’s reward structure for that episode. For example, in spatial navigation tasks, $G$ might be the location or direction of a rewarding state. We denote the agent’s policy $\pi _ { \theta } ( A \mid S , G )$ , where $S$ is the agent’s state, $A$ the agent’s action, and $\theta$ the policy parameters.
+
+We incentivize agents to learn task structure by training policies that perform well under a variety of goals, while not overfitting to any individual goal. We achieve this by training agents that, in addition to maximizing reward, minimize the policy dependence on the individual goal, quantified by the conditional mutual information $I ( A ; { \bar { G } } \mid S )$ . This is inspired by the information bottleneck approach (Tishby et al., 1999) of training deep neural networks for supervised learning (Alemi et al., 2017; Chalk et al., 2016; Achille and Soatto, 2016; Kolchinsky et al., 2017), where classifiers are trained to achieve high accuracy while simultaneously encoding as little information about the input as possible. This form of “information dropout” has been shown to promote generalization performance (Achille and Soatto, 2016; Alemi et al., 2017). We show that minimizing goal information promotes generalization in an RL setting as well. Our proposed model is referred as InfoBot (inspired from the Information Bottleneck framework).
+
+This approach to learning task structure can also be interpreted as encouraging agents to follow a default policy: This is the default behaviour which the agent should follow in the absence of any additional task information (like the goal location, the relative distance to the goal or a language instruction etc). To see this, note that our regularizer can also be written as $I ( A ; G \mid ^ { - } S ) { \overset { } { = } } \mathbb { E } _ { \pi _ { \theta } } \left[ D _ { \mathrm { K L } } [ \pi _ { \theta } ( A \mid S , G ) \mid \pi _ { 0 } ( A \mid S ) ] \right]$ , where $\pi _ { \theta } ( A \mid S , G )$ is the agent’s multi-goal policy, $\mathbb { E } _ { \pi _ { \theta } }$ denotes an expectation over trajectories generated by $\pi _ { \theta }$ , $D _ { \mathrm { K L } }$ is the Kuhlback-Leibler divergence, and $\begin{array} { r } { \pi _ { 0 } ( A \mid S ) = \sum _ { g } p ( g ) \pi _ { \theta } ( \bar { A } \mid S , g ) } \end{array}$ is a “default” policy with the goal marginalized out. While the agent never actually follows the default policy $\pi _ { 0 }$ directly, it can be viewed as what the agent might do in the absence of any knowledge about the goal. Thus, our approach encourages the agent to learn useful behaviours and to follow those behaviours closely, except where diverting from doing so leads to significantly higher reward. Humans too demonstrate an affinity for relying on default behaviour when they can (Kool and Botvinick, 2018), which we take as encouraging support for this line of work (Hassabis et al., 2017).
+
+We refer to states where diversions from default behaviour occur as decision states, based on the intuition that they require the agent not to rely on their default policy (which is goal agnostic) but instead to make a goal-dependent “decision.” Our approach to exploration then involves encouraging the agent to seek out these decision states in new environments. Decision states are natural subgoals for efficient exploration because they are boundaries between achieving different goals (van Dijk and Polani, 2011). By visiting decision states, an agent is encouraged to 1) follow default trajectories that work across many goals (i.e could be executed in multiple different contexts) and 2) uniformly explore across the many “branches” of decision-making. We encourage the visitation of decision states by first training an agent with an information regularizer to recognize decision states. We then freeze the agent’s policy, and use $D _ { \mathrm { K L } } [ \pi _ { \theta } ( A \mid S , G ) \mid \pi _ { 0 } ( A \mid S ) ]$ as an exploration bonus for training a new policy. Crucially, this approach to exploration is tuned to the family of tasks the agent is trained on, and we show that it promotes efficient exploration than other task-agnostic approaches to exploration (Houthooft et al., 2016; Pathak et al., 2017b).
+
+Our contributions can be summarized as follows :
+
+• We regularize RL agents in multi-goal settings with ${ \bar { I } } ( A ; G \mid S )$ , an approach inspired by the information bottleneck and the cognitive science of decision making, and show that it promotes generalization across tasks.
+
+We use policies as trained above to then provide an exploration bonus for training new policies in the form of $D _ { \mathrm { K L } } [ \pi _ { \theta } ( A \mid S , \bar { G } ) \mid \pi _ { 0 } ( \bar { A } \mid S ) ]$ , which encourages the agent to seek out decision states. We demonstrate that this approach to exploration performs more effectively than other state-of-the-art methods, including a count-based bonus, VIME (Houthooft et al., 2016), and curiosity (Pathak et al., 2017b).
+
+![](images/04c233435f058561cbde53362d20b8db3b6ad6bdaaecfaf4730acd05bd927ffb.jpg)  
+Figure 1: Policy architecture.
+
+# 2 OUR APPROACH
+
+Our objective is to train an agent on one set of tasks (environments) $T \sim p _ { \mathrm { t r a i n } } ( T )$ , but to have the agent perform well on another different, but related, set of tasks $T \sim p _ { \mathrm { t e s t } } ( T )$ . We propose to maximize the following objective in the training environments:
+
+$$
+\begin{array} { r l } & { J ( \theta ) \equiv \mathbb { E } _ { \pi _ { \theta } } [ r ] - \beta I ( A ; G \mid S ) } \\ & { \phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x } } \\ & { \phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x } = \mathbb { E } _ { \pi _ { \theta } } [ r - \beta D _ { \mathrm { K L } } \left[ \pi _ { \theta } ( A \mid S , G ) \mid \pi _ { 0 } ( A \mid S ) \right] ] , } \end{array}
+$$
+
+where $\mathbb { E } _ { \pi _ { \theta } }$ denotes an expectation over trajectories generated by the agent’s policy, $\beta > 0$ is a tradeoff parameter, $D _ { \mathrm { K L } }$ is the Kullback–Leibler divergence, and $\bar { \pi _ { 0 } } ( A \mid \bar { S } ) \equiv \bar { \sum _ { g } { p ( g ) } } \pi _ { \theta } ( A \mid S , g )$ is a “default” policy with the agent’s goal marginalized out.
+
+# 2.1 TRACTABLE BOUNDS ON INFORMATION
+
+We parameterize the policy $\pi _ { \theta } ( A \mid S , G )$ using an encoder $p _ { \mathrm { e n c } } ( Z \mid S , G )$ and a decoder $p _ { \mathrm { d e c } } ( \bar { \boldsymbol { A } } \mid S , Z )$ such that $\begin{array} { r } { \pi _ { \boldsymbol { \theta } } ( \boldsymbol { \dot { A } } \mid S , G ) = \sum _ { z } p _ { \mathrm { e n c } } ( z \mid S , G ) p _ { \mathrm { d e c } } ( \boldsymbol { \dot { A } } \mid S , z ) } \end{array}$ (see figure 1). The encoder output $Z$ is meant to represent the information about the present goal $G$ that the agent believes is important to access in the present state $S$ in order to perform well. The decoder takes this encoded goal information and the current state and produces a distribution over actions $A$ .
+
+We suppress the dependence of $p _ { \mathrm { e n c } }$ and $p _ { \mathrm { d e c } }$ on $\theta$ , but $\theta$ in the union of their parameters. Due to the data processing inequality (DPI) (Cover and Thomas, 2006), $I ( Z ; G \mid S ) \ge \bar { I } ( A ; G \mid S )$ . Therefore, minimizing the goal information encoded by $p _ { \mathrm { e n c } }$ also minimizes $I ( A ; G \mid S )$ .
+
+Thus, we instead maximize this lower bound on $J ( \theta )$ :
+
+$$
+\begin{array} { r l } & { J ( \theta ) \geq \mathbb { E } _ { \pi _ { \theta } } [ r ] - \beta I ( Z ; G \mid S ) } \\ & { \phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x } } \\ & { \phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x } = \mathbb { E } _ { \pi _ { \theta } } [ r - \beta D _ { \mathrm { K L } } [ p _ { \mathrm { e n c } } ( Z \mid S , G ) \mid p ( Z \mid S ) ] ] , } \end{array}
+$$
+
+where $\begin{array} { r } { p ( Z \mid S ) = \sum _ { g } p ( g ) p _ { \mathrm { e n c } } ( Z \mid S , g ) } \end{array}$ is the marginalized encoding.
+
+In practice, performing this marginalization over the goal may often be prohibitive, since the agent might not have access to the goal distribution $p ( G )$ , or even if the agent does, there might be many or a continuous distribution of goals that makes the marginalization intractable. To avoid this marginalization, we replace $p ( Z \mid S )$ with a variational approximation $q ( Z \mid S )$ (Kingma and Welling, 2014; Alemi et al., 2017; Houthooft et al., 2016; Strouse et al., 2018). This again provides a lower bound on $J ( \theta )$ since:
+
+$$
+\begin{array} { r l } & { I ( Z ; G \mid S ) = \displaystyle \sum _ { z , s , g } p ( z , s , g ) \log \frac { p ( z \mid g , s ) } { p ( z \mid s ) } } \\ & { \quad \quad \quad = \displaystyle \sum _ { z , s , g } p ( z , s , g ) \log p ( z \mid g , s ) - \sum _ { z , s } p ( s ) p ( z \mid s ) \log p ( z \mid s ) } \\ & { \quad \quad \geq \displaystyle \sum _ { z , s , g } p ( z , s , g ) \log p ( z \mid g , s ) - \sum _ { z , s } p ( s ) p ( z \mid s ) \log q ( z \mid s ) , } \end{array}
+$$
+
+where the inequality in the last line, in which we replace $p ( z \mid s )$ with $q ( z \mid s )$ , follows from that $\begin{array} { r } { D _ { \mathrm { K L } } [ p ( Z \mid s ) ] q ( \vec { Z } \mid s ) ] \geq 0 \Rightarrow \sum _ { z } p ( z \mid s ) \log p ( \vec { z } \mid s ) \geq \sum _ { z } \hat { p } ( z \mid s ) \log q ( \vec { z } \mid s ) } \end{array}$ .
+
+Thus, we arrive at the lower bound $\tilde { J } ( \theta )$ that we maximize in practice:
+
+$$
+J ( \theta ) \geq \tilde { J } ( \theta ) \equiv \mathbb { E } _ { \pi _ { \theta } } [ r - \beta D _ { \mathrm { K L } } \left[ p _ { \mathrm { e n c } } ( Z \mid S , G ) \mid q ( Z \mid S ) \right] ] .
+$$
+
+In the experiments below, we fix $q ( Z \mid S )$ to be unit Gaussian, however it could also be learned, in which case its parameters should be included in $\theta$ . Although our approach is compatible with any RL method, we maximize $\tilde { J } ( \theta )$ on-policy from sampled trajectories using a score function estimator (Williams, 1992; Sutton et al., 1999a). As derived by Strouse et al. (2018), the resulting update at time step $t$ , which we denote $\nabla _ { \boldsymbol { \theta } } \tilde { J } ( t )$ , is:
+
+$$
+\nabla _ { \theta } \tilde { J } ( t ) = \tilde { R } _ { t } \log ( \pi _ { \theta } ( a _ { t } \mid s _ { t } , g _ { t } ) ) - \beta \nabla _ { \theta } D _ { \mathrm { K L } } \left[ p _ { \mathrm { e n c } } ( Z \mid s _ { t } , g _ { t } ) \mid q ( Z \mid s _ { t } ) \right] ,
+$$
+
+where modifi $\begin{array} { r } { \tilde { R } _ { t } \equiv \sum _ { u = t } ^ { T } \gamma ^ { u - t } \tilde { r } _ { u } } \end{array}$ is a modified return, ength of the current ep $\tilde { r } _ { t } \equiv r _ { t } + \beta D _ { \mathrm { K L } } \left[ p _ { \mathrm { e n c } } ( Z \mid s _ { t } , g ) \mid q ( Z \mid s _ { t } ) \right]$ is a and $T$ $a _ { t } , s _ { t }$ $g _ { t }$ goal at time $t$ , respectively. The first term in the gradient comes from applying the REINFORCE update to the modified reward, and can be thought of as encouraging the agent to change the policy in the present state to revisit future states to the extent that they provide high external reward as well as low need for encoding goal information. The second term comes from directly optimizing the policy to not rely on goal information, and can be thought of as encouraging the agent to directly alter the policy to avoid encoding goal information in the present state. Note that while we take a Monte Carlo policy gradient, or REINFORCE, approach here, our regularizer is compatible with any RL algorithm.
+
+# 2.2 POLICY AND EXPLORATION TRANSFER
+
+By training the policy as in equation 5 the agent learns to rely on its (goal-independent) habits as much as possible, deviating only in decision states (as introduced in Section 1) where it makes goaldependent modifications. We demonstrate in Section 4 that this regularization alone already leads to generalization benefits (that is, increased performance on $T \sim p _ { \mathrm { t e s t } } ( \bar { T } )$ after training on $T \sim p _ { \mathrm { t r a i n } } ( T ) )$ . However, we train the agent to identify decision states as in equation 5, such that the learnt goaldependent policy can provide an exploration bonus in the new environments. That is, after training on $T \sim p _ { \mathrm { t r a i n } } ( T )$ , we freeze the agent’s encoder $p _ { \mathrm { e n c } } ( Z \mid S , G )$ and marginal encoding $q ( Z \mid S )$ , discard the decoder $\overset { \cdot } { p } _ { \mathrm { d e c } } ( A \mid S , Z )$ , and use the encoders to provide $D _ { \mathrm { K L } } \left[ p _ { \mathrm { e n c } } ( Z \mid S , G ) \mid q ( Z \mid S ) \right]$ as a state and goal dependent exploration bonus for training a new policy $\pi _ { \phi } ( A \mid S , G )$ on $T \sim p _ { \mathrm { t e s t } } ( T )$ . To ensure that the new agent does not pursue the exploration bonus solely (in lieu of reward), we also decay the bonus with continued visits by weighting with a count-based exploration bonus as well. That is, we divide the KL divergence by $\sqrt { c ( S ) }$ , where $c ( S )$ is the number of times that state has been visited during training, which is initialized to 1. Letting $r _ { e } ( t )$ be the environmental reward at time $t$ , we thus train the agent to maximize the combined reward $r _ { t }$ :
+
+$$
+r _ { t } = r _ { e } ( t ) + \frac { \beta } { \sqrt { c ( s _ { t } ) } } D _ { \mathrm { K L } } \left[ p _ { \mathrm { e n c } } ( Z \mid s _ { t } , g _ { t } ) \mid q ( Z \mid s _ { t } ) \right] .
+$$
+
+Our approach is summarized in algorithm 1.
+
+<table><tr><td colspan="2">Algorithm1 Transfer and Exploration via the Information Bottleneck</td></tr><tr><td>Require:</td><td>A policy πθ(A | S,G) = ∑z Penc(z| S,G) Pdec(A| S,z), parameterized by 0</td></tr><tr><td>Require:</td><td>A variational approximation q(Z|S) to the goal-marginalized encoder</td></tr><tr><td>Require:</td><td>A regularization weight β</td></tr><tr><td>Require:</td><td>Another policy π𝜙(A| S,G),along with a RL algorithm A to train it</td></tr><tr><td>Require:</td><td>A set of training tasks (environments) Ptrain(T) and test tasks ptest(T)</td></tr><tr><td colspan="2">Require: A goal sampling strategy p(G|T) given a task T</td></tr><tr><td colspan="2">for episodes = 1 to Ntrain do Sample a task T ~ Ptrain(T) and goal G ~ p(G |T)</td></tr><tr><td colspan="2"> Produce trajectory T on task T with goal G using policy πe(A| S, G)</td></tr><tr><td colspan="2">Update policy parameters θ over T using Eqn 5</td></tr><tr><td colspan="2">end for</td></tr><tr><td colspan="2">Optional: use π directly on tasks sampled from ptest (T) for episodes = 1 to Ntest do</td></tr><tr><td colspan="2">Sample a task T ~ Ptest(T) and goal G ~ p(G|T)</td></tr><tr><td colspan="2">Produce trajectory T on task T with goal G using policy πφ(A| S, G)</td></tr><tr><td colspan="2">Update policy parameters  using algorithm A to maximize the reward given by Eqn 6</td></tr></table>
+
+# 3 RELATED WORK
+
+van Dijk and Polani (2011) were the first to point out the connection between action-goal information and the structure of decision-making. They used information to identify decision states and use them as subgoals in an options framework (Sutton et al., 1999b). We build upon their approach by combining it with deep reinforcement learning to make it more scaleable, and also modify it by using it to provide an agent with an exploration bonus, rather than subgoals for options.
+
+Our decision states are similar in spirit to the notion of ”bottleneck states” used to define subgoals in hierarchical reinforcement learning. A bottleneck state is defined as one that lies on a wide variety of rewarding trajectories (McGovern and Barto, 2001; Stolle and Precup, 2002) or one that otherwise serves to separate regions of state space in a graph-theoretic sense (Menache et al., 2002; ¸Sim¸sek et al., 2005; Kazemitabar and Beigy, 2009; Machado et al., 2017). The latter definition is purely based on environmental dynamics and does not incorporate reward structure, while both definitions can lead to an unnecessary proliferation of subgoals. To see this, consider a T-maze in which the agent starts at the bottom and two possible goals exist at either end of the top of the T. All states in this setup are bottleneck states, and hence the notion is trivial. However, only the junction where the lower and upper line segments of the T meet are a decision state. Thus, we believe the notion of a decision state is a more parsimonious and accurate indication of good subgoals than is the above notions of a bottleneck state. The success of our approach against state-of-the-art exploration methods (Section 4) supports this claim.
+
+We use the terminology of information bottleneck (IB) in this paper because we limit (or bottleneck) the amount of goal information used by our agent’s policy during training. However, the correspondence is not exact: while both our method and IB limit information into the model, we maximize rewards while IB maximizes information about a target to be predicted. The latter is thus a supervised learning algorithm. If we instead focused on imitation learning and replaced $\mathbb { E } [ r ]$ with $I ( A ^ { * } ; A \mid S )$ in Eqn 1, then our problem would correspond exactly to a variational information bottleneck (Alemi et al., 2017) between the goal $G$ and correct action choice $A ^ { * }$ (conditioned on $S$ ).
+
+Whye Teh et al. (2017) trained a policy with the same KL divergence term as in Eqn 1. But this term is used completely differently context: Whye Teh et al. (2017) use a regularizer on the KL-divergence between action distributions of different policies to improve distillation, does not have any notion of goals, and is not concerned with exploration or with learning exploration strategies and transferring them to new domain. We use the variational information bottleneck, which has a KL divergence penalty on the difference between the posterior latent variable distribution and the prior. We are not distilling multiple policies. Parallel to our work, Strouse et al. (2018) also used Eqn 1 as a training objective, however their purpose was not to show better generalization and transfer, but instead to promote the sharing and hiding of information in a multi-agent setting. In concurrent work (Galashov et al., 2019) proposed a way to learn default policy which helps to enforce an inductive bias, and helps in transfer across different but related tasks.
+
+Popular approaches to exploration in RL are typically based on: 1) injecting noise into action selection (e.g. epsilon-greedy, (Osband et al., 2016)), 2) encouraging “curiosity” by encouraging prediction errors of or decreased uncertainty about environmental dynamics (Schmidhuber, 1991; Houthooft et al., 2016; Pathak et al., 2017b), or 3) count-based methods which incentivize seeking out rarely visited states (Strehl and Littman, 2008; Bellemare et al., 2016; Tang et al., 2016; Ostrovski et al., 2017). One limitation shared by all of these methods is that they have no way to leverage experience on previous tasks to improve exploration on new ones; that is, their methods of exploration are not tuned to the family of tasks the agent faces. Our transferrable exploration strategies approach in algorithm 1 however does exactly this. Another notable recent exception is Gupta et al. (2018), which took a meta-learning approach to transferable exploration strategies.
+
+# 4 EXPERIMENTAL RESULTS
+
+In this section, we demonstrate the following experimentally:
+
+• The goal-conditioned policy with information bottleneck leads to much better policy transfer than standard RL training procedures (direct policy transfer). • Using decision states as an exploration bonus leads to better performance than a variety of standard task-agnostic exploration methods (transferable exploration strategies).
+
+![](images/0077313ab1b723d7b2091d8fc44b1445395e5a5e4ea25e3d10a4469987eb5f38.jpg)  
+Figure 2: MultiRoomNXSY and FindObjSY MiniGrid environments. See text for details.
+
+# 4.1 MINIGRID ENVIRONMENTS
+
+The first set of environments we consider are partially observable grid worlds generated with MiniGrid (Chevalier-Boisvert and Willems, 2018), an OpenAI Gym package (Brockman et al., 2016). We consider the MultiRoomNXSY and a FindObjSY task domains, as depicted in Figure 2. Both environments consist of a series of connected rooms, sometimes separated by doors that need opened. In both tasks, black squares are traversable, grey squares are walls, black squares with colored borders are doors, the red triangle is the agent, and the shaded area is the agent’s visible region. The MultiRoomNXSY the environment consists of $X$ rooms, with size at most $Y$ , connected in random orientations. The agent is placed in a distal room and must navigate to a green goal square in the most distant room from the agent. The agent receives an egocentric view of its surrounding, consisting of $3 \times 3$ pixels. The task increases in difficulty with $X$ and $Y$ . The FindObjSY environment consists of 9 connected rooms of size $Y - 2 \times Y - 2$ arranged in a grid. The agent is placed in the center room and must navigate to an object in a randomly chosen outer room (e.g. yellow circle in bottom room in Figure 2c and blue square in top left room in Figure 2d). The agent again receives an egocentric observation, this time consisting of $7 \times 7$ pixels, and again the difficulty of the task increases with $Y$ For more details of the environment, see Appendix H.
+
+Solving these partially observable, sparsely rewarded tasks by random exploration is difficult because there is a vanishing probability of reaching the goal randomly as the environments become larger. Transferring knowledge from simpler to more complex versions of these tasks thus becomes essential. In the next two sections, we demonstrate that our approach yields 1) policies that directly transfer well from smaller to larger environments, and 2) exploration strategies that outperform other task-agnostic exploration approaches.
+
+# 4.2 DIRECT POLICY GENERALIZATION ON MINIGRID TASKS
+
+We first demonstrate that training an agent with a goal bottleneck alone already leads to more effective policy transfer. We train policies on smaller versions of the MiniGrid environments (MultiRoomN2S6 and FindObjS5 and S7), but evaluate them on larger versions (MultiRoomN10S4, N10S10, and N12S10, and FindObjS7 and S10) throughout training.
+
+Figure 3 compares an agent trained with a goal bottleneck (first half of Algorithm 1) to a vanilla goal-conditioned A2C agent (Mnih et al., 2016) on MultiRoomNXSY generalization. As is clear, the goal-bottlenecked agent generalizes much better. The success rate is the number of times the agent solves a larger task with 10-12 rooms while it is being trained on a task with only 2 rooms. When generalizing to 10 small rooms, the agent learns to solve the task to near perfection, whereas the goal-conditioned A2C baseline only solves ${ < } 5 0 \%$ of mazes (Figure 3a).
+
+Table 1 compares the same two agents on FindObjSY generalization. In addition, this comparison includes an ablated version of our agent with $\beta = 0$ , that is an agent with the same architecture as in Figure 1 but with the no information term in its training objective. This is to ensure that our method’s success is not due to the architecture alone. As is evident, the goal-bottlenecked agent again generalizes much better.
+
+We analyzed the agent’s behaviour to understand the intuition of why it generalizes well. In the MultiRoomNXSY environments, we find that the agent quickly discovers a wall following strategy. Since these environments are partially observable, this is indeed a good strategy that also generalizes well to larger mazes. In the FindObjSY environments, on the other hand, the agent sticks toward the center of the rooms, making a beeline from doorway to doorway. This is again a good strategy, because the agent’s field of view in these experiments is large enough to see the entire room in which its in to determine if the goal object is present or not.
+
+Table 1: Policy generalization on FindObjSY . Agents trained on FindObjS5, and evaluated on FindObjS7 and S10.   
+
+<table><tr><td>Method</td><td>FindObjS7</td><td>FindObjS10</td></tr><tr><td>Goal-conditioned A2C</td><td>56%</td><td>36%</td></tr><tr><td>InfoBot with β=0</td><td>44%</td><td>24%</td></tr><tr><td>InfoBot</td><td>81%</td><td>61%</td></tr></table>
+
+![](images/d8550c98c040b5d4dfc2ce6a429456f8cff2c9934562a49f7879df46fae867be.jpg)  
+Figure 3: Policy generalization on MultiRoomNXSY . Success is measured by the percent of time the agent can find the goal in an unseen maze. Error bars are standard deviations across runs. Baseline is a vanilla goal-conditioned A2C agent.
+
+Table 2: Transferable exploration strategies on MultiRoomNXSY . InfoBot encoder trained on MultiRoomN2S6. All agents evaluated on MultiRoomN3S4 and N5S4. While several methods perform well with 3 rooms, InfoBot performs far better as the number of rooms increases to 5.   
+
+<table><tr><td>Method</td><td>MultiRoomN3S4</td><td>MultiRoomN5S4</td></tr><tr><td>Goal-conditioned A2C</td><td>0%</td><td>0%</td></tr><tr><td>TRPO+VIME</td><td>54%</td><td>0%</td></tr><tr><td>Count based exploration</td><td>95%</td><td>0%</td></tr><tr><td>Curiosity-based exploration</td><td>95%</td><td>54%</td></tr><tr><td>InfoBot (decision state exploration bonus)</td><td>90%</td><td>85%</td></tr></table>
+
+# 4.3 TRANSFERABLE EXPLORATION STRATEGIES ON MINIGRID TASKS
+
+We now evaluate our approach to exploration (the second half of Algorithm 1). We train agents with a goal bottleneck on one set of environments (MultiRoomN2S6) where they learn the sensory cues that correspond to decision states. We then use the identified decision states to guide exploration on another set of environments (MultiRoomN3S4, MultiRoomN4S4, and MultiRoomN5S4). We compare to several standard task-agnostic exploration methods, including count-based exploration (Eqn 6 without the $D _ { \mathrm { K L } }$ , that a bonus of $\beta / \sqrt { c ( s ) } )$ , VIME (Houthooft et al., 2016), and curiosity-driven exploration (Pathak et al., 2017b), as well as a goal-conditioned A2C baseline with no exploration bonuses. Results are shown in Table 2 and Figure 4.
+
+On a maze with three rooms, the count-based method and curiosity-driven exploration slightly outperform the proposed learned exploration strategy. However, as the number of rooms increases, the count-based method and VIME fail completely and the curiosity-based method degrades to only $54 \%$ success rate. This is in contrast to the proposed exploration strategy, which by learning the structure of the task, maintains a high success rate of $8 5 \%$ .
+
+# 4.4 GOAL-BASED NAVIGATION TASKS
+
+In this task, we use a partially observed goal based MiniPacMan environment as shown in Figure 5. The agent navigates a maze, and tries to reach the goal. The agent sees only a partial window around itself. The agent only gets a reward of “1” when it reaches the goal. For standard RL algorithms, these tasks are difficult to solve due to the partial observability of the environment, sparse reward (as the agent receives a reward only after reaching the goal), and low probability of reaching the goal via random walks (precisely because these junction states are crucial states where the right action must be taken and several junctions need to be crossed). This environment is more challenging as compared to the Minigrid environment, as this environment also has dead ends as well as more complex branching.
+
+We first demonstrate that training an agent with a goal bottleneck alone leads to more effective policy transfer. We train policies on smaller versions of this goal based MiniPacMan environment environments $\left( 6 \mathrm { ~ x ~ } 6 \mathrm { ~ m a z e ~ } \right)$ ), but evaluate them on larger versions (11 X 11) throughout training.
+
+![](images/b24bb2cb9e304d672649659f09a19c239b79cbdf36236c3bb9c719a4a31e8938.jpg)  
+Figure 4: Transferable exploration strategies on MultiRoomNXSY . As the number of rooms increases (from left to right), a count-based exploration bonus alone cannot solve the task, whereas the proposed exploration bonus, by being tuned to task structure, enables success on these more difficult tasks.
+
+Table 3: Experiments for training the agent in a $6 \times 6$ maze environment, and then generalizing to a $1 1 \times 1 1$ maze. Comparison of our proposed method to regular actor-critic methods, UVFA and other hierarchical approaches. Results shown for the $\%$ of times agent reaches the goal. The results are average over 3 random seeds.   
+
+<table><tr><td>Algorithm (Train on 6 × 6 maze)</td><td>Evaluate on 11 × 11 maze</td></tr><tr><td>Actor-Critic</td><td>5%</td></tr><tr><td>PPO (Proximal Policy Optimization</td><td>8%</td></tr><tr><td>Actor-Critic+ Count-Based</td><td>7%</td></tr><tr><td>Curiosity Driven Learning (ICM)</td><td>47%</td></tr><tr><td>Goal Based (UVFA) Goal - TopDownImage of the goal</td><td>7%</td></tr><tr><td>Goal Based (UVFA) Goal - Relative Dist</td><td>15%</td></tr><tr><td>Feudal RL</td><td>37%</td></tr><tr><td>InfoBot (proposed)</td><td>64%</td></tr></table>
+
+Table. 3 compares an agent trained with a goal bottleneck (first half of Algorithm 1) to a vanilla goal-conditioned A2C agent (Mnih et al., 2016), exploration methods like count-based exploration, curiosity driven exploration (Pathak et al., 2017a) and Feudal RL algorithm (Vezhnevets et al., 2017). The goal-bottlenecked agent generalizes much better. The success rate is the number of times the agent solves a larger task while it is being trained on a task with only 2 rooms. When generalizing to larger maze, the agent learns to solve the task $64 \%$ of the times, whereas other agents solve ${ < } 5 0 \%$ of mazes (Table 3). For representing the goals, we experiment with 2 versions. 1) In which we give the agent’s relative distance to the goal as the goal representation. 2) In which we give the top down image of the goal. For our experiments, the baseline in which we give the relative distance to the goal worked better.
+
+# 4.5 MIDDLE GROUND BETWEEN MODEL BASED RL AND MODEL FREE RL
+
+We further demonstrate the idea of decision states in a planning goal-based navigation task that uses a combination of model-based and model-free RL. Identifying useful decision states can provide a comfortable middle ground between model-free reasoning and model-based planning. For example, imagine planning over individual decision states, while using model-free knowledge to navigate between bottlenecks: aspects of the environment that are physically complex but vary little between problem instances are handled in a model-free way (the navigation between decision points), while the particular decision points that are relevant to the task can be handled by explicitly reasoning about causality, in a more abstract representation. We demonstrate this using a similar setup as in imagination augmented agents (Weber et al., 2017). In imagination augmented agents, model free agents are augmented with imagination, such that the imagination model can be queried to make predictions about the future. We use the dynamics models to simulate imagined trajectories, which are then summarized by a neural network and this summary is provided as additional context to a policy network. We use the output of the imagination module as a “goal” and we want to show that only near the decision points (i.e potential subgoals) the agent wants to make use of the information which is a result of running imagination module.
+
+![](images/f7f9597f004bec11d4d2ba2098ecba707e9ac27dae121b6d16270b9413033019.jpg)  
+Figure 5: Goal based MiniPacMan navigation task: We train on a $6 \times 6$ environment, and evaluate the generalization performance in a $1 1 \times 1 1$ maze. The agent is represented by white color and has to reach the goal (light green marker).
+
+![](images/c9b6c68c83475cdc82840a0d1f28951a18a7f62763531fa6019157fa8198e258.jpg)  
+Figure 6: Goal based MiniPacMan navigation task: Here the agent gets a full observation of environment. We follow the similar setup as in Imagination Augmented agents. In this, the output of the imagination core is treated as a contextual information by the policy. We treat this contextual information as the “goal” in the InfoBot setup. Here, we want to see, where the policy wants to access the information provided by running the imagination module. Ideally, only at the decision states (i.e potential sub-goals) policy should access the output of the imagination module. We show the output of $D _ { \mathrm { K L } } \left[ p _ { \mathrm { e n c } } ( Z \mid s _ { t } , g _ { t } ) \mid q ( Z \mid s _ { t } ) \right]$ , where $g _ { t }$ refers to the output of imagination module. High KL is represented by lighter color.
+
+# 5 CONNECTIONS TO NEUROSCIENCE AND COGNITIVE SCIENCE
+
+The work we have presented bears some interesting connections to cognitive science and neuroscience. Both of these fields draw a fundamental distinction between automatic and controlled action selection (Miller and Cohen, 2001). In automatic responses, perceptual inputs directly trigger actions according to a set of habitual stimulus-response associations. In controlled behaviour, automatic responses are overridden in order to align behaviour with a more complete representation of task context, including current goals. As an example, on the drive to work, automatic responding may trigger the appropriate turn at a familiar intersection, but top-down control may be needed to override this response if the same intersection is encountered on the route to a less routine destination.
+
+As is readily evident, our InfoBot architecture contains two pathways that correspond rather directly to the automatic and controlled pathways that have been posited in cognitive neuroscience models (Miller and Cohen, 2001). In the neuroscience context, representation of task context and the function of overriding automatic responses has been widely linked with the prefrontal cortex (Miller and Cohen, 2001), and it is interesting to consider the route within InfoBot from goal to action representations in this light. Notably, recent work has suggested that prefrontal control processes are associated with subjective costs; ceteris paribus, human decision-makers will opt for habitual or automatic routes to behaviour. This of course aligns with InfoBot, and in particular with the KL term in Equation 1.
+
+This correspondence with neuroscience provides some indirect encouragement for the approach implemented in the present work. In turn, the InfoBot framework provides an indication for why a cost of control may exist in human cognition, namely that this encourages the emergence of useful habits, with payoffs for efficient exploration and transfer.
+
+# 6 CONCLUSION
+
+In this paper, we proposed to train agents to develop “default behaviours” as well as the knowledge of when to break those behaviour, using an information bottleneck between the agent’s goal and policy. We demonstrated empirically that this training procedure leads to better direct policy transfer across tasks. We also demonstrated that the states in which the agent learns to deviate from its habits, which we call ”decision states”, can be used as the basis for a learned exploration bonus that leads to more effective training than other task-agnostic exploration methods.
+
+# ACKNOWLEDGEMENTS
+
+The authors acknowledge the important role played by their colleagues at Mila throughout the duration of this work. AG would like to thank Doina Precup, Maxime Chevalier-Boisvert and Alexander Neitz for very useful discussions. AG would like to thank Konrad Kording, Rosemary Nan Ke, Jonathan Binas, Bernhard Schoelkopf for useful discussions. The authors would also like to thank Yee Whye Teh, Peter Henderson, Emmanuel Bengio, Philip Bachman, Michael Noukhovitch for feedback on the draft. The authors are grateful to NSERC, CIFAR, Google, Samsung, Nuance, IBM, Canada Research Chairs, Canada Graduate Scholarship Program, Nvidia for funding, and Compute Canada for computing resources. We are very grateful to Google for giving Google Cloud credits used in this project.
+
+# REFERENCES
+
+A. Achille and S. Soatto. Information Dropout: Learning Optimal Representations Through Noisy Computation. ArXiv e-prints, Nov. 2016.   
+A. Achille and S. Soatto. On the emergence of invariance and disentangling in deep representations. CoRR, abs/1706.01350, 2017. URL http://arxiv.org/abs/1706.01350.   
+A. A. Alemi, I. Fischer, J. V. Dillon, and K. Murphy. Deep variational information bottleneck. arXiv preprint arXiv:1612.00410, 2016.   
+A. A. Alemi, I. Fischer, J. V. Dillon, and K. Murphy. Deep variational information bottleneck. International Conference on Learning Representations (ICLR), abs/1612.00410, 2017. URL http://arxiv.org/abs/1612.00410.   
+N. J. Beaudry and R. Renner. An intuitive proof of the data processing inequality. Quantum Information & Computation, 12(5-6):432–441, 2012. URL http://www.rintonpress. com/xxqic12/qic-12-56/0432-0441.pdf.   
+M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   
+M. G. Bellemare, S. Srinivasan, G. Ostrovski, T. Schaul, D. Saxton, and R. Munos. Unifying Count-Based Exploration and Intrinsic Motivation. ArXiv e-prints, June 2016.   
+G. Brockman, V. Cheung, L. Pettersson, J. Schneider, J. Schulman, J. Tang, and W. Zaremba. OpenAI Gym. ArXiv e-prints, June 2016.   
+M. Chalk, O. Marre, and G. Tkacik. Relevant sparse codes with variational information bottleneck. ArXiv e-prints, May 2016.   
+M. Chevalier-Boisvert and L. Willems. Minimalistic gridworld environment for openai gym. https: //github.com/maximecb/gym-minigrid, 2018.
+
+T. M. Cover and J. A. Thomas. Elements of Information Theory. Wiley-Interscience, 2006.
+
+D. Foster and P. Dayan. Structure in the space of value functions. Machine Learning, 49(2):325–346, Nov 2002. ISSN 1573-0565. doi: 10.1023/A:1017944732463. URL https://doi.org/10. 1023/A:1017944732463.
+
+A. Galashov, S. Jayakumar, L. Hasenclever, D. Tirumala, J. Schwarz, G. Desjardins, W. M. Czarnecki, Y. W. Teh, R. Pascanu, and N. Heess. Information asymmetry in KL-regularized RL. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id ${ . } = { }$ S1lqMn05Ym.
+
+A. Goyal, P. Brakel, W. Fedus, T. Lillicrap, S. Levine, H. Larochelle, and Y. Bengio. Recall traces: Backtracking models for efficient reinforcement learning. arXiv preprint arXiv:1804.00379, 2018.
+
+A. Gupta, R. Mendonca, Y. Liu, P. Abbeel, and S. Levine. Meta-Reinforcement Learning of Structured Exploration Strategies. ArXiv e-prints, Feb. 2018.
+
+T. Haarnoja, A. Zhou, P. Abbeel, and S. Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. CoRR, abs/1801.01290, 2018. URL http: //arxiv.org/abs/1801.01290.
+
+D. Hassabis, D. Kumaran, C. Summerfield, and M. Botvinick. Neuroscience-inspired artificial intelligence. Neuron, 95(2):245–248, 2017. URL https://doi.org/10.1016/j.neuron. 2017.06.011.
+
+R. Houthooft, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. Vime: Variational information maximizing exploration. In Advances in Neural Information Processing Systems, pages 1109–1117, 2016.
+
+M. Janner, K. Narasimhan, and R. Barzilay. Representation learning for grounded spatial reasoning. Transactions of the Association of Computational Linguistics, 6:49–61, 2018.
+
+S. J. Kazemitabar and H. Beigy. Using strongly connected components as a basis for autonomous skill acquisition in reinforcement learning. In International Symposium on Neural Networks, pages 794–803. Springer, 2009.
+
+D. P. Kingma and M. Welling. Auto-Encoding Variational Bayes. International Conference on Learning Representations (ICLR), Dec. 2014.
+
+J. B. Kinney and G. S. Atwal. Equitability, mutual information, and the maximal information coefficient. Proceedings of the National Academy of Sciences, 111(9):3354–3359, 2014. ISSN 0027-8424. doi: 10.1073/pnas.1309933111. URL http://www.pnas.org/content/111/ 9/3354.
+
+A. Kolchinsky, B. D. Tracey, and D. H. Wolpert. Nonlinear Information Bottleneck. ArXiv e-prints, May 2017.
+
+W. Kool and M. Botvinick. Mental labour. Nature Human Behaviour, 2018.
+
+I. Kostrikov. Pytorch implementations of reinforcement learning algorithms. https://github. com/ikostrikov/pytorch-a2c-ppo-acktr, 2018.
+
+M. C. Machado, M. G. Bellemare, and M. Bowling. A laplacian framework for option discovery in reinforcement learning. arXiv preprint arXiv:1703.00956, 2017.
+
+A. McGovern and A. G. Barto. Automatic discovery of subgoals in reinforcement learning using diverse density. Citeseer, 2001.
+
+I. Menache, S. Mannor, and N. Shimkin. Q-cut—dynamic discovery of sub-goals in reinforcement learning. In European Conference on Machine Learning, pages 295–306. Springer, 2002.
+
+E. K. Miller and J. D. Cohen. An integrative theory of prefrontal cortex function. Annual Review of Neuroscience, 24(1):167–202, 2001. doi: 10.1146/annurev.neuro.24.1.167. URL https: //doi.org/10.1146/annurev.neuro.24.1.167. PMID: 11283309.
+
+V. Mnih, A. Puigdomènech Badia, M. Mirza, A. Graves, T. P. Lillicrap, T. Harley, D. Silver, and K. Kavukcuoglu. Asynchronous Methods for Deep Reinforcement Learning. ArXiv e-prints, 2016.
+
+I. Mordatch and P. Abbeel. Emergence of grounded compositional language in multi-agent populations. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.   
+I. Osband, C. Blundell, A. Pritzel, and B. Van Roy. Deep exploration via bootstrapped dqn. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett, editors, Advances in Neural Information Processing Systems 29, pages 4026– 4034. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6501-deep-exploration-via-bootstrapped-dqn.pdf.   
+G. Ostrovski, M. G. Bellemare, A. van den Oord, and R. Munos. Count-Based Exploration with Neural Density Models. ArXiv e-prints, Mar. 2017.   
+D. Pathak, P. Agrawal, A. A. Efros, and T. Darrell. Curiosity-driven exploration by self-supervised prediction. CoRR, abs/1705.05363, 2017a. URL http://arxiv.org/abs/1705.05363.   
+D. Pathak, P. Agrawal, A. A. Efros, and T. Darrell. Curiosity-driven exploration by self-supervised prediction. In D. Precup and Y. W. Teh, editors, Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 2778– 2787, International Convention Centre, Sydney, Australia, 06–11 Aug 2017b. PMLR. URL http://proceedings.mlr.press/v70/pathak17a.html.   
+M. Plappert, M. Andrychowicz, A. Ray, B. McGrew, B. Baker, G. Powell, J. Schneider, J. Tobin, M. Chociej, P. Welinder, V. Kumar, and W. Zaremba. Multi-Goal Reinforcement Learning: Challenging Robotics Environments and Request for Research. ArXiv e-prints, Feb. 2018.   
+T. Schaul, D. Horgan, K. Gregor, and D. Silver. Universal value function approximators. In F. Bach and D. Blei, editors, Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pages 1312–1320, Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings.mlr.press/v37/schaul15.html.   
+J. Schmidhuber. Curious model-building control systems. In In Proc. International Joint Conference on Neural Networks, Singapore, pages 1458–1463. IEEE, 1991.   
+J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov. Proximal policy optimization algorithms. CoRR, abs/1707.06347, 2017. URL http://arxiv.org/abs/1707.06347.   
+J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov. Proximal Policy Optimization Algorithms. ArXiv e-prints, July 2017.   
+Ö. ¸Sim¸sek, A. P. Wolfe, and A. G. Barto. Identifying useful subgoals in reinforcement learning by local graph partitioning. In Proceedings of the 22nd international conference on Machine learning, pages 816–823. ACM, 2005.   
+M. Stolle and D. Precup. Learning options in reinforcement learning. In International Symposium on abstraction, reformulation, and approximation, pages 212–223. Springer, 2002.   
+A. L. Strehl and M. L. Littman. An analysis of model-based interval estimation for markov decision processes. J. Comput. Syst. Sci., 74(8):1309–1331, Dec. 2008. ISSN 0022-0000. doi: 10.1016/j. jcss.2007.08.009. URL http://dx.doi.org/10.1016/j.jcss.2007.08.009.   
+D. Strouse, M. Kleiman-Weiner, J. Tenenbaum, M. Botvinick, and D. Schwab. Learning to share and hide intentions using information regularization. In Advances in Neural Information Processing Systems (NIPS) 31. NeurIPS, 2018.   
+R. S. Sutton, D. McAllester, S. Singh, and Y. Mansour. Policy gradient methods for reinforcement learning with function approximation. In Proceedings of the 12th International Conference on Neural Information Processing Systems, NIPS’99, pages 1057–1063, Cambridge, MA, USA, 1999a. MIT Press. URL http://dl.acm.org/citation.cfm?id=3009657.3009806.   
+R. S. Sutton, D. Precup, and S. Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial Intelligence, 112(1-2):181–211, Aug. 1999b. ISSN 0004-3702. doi: 10.1016/S0004-3702(99)00052-1. URL http://dx.doi.org/10.1016/ S0004-3702(99)00052-1.   
+H. Tang, R. Houthooft, D. Foote, A. Stooke, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. #Exploration: A Study of Count-Based Exploration for Deep Reinforcement Learning. ArXiv e-prints, Nov. 2016.   
+N. Tishby, F. C. Pereira, and W. Bialek. The information bottleneck method. Proceedings of The 37th Allerton Conference on Communication, Control, and Computing, pages 368–377, 1999.   
+N. Tishby, F. C. Pereira, and W. Bialek. The information bottleneck method. arXiv preprint physics/0004057, 2000.   
+S. G. van Dijk and D. Polani. Grounding subgoals in information transitions. IEEE Symposium on Adaptive Dynamic Programming and Reinforcement Learning (ADPRL), 2011. URL https: //ieeexplore.ieee.org/document/5967384/.   
+A. S. Vezhnevets, S. Osindero, T. Schaul, N. Heess, M. Jaderberg, D. Silver, and K. Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. CoRR, abs/1703.01161, 2017. URL http://arxiv.org/abs/1703.01161.   
+T. Weber, S. Racanière, D. P. Reichert, L. Buesing, A. Guez, D. J. Rezende, A. P. Badia, O. Vinyals, N. Heess, Y. Li, R. Pascanu, P. Battaglia, D. Silver, and D. Wierstra. Imagination-augmented agents for deep reinforcement learning. CoRR, abs/1707.06203, 2017. URL http://arxiv. org/abs/1707.06203.   
+Y. Whye Teh, V. Bapst, W. M. Czarnecki, J. Quan, J. Kirkpatrick, R. Hadsell, N. Heess, and R. Pascanu. Distral: Robust Multitask Reinforcement Learning. ArXiv e-prints, 2017.   
+R. J. Williams. Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning. Machine Learning, 8(3-4):229–256, 1992. ISSN 0885-6125. doi: 10.1007/BF00992696. URL https://doi.org/10.1007/BF00992696.
+
+# A MATHEMATICAL FRAMEWORK
+
+We show that the proposed approach is equivalent to regularizing agents with a variational upper bound on the mutual information between goals and actions given states.
+
+Recall that the variational information bottleneck objective (Alemi et al., 2016; Tishby et al., 2000) is formulated as the maximization of $I ( Z , Y ) - \beta I ( Z , X )$ . In our setting, the input $( X )$ corresponds to the goal of the agent $( G )$ and $( A )$ corresponds to the target output.
+
+We assume that the joint distribution $p ( G , A , Z | S )$ factorizes as follows: $p ( G , A , Z | S ) \ =$ $p ( Z | G , A , S ) p ( A | Z , S ) p ( G | S ) \ = \ p ( Z | G , S ) p ( A | \dot { Z } , S ) p ( G | S )$ i.e., we assume $p ( Z | G , A , S ) \ =$ $p ( Z | G , S )$ , corresponding to the Markov chain $G  Z  A$ .
+
+The Data Processing Inequality (DPI) (Beaudry and Renner, 2012; Kinney and Atwal, 2014; Achille and Soatto, 2017) for a Markov chain $x  z  y$ ensures that $I ( x ; z ) \ge I ( x ; y )$ .
+
+Hence for Infobot, it implies,
+
+$$
+I ( A ; G | S ) \leq I ( Z ; G | S )
+$$
+
+To get an upper bound on $I ( G ; Z | S )$ , we first would get an upper bound on $I ( G ; Z | S = s )$ , and then we average over $p ( s )$ to get the required upper bound.
+
+We get the following result,
+
+$$
+I ( G ; Z | S = s ) = \sum _ { z , g } p ( g | s ) p ( z | s , g ) \log \frac { p ( z | s , g ) } { p ( z | s ) } ,
+$$
+
+Here, we assume that marginalizing over goals to get $\begin{array} { r } { p ( z | s ) = \sum _ { g } p ( g ) p ( z | s , g ) } \end{array}$ is intractable, and so we approximate it with a normal prior $p _ { p r i o r } = N ( 0 , 1 )$ . Since the cross-entropy between $p ( z | s )$ and $p _ { p r i o r } ( z )$ is larger than between $p ( z | s )$ and itself, we get the following upper bound:
+
+$$
+\begin{array} { r } { I ( G ; Z | S = s ) \le \displaystyle \sum _ { g } p ( g | s ) \sum _ { z } p ( z | s , g ) \log \frac { p ( z | s , g ) } { p _ { p r i o r } ( z ) } } \\ { = \displaystyle \sum _ { g } p ( g | s ) D _ { K L } [ p ( z | s , g ) | p _ { p r i o r } ( z ) ] } \end{array}
+$$
+
+Averaging over state probabilities gives
+
+$$
+\begin{array} { r } { I ( Z ; G | S ) \le \displaystyle \sum _ { s } p ( s ) \sum _ { g } p ( g | s ) D _ { K L } [ p ( z | s , g ) | p _ { p r i o r } ( z ) ] } \\ { = \displaystyle \sum _ { g } p ( g ) \sum _ { s } p ( s | g ) D _ { K L } [ p ( z | s , g ) | p _ { p r i o r } ( z ) ] } \end{array}
+$$
+
+Using Eq. 7 , we can get an upper bound on the mutual information between immediate action and goal. Here $r ( z )$ is a fixed prior.
+
+$$
+\begin{array} { r l } { I ( A ; G | S ) \le I ( Z ; G | S ) } & { } \\ { \le \underbrace { \displaystyle \sum _ { g } p ( g ) } _ { \mathrm { s a m p l e ~ a ~ g o a l ~ s a m p l e ~ a ~ t r a j e c t o r y } } \underbrace { \mathrm { K L } [ p _ { \mathrm { e n c } } ( z | s , g ) | | p _ { p r i o r } ( z ) ] } _ { \mathrm { p e n a l i z e ~ e n c o d e r ~ f o r ~ d e p a r t u r e ~ f r o m ~ p r i o r } } . } \end{array}
+$$
+
+Hence, minimizing the KL between $p _ { p r i o r } ( z )$ and $p ( z | s , g )$ penalizes the use of information about the goal by the policy, so that when the policy decides to use information about the goal, it must be worthwhile, otherwise the agent is supposed to follow a "default" behaviour.
+
+![](images/0193d93ae4b6d40af93a57d7af8ac81ec404b39f16e01afd4b8a6d6bf85a74a8.jpg)  
+Figure 7: Transferable exploration strategies on Humanoid, Walker2D, and Hopper. The ”baseline” is PPO (Schulman et al., 2017). Experiments are run with 5 random seeds and averaged over the runs.
+
+![](images/c946050e4f3010414c1d25f10ca7c1755bca2bd2b97ca0c1cc3c8e497c79b574.jpg)  
+Figure 8: Transferable exploration strategies on Pong, Qbert, Seaquest, and Breakout. The baseline is a vanilla A2C agent. Results averaged over three random seeds.
+
+A.1 TRANSFERABLE EXPLORATION STRATEGIES FOR CONTINUOUS CONTROL
+
+To show that the InfoBot architecture can also be applied to continuous control, we evaluated the performance of InfoBot on three continuous control tasks from OpenAI Gym (Brockman et al., 2016). Because InfoBot depends on the goal, in the control domains, we use high value states as an approximation to the goal state following Goyal et al. (2018). We maintain a buffer of high value states, and at each update, we sample a high value state from the buffer which acts as a proxy for the goal. We compared to proximal policy optimization (PPO) (Schulman et al., 2017), as well as two ablated versions of our model: 1) instead of taking high value states, we take low value states from the buffer as proxy to the goal (”InfoBot-low-value”) and 2) we use the same InfoBot policy architecture but do not use the information regularizer (i.e. $\beta = 0$ ) (”InfoBot-zero-kl”). The results in Figure 7 show that InfoBot improves over all three alternatives.
+
+# A.2 TRANSFERABLE EXPLORATION STRATEGIES FOR ATARI
+
+We further evaluate our experiments on few Atari games (Bellemare et al., 2013) using A2C and compare it with our proposed InfoBot framework. In this experiment, our goal is to show that InfoBot can generalize to even more complex domains compared to the maze tasks above. As in the control experiments, we again use high value states as a proxy to the goal Goyal et al. (2018) and maintain a buffer of 20000 states to sample and prioritize high value states. We evaluate our proposed model on 4 Atari games (Pong, QBert, Seaquest and BreakOut) as shown in figure 8. We find that compared to a vanilla A2C agent, our InfoBot A2C agent performs significantly better on these Atari tasks. Our experiments are averaged over three random seeds.
+
+# B TRANSFERRED EXPLORATION STRATEGY IN ATARI
+
+We demonstrate that the encoder can be used to transfera exploration strategy across Atari games to help agents learn a new game quickly. To initialize the encoder, we train an agent on the game Seaquest, where the agent is trained to identify the decision states. We then re-use this encoder on another Atari environment to provide an exploration bonus. Our experiments on the Atari games are evaluated on the games of Pong and Qbert. On Pong, an agent with learns to get a task return of 20 in 3M time steps. We show that the identification of bottleneck states can be used to transfer exploration strategies across Atari games (Fig. 9).
+
+![](images/b0b81e8e18e2b24f6978c00d04a89481e4ae62d4a19963460ffd3e864c817883.jpg)  
+Figure 9: Transfer across ALE Games (Pong, Qbert and Freeway) using egocentric encoder to provide exploration bonus, trained from Seaquest. Comparison of InfoBot $\mathrm { ( A 2 C + K L }$ Regularizer) with a Baseline A2C. Experiment results averaged over four random seeds. See Section B.
+
+# C ALGORITHM IMPLEMENTATION DETAILS
+
+We evaluate the InfoBot framework using Adavantage Actor-Critic (A2C) to learn a policy $\pi _ { \boldsymbol { \theta } } ( a | \boldsymbol { s } , \boldsymbol { g } )$ conditioned on the goal. To evaluate the performance of InfoBot, we use a range of maze multiroom tasks from the gym-minigrid framework (Chevalier-Boisvert and Willems, 2018) and the A2C implementation from (Chevalier-Boisvert and Willems, 2018). For the maze tasks, we used agent’s relative distance to the absolute goal position as "goal".
+
+For the maze environments, we use A2C with 48 parallel workers. Our actor network and critic networks consist of two and three fully connected layers respectively, each of which have 128 hidden units. The encoder network is also parameterized as a neural network, which consists of 1 fully connected layer. We use RMSProp with an initial learning rate of 0.0007 to train the models, for both InfoBot and the baseline for a fair comparison. Due to the partially observable nature of the environment, we further use a LSTM to encode the state and summarize the past observations.
+
+For the Atari experiments, we use the open-source A2C implementation from Kostrikov (2018) and condition the goal state into the policy network. For the actor network, we use 3 convolution layers with ReLU activations. For training the networks, we use RMSProp with pre-defined learning rates for our algorithm and the baseline. The goal state in our experiments is used as the high value state following (Goyal et al., 2018).
+
+For the Mujoco Experiments, we use Proximal Policy Optimization (PPO) (Schulman et al., 2017) with the open-source implementation available in Kostrikov (2018), using the defined architectures and hyperparameters as given in the repository for both our algorithm and the baseline. Again, for the goal-conditioned policies, the goal state for Mujoco experiments is defined as the high value state following (Goyal et al., 2018).
+
+For reproducibility purposes of our experiments, we will further release the code on github that will be available on
+
+Hyperparameter Search for Grid World Experiments: For the proposed method, we only varied the weight of KL loss. We tried 5 different values 0.1, 0.9, 0.01, 0.09, 0.005 for each of the env. and plotted the results which gave the most improvement. We used CNN policy for the case of FindObjSY env, and MLP policy for the case of MultiRoomNXSY. We used the agent’s relative distance to goal as a goal for our goal conditioned policy.
+
+Hyperparameter Search for Control experiments We have not done any hyper-parameter search for the baseline. For the proposed method, we only varied the weight of KL loss. We tried 3 different values 0.5, 0.01, 0.09 for each of the env. and plotted the results which gave the most improvement over the PPO baseline.
+
+<table><tr><td>Method</td><td>Train Reward</td><td>TestReward</td></tr><tr><td>No Communication</td><td>-0.919</td><td>-0.920</td></tr><tr><td>Communication</td><td>-0.36</td><td>-0.472</td></tr><tr><td>Communication (with KL cost)</td><td>-0.293</td><td>-0.38</td></tr></table>
+
+Table 4: Training and test physical reward for setting with comunication, without communication, with limited communication (using InfoBot cost)
+
+# D MULTIAGENT COMMUNICATION
+
+Here, we want to show that by training agents to develop “default behaviours” as well as the knowledge of when to break those behaviours, using an information bottleneck can also help in other scenarios like multi-agent communication. Consider multiagent communication, where in order to solve a task, agents require communicating with another agents. Ideally, an agent would would like to communicate with other agent, only when its essential to communicate, i.e the agents would like to minimize the communication with another agents. Here we show that selectively deciding when to communicate with another agent can result in faster learning.
+
+In order to be more concrete, suppose there are two agents, Alex and Bob, and that Alex receives Bob’s action at time t, then Alex can use Bob’s action to decide what influence Bob’s action has on its own action distribution. Lets say the current state of the Alex and Bob are represented by $s _ { a } , s _ { r }$ respectively, and the communication channel b/w Alex and Bob is represented by $z$ . Alex and BOb can decide what action to take based on the distribution $p _ { a } ( a _ { a } | s _ { s } ) , p _ { r } ( \bar { a } _ { r } | s _ { r } )$ respectively. Now, when Alex wants to use the information regarding Bob’s action, then the modified action distribution (for Alex) becomes $p _ { a } ( a _ { a } | s _ { a } , z _ { r } )$ where $z _ { r }$ contains information regarding Bob’s past states and actions, similarly the modified action distribution (for Bob) becomes $p _ { r } ( a _ { r } | s _ { r } , z _ { a } )$ . Now, the idea is that Alex and Bob wants to know about each other actions only when its necessary (i.e the goal is to minimize the communication $\mathrm { { \bf b / w } }$ Alex and Bob) such that on average they only use information corresponding to there own states (which could include past states and past actions.) This would correspond to penalizing the difference between the marginal policy of Alex (“habit policy”) and the conditional policy of Alex (conditioned on Bob’s state and action information) as it tells us how much influence Bob’s action has on Alex’s action distribution. In mathematical terms, it would correspond to penalizing $D _ { \mathrm { K L } } \left[ p _ { \mathrm { a } } ( a _ { a } \mid s _ { a } , z _ { r } ) \mid p _ { a } ( a _ { a } \mid s _ { a } ) \right]$ .
+
+In order to show this, we use the same setup as in the paper (Mordatch and Abbeel, 2018). The agent perform actions and communicate utterances according to policy which is identically instantiated for all the different agents. This policy determines the action, and the communication protocols. We assume all agents have identical action and observation spaces, and all agents act according to the same policy and receive a shared reward. We consider the cooperative setting, in which the problem is to find a policy that maximizes expected return for all the agents.Table 4 shows the training and test rewards as compared to the scenarios when there is no communication b/w different agents, when all the agents can communication with each other, and when there is a KL cost penalizing the KL b/w the conditional policy distribution and marginal policy distribution. As evident, agents trained with InfoBot cost achieves the best results.
+
+# D.1 MULTIAGENT COMMUNICATION
+
+The environment consists of N agents and M landmarks. Both the agents and landmarks exhibit different characteristics such as different color and shape type. Different agents can act to move in the environment. They can also act be effected by the interactions with other agents. Asides from taking physical actions, agents communicate with other agents using verbal communication symbols $c$ . We use the same setup as in the paper (Mordatch and Abbeel, 2018).
+
+![](images/76cfe358848a63d10e9bffc9e40a9d31b14c65884578a34b9cae61030b769fc1.jpg)  
+Figure 10: Visitation Count: Effect on visitation count as a result of giving KL as an exploration bonus. As top figure shows, that after giving KL as an exploration bouns, agent visits more diverse states. Here, the agent is trained on a smaller $6 \times 6$ maze, and evaluated on more complex $1 1 ^ { * } 1 1$ maze. The "blueness" quanitifies the states visited by the agent.
+
+E EFFECT ON VISITATION COUNT DUE TO EXPLORATION BONUS
+
+# F COMPARISON WITH OFF POLICY ALGORITHMS (SAC)
+
+In this section, we study in isolation the effect of proposed method as compared to the state of the art off-policy methods like SAC (Haarnoja et al., 2018). For this domain, we again use high value states as an approximation to the goal state following (Goyal et al., 2018). In order to implement this, we maintain a buffer of 20000 states, and choose the state with the highest value under the current value function, as a proxy to the goal.
+
+We compare the proposed method with SAC in sparse reward scenarios. We evaluate the proposed algorithm on 4 MuJoCo tasks in OpenAI Gym. (Brockman et al., 2016)
+
+The result in Figure 11 shows the performance of the proposed method showing improvement over the baseline on HalfCheetah-v2, Walker2d-v2, Hopper-v2 and Swimmer-v2 sparse reward tasks. We evaluate the performance by evaluating after every 50K steps. We plotted the performance of the proposed method as well as baseline for 500K steps. We averaged over 2 random seeds.
+
+# G INFORMATION REGULARIZATION FOR INSTRUCTION FOLLOWING
+
+Here we use the proposed method in the context of interactive worlds for spatial reasoning where the goal is given by language instruction. The agent is placed in an interactive world, and agent can take actions to reach the goal specified by language instruction. For ex. Reach the north-most house, the problem could be challenging because the language instruction is is highly contextdependent. Therefore, for better generalization to unseen worlds, the model must jointly reason over the instruction text and environment configuration.
+
+![](images/ac5cc17c07338416afe57a9f4e9a1c9442aff3dd5f2593ce0dc1e819fe696bda.jpg)  
+Figure 11: InfoBot comparison with state of the art off policy algorithm (SAC) on sparse reward mujoco envs.
+
+We model our task as a Markov Decision Process (MDP), where an agent can take actions to effect the world. The goal to the agent is specified by the language instruction. The MDP can be represented by the tuple (S,A,G,T,R), where S is the set of all possible states, A is the action set, G is the set of all goal specifications in natural language, $T ( s _ { n e x t } | s , a , g )$ is the transition distribution, and $\mathsf { R } ( \mathsf { s } , \mathsf { g } )$ is the reward function, which is dependent on both the current state as well as goal. A state $\mathbf { s } \in \mathbf { S }$ includes information such as the locations of different entities along with the agent’s own position.
+
+Puddle world navigation data In order to study generalization across a wide variety of environmental conditions and linguistic inputs, we follow the same experimental setup as in (Janner et al., 2018). Its basically an extension of the puddle world reinforcement learning benchmark. States in a grid are first filled with either grass or water cells, such that the grass forms one connected component. We then populate the grass region with six unique objects which appear only once per map (triangle, star, diamond, circle, heart, and spade) and four non-unique objects (rock, tree, horse, and house) which can appear any num- ber of times on a given map.
+
+We compare the proposed method to the UVFA (Schaul et al., 2015). We made use of one MLPs and the LSTM to learn low dimensional embeddings of states and goals respectively which are then combined via dot product to give value estimates. Goals are described in text described in text, and hence we use the LSTM over the language instruction. The state MLP has an identical architecture to that of the UVFA: two hidden layers of dimension 128 and ReLU activations.
+
+Text instructions can have both local and global references to objects. Local references require an understanding of spatial prepositional phrases such as ‘above’, ‘next to’ in order to reach the goal. This is invariant to the global position of the object references, on the other hand, global references contains superlatives such as ‘easternmost’ and ‘topmost’, which require reasoning over the entire map. For example, in the case of local reference, one could describe a unique object (e.g. Go to the circle), whereas for global reference might require comparing the positions of all objects of a specific type (e.g. Go to the northernmost tree). Fig. 12 shows randomly generated worlds.
+
+<table><tr><td>Method</td><td>Local - Policy Quality</td><td>Global - Policy Quality</td></tr><tr><td>UVFA</td><td>0.57</td><td>0.59</td></tr><tr><td>InfoBot (Proposed Method)</td><td>0.89</td><td>0.81</td></tr></table>
+
+Table 5: Performance of models trained via reinforcement learning on a held-out set of environments and instructions. Policy quality is the true expected normalized reward. We show results from training on the local and global instructions both separately and jointly.
+
+![](images/87aa5045bfd7f287d21fc9a62b5d618ec02a50baf5b72abc2576baf22509cb38.jpg)  
+Figure 12: Visualizations of randomly generated worlds
+
+# H MINIGRID ENVIRONMENTS FOR OPENAI GYM
+
+The FindObj and MultiRoom environments used for this research are part of MiniGrid, which is an open source gridworld package. This package includes a family reinforcement learning environments compatible with the OpenAI Gym framework. Many of these environments are parameterizable so that the difficulty of tasks can be adjusted (eg: the size of rooms is often adjustable).
+
+# H.1 THE WORLD
+
+In MiniGrid, the world is a grid of size NxN. Each tile in the grid contains exactly zero or one object. The possible object types are wall, door, key, ball, box and goal. Each object has an associated discrete color, which can be one of red, green, blue, purple, yellow and grey. By default, walls are always grey and goal squares are always green.
+
+# H.2 REWARD FUNCTION
+
+Rewards are sparse for all MiniGrid environments. In the MultiRoom environment, episodes are terminated with a positive reward when the agent reaches the green goal square. Otherwise, episodes are terminated with zero reward when a time step limit is reached. In the FindObj environment, the agent receives a positive reward if it reaches the object to be found, otherwise zero reward if the time step limit is reached.
+
+# H.3 ACTION SPACE
+
+There are seven actions in MiniGrid: turn left, turn right, move forward, pick up an object, drop an object, toggle and done. For the purpose of this paper, the pick up, drop and done actions are irrelevant. The agent can use the turn left and turn right action to rotate and face one of 4 possible directions (north, south, east, west). The move forward action makes the agent move from its current tile onto the tile in the direction it is currently facing, provided there is nothing on that tile, or that the tile contains an open door. The agent can open doors if they are right in front of it by using the toggle action.
+
+# H.4 OBSERVATION SPACE
+
+Observations in MiniGrid are partial and egocentric. By default, the agent sees a square of $7 \mathbf { x } 7$ tiles in the direction it is facing. These include the tile the agent is standing on. The agent cannot see through walls or closed doors. The observations are provided as a tensor of shape $7 \mathrm { x } 7 \mathrm { x } 3 $ . However, note that these are not RGB images. Each tile is encoded using 3 integer values: one describing the type of object contained in the cell, one describing its color, and a flag indicating whether doors are open or closed. This compact encoding was chosen for space efficiency and to enable faster training. The fully observable RGB image view of the environments shown in this paper is provided for human viewing.
+
+# H.5 LEVEL GENERATION
+
+The level generation in this task works as follows: (1) Generate the layout of the map (X number of rooms with different sizes (at most size Y) and green goal) (2) Add the agent to the map at a random location in the first room. (3) Add the goal at a random location in the last room. MultiRoomNXSY - In this task, the agent gets an egocentric view of its surroundings, consisting of $3 \times 3$ pixels. A neural network parameterized as MLP is used to process the visual observation.
+
+FindObjSY - In this task, the agent’s egocentric observation consists of $7 \times 7$ pixels. We use Convolutional Neural Networks to encode the visual observations.
+
+# I MINIPACMAN ENV
+
+Fuedal Networks primarily has four components: (1) Transition policy gradient, (2) Directional cosine similarity rewards, (3) Goals specified with respect to a learned representation, and (4) dilated RNN. For our work we use normal LSTMs, and hence we do not include design choice (4).

parse/train/uCQfPZwRaUu/uCQfPZwRaUu.md

@@ -0,0 +1,368 @@
+# DATA-EFFICIENT REINFORCEMENT LEARNING WITH SELF-PREDICTIVE REPRESENTATIONS
+
+Max Schwarzer∗ Mila, Université de Montréal
+
+Ankesh Anand∗ Mila, Université de Montréal Microsoft Research
+
+Rishab Goel Mila
+
+R Devon Hjelm Microsoft Research Mila, Université de Montréal
+
+Aaron Courville   
+Mila, Université de Montréal   
+CIFAR Fellow
+
+Philip Bachman Microsoft Research
+
+# ABSTRACT
+
+While deep reinforcement learning excels at solving tasks where large amounts of data can be collected through virtually unlimited interaction with the environment, learning from limited interaction remains a key challenge. We posit that an agent can learn more efficiently if we augment reward maximization with self-supervised objectives based on structure in its visual input and sequential interaction with the environment. Our method, Self-Predictive Representations (SPR), trains an agent to predict its own latent state representations multiple steps into the future. We compute target representations for future states using an encoder which is an exponential moving average of the agent’s parameters and we make predictions using a learned transition model. On its own, this future prediction objective outperforms prior methods for sample-efficient deep RL from pixels. We further improve performance by adding data augmentation to the future prediction loss, which forces the agent’s representations to be consistent across multiple views of an observation. Our full self-supervised objective, which combines future prediction and data augmentation, achieves a median human-normalized score of 0.415 on Atari in a setting limited to 100k steps of environment interaction, which represents a $55 \%$ relative improvement over the previous state-of-the-art. Notably, even in this limited data regime, SPR exceeds expert human scores on 7 out of 26 games. We’ve made the code associated with this work available at https://github.com/mila-iqia/spr.
+
+# 1 INTRODUCTION
+
+Deep Reinforcement Learning (deep RL, François-Lavet et al., 2018) has proven to be an indispensable tool for training successful agents on difficult sequential decision-making problems (Bellemare et al., 2013; Tassa et al., 2018). The success of deep RL is particularly noteworthy in highly complex, strategic games such as StarCraft (Vinyals et al., 2019) and DoTA2 (OpenAI et al., 2019), where deep RL agents now surpass expert human performance in some scenarios.
+
+Deep RL involves training agents based on large neural networks using large amounts of data (Sutton, 2019), a trend evident across both model-based (Schrittwieser et al., 2020) and model-free (Badia et al., 2020) learning. The sample complexity of such state-of-the-art agents is often incredibly high: MuZero (Schrittwieser et al., 2020) and Agent-57 (Badia et al., 2020) use 10-50 years of experience per Atari game, and OpenAI Five (OpenAI et al., 2019) uses 45,000 years of experience to accomplish its remarkable performance. This is clearly impractical: unlike easily-simulated environments such as video games, collecting interaction data for many real-world tasks is costly, making improved data efficiency a prerequisite for successful use of deep RL in these settings (Dulac-Arnold et al., 2019).
+
+![](images/49dcd1d1a1313bf1a7015ff2b01a758b13936f6641756d72e26f92c6e45cce91.jpg)  
+Figure 1: Median and Mean Human-Normalized scores of different methods across 26 games in the Atari 100k benchmark (Kaiser et al., 2019), averaged over 10 random seeds for SPR, and 5 seeds for most other methods except CURL, which uses 20. Each method is allowed access to only $1 0 0 \mathrm { k }$ environment steps or 400k frames per game. $( ^ { * } )$ indicates that the method uses data augmentation. SPR achieves state-of-art results on both mean and median human-normalized scores. Note that, even without data augmentation, SPR still outperforms all prior methods on both metrics.
+
+Meanwhile, new self-supervised representation learning methods have significantly improved data efficiency when learning new vision and language tasks, particularly in low data regimes or semisupervised learning (Xie et al., 2019; Hénaff et al., 2019; Chen et al., 2020b). Self-supervised methods improve data efficiency by leveraging a nearly limitless supply of training signal from tasks generated on-the-fly, based on “views" drawn from the natural structure of the data (e.g., image patches, data augmentation or temporal proximity, see Doersch et al., 2015; Oord et al., 2018; Hjelm et al., 2019; Tian et al., 2019; Bachman et al., 2019; He et al., 2020; Chen et al., 2020a).
+
+Motivated by successes in semi-supervised and self-supervised learning (Tarvainen & Valpola, 2017; Xie et al., 2019; Grill et al., 2020), we train better state representations for RL by forcing representations to be temporally predictive and consistent when subject to data augmentation. Specifically, we extend a strong model-free agent by adding a dynamics model which predicts future latent representations provided by a parameter-wise exponential moving average of the agent itself. We also add data augmentation to the future prediction task, which enforces consistency across different views of each observation. Contrary to some methods (Kaiser et al., 2019; Hafner et al., 2019), our dynamics model operates entirely in the latent space and does not rely on reconstructing raw states.
+
+We evaluate our method, which we call Self-Predictive Representations (SPR), on the 26 games in the Atari $1 0 0 \mathrm { k }$ benchmark (Kaiser et al., 2019), where agents are allowed only 100k steps of environment interaction (producing $4 0 0 \mathrm { k }$ frames of input) per game, which roughly corresponds to two hours of real-time experience. Notably, the human experts in Mnih et al. (2015) and Van Hasselt et al. (2016) were given the same amount of time to learn these games, so a budget of 100k steps permits a reasonable comparison in terms of data efficiency.
+
+In our experiments, we augment a modified version of Data-Efficient Rainbow (DER) (van Hasselt et al., 2019) with the SPR loss, and evaluate versions of SPR with and without data augmentation. We find that each version is superior to controlled baselines. When coupled with data augmentation, SPR achieves a median score of 0.415, which is a state-of-the-art result on this benchmark, outperforming prior methods by a significant margin. Notably, SPR also outperforms human expert scores on 7 out of 26 games while using roughly the same amount of in-game experience.
+
+# 2 METHOD
+
+We consider reinforcement learning (RL) in the standard Markov Decision Process (MDP) setting where an agent interacts with its environment in episodes, each consisting of sequences of observations, actions and rewards. We use $s _ { t }$ , $a _ { t }$ and $r _ { t }$ to denote the state, the action taken by the agent and the reward received at timestep $t$ . We seek to train an agent whose expected cumulative reward in each episode is maximized. To do this, we combine a strong model-free RL algorithm, Rainbow (Hessel
+
+![](images/3f5fc22c76d0f1c31c630eadd7dc070652f14b27632364081ef9738825e9c7b4.jpg)  
+Figure 2: An illustration of the full SPR method. Representations from the online encoder are used in the reinforcement learning task and for prediction of future representations from the target encoder via the transition model. The target encoder and projection head are defined as an exponential moving average of their online counterparts and are not updated via gradient descent. For brevity, we illustrate only the $k ^ { \mathrm { { t h } } }$ step of future prediction, but in practice we compute the loss over all steps from 1 to $K$ . Note: our implementation for this paper includes $g _ { o }$ in the Q-learning head.
+
+et al., 2018), with Self-Predictive Representations as an auxiliary loss to improve sample efficiency.   
+We now describe our overall approach in detail.
+
+# 2.1 DEEP Q-LEARNING
+
+We focus on the Atari Learning Environment (Bellemare et al., 2013), a challenging setting where the agent takes discrete actions while receiving purely visual, pixel-based observations. A prominent method for solving Atari, Deep Q Networks (Mnih et al., 2015), trains a neural network $Q _ { \theta }$ to approximate the agent’s current $Q$ -function (policy evaluation) while updating the agent’s policy greedily with respect to this Q-function (policy improvement). This involves minimizing the error between predictions from $Q _ { \theta }$ and a target value estimated by $Q _ { \xi }$ , an earlier version of the network:
+
+$$
+\mathcal { L } _ { \theta } ^ { D Q N } = \left( Q _ { \theta } ( s _ { t } , a _ { t } ) - ( r _ { t } + \gamma \operatorname* { m a x } _ { a } Q _ { \xi } ( s _ { t + 1 } , a ) ) \right) ^ { 2 } .
+$$
+
+Various improvements have been made over the original DQN: Distributional RL (Bellemare et al., 2017) models the full distribution of future reward rather than just the mean, Dueling DQN (Wang et al., 2016) decouples the value of a state from the advantage of taking a given action in that state, Double DQN (Van Hasselt et al., 2016) modifies the Q-learning update to avoid overestimation due to the max operation, among many others. Rainbow (Hessel et al., 2018) consolidates these improvements into a single combined algorithm and has been adapted to work well in data-limited regimes (van Hasselt et al., 2019).
+
+# 2.2 SELF-PREDICTIVE REPRESENTATIONS
+
+For our auxiliary loss, we start with the intuition that encouraging state representations to be predictive of future states given future actions should improve the data efficiency of RL algorithms. Let $\left( s _ { t : t + K } , a _ { t : t + K } \right)$ denote a sequence of $K + 1$ previously experienced states and actions sampled from a replay buffer, where $K$ is the maximum number of steps into the future which we want to predict. Our method has four main components which we describe below:
+
+• Online and Target networks: We use an online encoder $f _ { o }$ to transform observed states $s _ { t }$ into representations $z _ { t } \triangleq f _ { o } ( s _ { t } )$ . We use these representations in an objective that encourages them to be predictive of future observations up to some fixed temporal offset $K$ , given a sequence of $K$ actions to perform. We augment each observation $s _ { t }$ independently when using data augmentation. Rather than predicting representations produced by the online encoder, we follow prior work (Tarvainen & Valpola, 2017; Grill et al., 2020) by computing target representations for future states using a target encoder $f _ { \mathrm { m } }$ , whose parameters are an exponential moving average (EMA) of the online encoder parameters. Denoting the parameters of $f _ { \mathrm { o } }$ as $\theta _ { \mathrm { o } }$ , those of $f _ { \mathrm { m } }$ as $\theta _ { \mathrm { m } }$ , and the EMA coefficient as $\bar { \boldsymbol { \tau } } \in [ 0 , 1 )$ , the update rule for $\theta _ { \mathrm { m } }$ is:
+
+$$
+\theta _ { \mathrm { { m } } }  \tau \theta _ { \mathrm { { m } } } + ( 1 - \tau ) \theta _ { \mathrm { { o } } } .
+$$
+
+The target encoder is not updated via gradient descent. The special case $\tau = 0 , \ \theta _ { m } = \theta _ { o }$ is noteworthy, as it performs well when regularization is already provided by data augmentation.
+
+• Transition Model: For the prediction objective, we generate a sequence of $K$ predictions $\hat { z } _ { t + 1 : t + K }$ of future state representations $\tilde { z } _ { t + 1 : t + K }$ using an action-conditioned transition model $h$ . We compute $\hat { z } _ { t + 1 : t + K }$ iteratively: $\hat { z } _ { t + k + 1 } \triangleq h ( \hat { z } _ { t + k } , a _ { t + k } )$ , starting from $\hat { z } _ { t } \triangleq z _ { t } \triangleq f _ { o } ( s _ { t } )$ . We compute $\tilde { z } _ { t + 1 : t + K }$ by applying the target encoder $f _ { m }$ to the observed future states $s _ { t + 1 : t + K }$ : $\tilde { z } _ { t + k } \triangleq f _ { m } ( s _ { t + k } )$ . The transition model and prediction loss operate in the latent space, thus avoiding pixel-based reconstruction objectives. We describe the architecture of $h$ in section 2.3.
+
+• Projection Heads: We use online and target projection heads $g _ { o }$ and $g _ { m }$ (Chen et al., 2020a) to project online and target representations to a smaller latent space, and apply an additional prediction head $q$ (Grill et al., 2020) to the online projections to predict the target projections:
+
+$$
+\hat { y } _ { t + k } \triangleq q ( g _ { o } ( \hat { z } _ { t + k } ) ) , \forall \hat { z } _ { t + k } \in \hat { z } _ { t + 1 : t + K } ; \quad \tilde { y } _ { t + k } \triangleq g _ { m } ( \tilde { z } _ { t + k } ) , \forall \tilde { z } _ { t + k } \in \tilde { z } _ { t + 1 : t + K } .
+$$
+
+The target projection head parameters are given by an EMA of the online projection head parameters, using the same update as the online and target encoders.
+
+• Prediction Loss: We compute the future prediction loss for SPR by summing over cosine similarities1 between the predicted and observed representations at timesteps $t + k$ for $1 \leq k \leq K$ :
+
+$$
+\mathcal { L } _ { \theta } ^ { \mathrm { S P R } } ( s _ { t : t + K } , a _ { t : t + K } ) = - \sum _ { k = 1 } ^ { K } \left( \frac { \tilde { y } _ { t + k } } { | | \tilde { y } _ { t + k } | | _ { 2 } } \right) ^ { \top } \left( \frac { \hat { y } _ { t + k } } { | | \hat { y } _ { t + k } | | _ { 2 } } \right) ,
+$$
+
+where $\tilde { y } _ { t + k }$ and $\hat { y } _ { t + k }$ are computed from $\left( s _ { t : t + K } , a _ { t : t + K } \right)$ as we just described.
+
+We call our method Self-Predictive Representations (SPR), following the predictive nature of the objective and the use of an exponential moving average target network similar to (Tarvainen $\&$ Valpola, 2017; He et al., 2020). During training, we combine the SPR loss with the Q-learning loss for Rainbow. The SPR loss affects $f _ { o }$ , $g _ { o }$ , $q$ and $h$ . The $\mathbf { Q }$ -learning loss affects $f _ { o }$ and the Q-learning head, which contains additional layers specific to Rainbow. Denoting the Q-learning loss from Rainbow as ${ \mathcal { L } } _ { \theta } ^ { \mathrm { R L } }$ , our full optimization objective is: $\mathcal { L } _ { \theta } ^ { \mathrm { t o t a l } } = \mathcal { L } _ { \theta } ^ { \mathrm { R L } } + \lambda \mathcal { L } _ { \theta } ^ { \mathrm { S P R } }$ .
+
+Unlike some other proposed methods for representation learning in reinforcement learning (Srinivas et al., 2020), SPR can be used with or without data augmentation, including in contexts where data augmentation is unavailable or counterproductive. Moreover, compared to related work on contrastive representation learning, SPR does not use negative samples, which may require careful design of contrastive tasks, large batch sizes (Chen et al., 2020a), or the use of a buffer to emulate large batch sizes (He et al., 2020)
+
+# 2.3 TRANSITION MODEL ARCHITECTURE
+
+For the transition model $h$ , we apply a convolutional network directly to the $6 4 \times 7 \times 7$ spatial output of the convolutional encoder $f _ { o }$ . The network comprises two 64-channel convolutional layers with $3 \times 3$ filters, with batch normalization (Ioffe & Szegedy, 2015) after the first convolution and ReLU nonlinearities after each convolution. We append a one-hot vector representing the action taken to each location in the input to the first convolutional layer, similar to Schrittwieser et al. (2020). We use a maximum prediction depth of $K = 5$ , and we truncate calculation of the SPR loss at episode boundaries to avoid encoding environment reset dynamics into the model.
+
+Algorithm 1: Self-Predictive Representations   
+
+<table><tr><td>Denote parameters of online encoder f。and projection g。as 0o Denote parameters of target encoder fm and projection gm as 0m Denote parameters of transition model h, predictor q and Q-learning head as Φ Denote the maximum prediction depth as K,batch size as N initializereplaybufferB whileTrainingdo collect experience (s,a,r,s&#x27;) with (0.,) and add to buffer B sample a minibatch of sequences of (s,a,r,s&#x27;) ~ B for i in range(O, N) do if augmentation then s ← augment(s𝑖); s&#x27; ← augment(s&#x27;) end ←fo(s) // online representations ←0 for k in (l,...,K) do ←h(（2-10×-1） // latent states via transition model ←fm（） // target representations</td></tr></table>
+
+# 2.4 DATA AUGMENTATION
+
+When using augmentation, we use the same set of image augmentations as in $\mathrm { D r Q }$ from Yarats et al. (2021), consisting of small random shifts and color jitter. We normalize activations to lie in $[ 0 , 1 ]$ at the output of the convolutional encoder and transition model, as in Schrittwieser et al. (2020). We use Kornia (Riba et al., 2020) for efficient GPU-based data augmentations.
+
+When not using augmentation, we find that SPR performs better when dropout (Srivastava et al., 2014) with probability 0.5 is applied at each layer in the online and target encoders. This is consistent with Laine & Aila (2017); Tarvainen & Valpola (2017), who find that adding noise inside the network is important when not using image-specific augmentation, as proposed by Bachman et al. (2014).
+
+# 2.5 IMPLEMENTATION DETAILS
+
+For our Atari experiments, we largely follow van Hasselt et al. (2019) for DQN hyperparameters, with four exceptions. We follow DrQ (Yarats et al., 2021) by: using the 3-layer convolutional encoder from Mnih et al. (2015), using 10-step returns instead of 20-step returns for Q-learning, and not using a separate DQN target network when using augmentation. We also perform two gradient steps per environment step instead of one. We show results for this configuration with and without augmentation in Table 5, and confirm that these changes are not themselves responsible for our performance. We reuse the first layer of the DQN MLP head as the SPR projection head $g _ { o }$ . When using dueling DQN (Wang et al., 2016), $g _ { o }$ concatenates the outputs of the first layers of the value and advantage heads. When these layers are noisy (Fortunato et al., 2018), $g _ { o }$ does not use the noisy parameters. Finally, we parameterize the predictor $q$ as a linear layer. We use $\tau = 0 . 9 9$ when augmentation is disabled and $\tau = 0$ when enabled. For $\mathcal { L } _ { \theta } ^ { \mathrm { t o t a l } } = \mathcal { L } _ { \theta } ^ { \mathrm { R L } } + \lambda \mathcal { L } _ { \theta } ^ { \mathrm { S P R } }$ , we use $\lambda = 2$
+
+Hyperparameters were tuned over a subset of games (following Mnih et al., 2015; Machado et al., 2018). We list the complete hyperparameters in Table 3.
+
+Our implementation uses rlpyt (Stooke & Abbeel, 2019) and PyTorch (Paszke et al., 2019). We find that SPR modestly increases the time required for training, which we discuss in more detail in Appendix D.
+
+# 3 RELATED WORK
+
+# 3.1 DATA-EFFICIENT RL:
+
+A number of works have sought to improve sample efficiency in deep RL. SiMPLe (Kaiser et al., 2019) learns a pixel-level transition model for Atari to generate simulated training data, achieving strong results on several games in the $1 0 0 \mathrm { k }$ frame setting, at the cost of requiring several weeks for training. However, van Hasselt et al. (2019) and Kielak (2020) introduce variants of Rainbow (Hessel et al., 2018) tuned for sample efficiency, Data-Efficient Rainbow (DER) and OTRainbow, which achieve comparable or superior performance with far less computation.
+
+In the context of continuous control, several works propose to leverage a latent-space model trained on reconstruction loss to improve sample efficiency (Hafner et al., 2019; Lee et al., 2019; Hafner et al., 2020). Most recently, DrQ (Yarats et al., 2021) and RAD (Laskin et al., 2020) have found that applying modest image augmentation can substantially improve sample efficiency in reinforcement learning, yielding better results than prior model-based methods. Data augmentation has also been found to improve generalization of reinforcement learning methods (Combes et al., 2018; Laskin et al., 2020) in multi-task and transfer settings. We show that data augmentation can be more effectively leveraged in reinforcement learning by forcing representations to be consistent between different augmented views of an observation while also predicting future latent states.
+
+# 3.2 REPRESENTATION LEARNING IN RL:
+
+Representation learning has a long history of use in RL – see Lesort et al. (2018). For example, CURL (Srinivas et al., 2020) proposed a combination of image augmentation and a contrastive loss to perform representation learning for RL. However, follow-up results from RAD (Laskin et al., 2020) suggest that most of the benefits of CURL come from image augmentation, not its contrastive loss.
+
+CPC (Oord et al., 2018), CPC|Action (Guo et al., 2018), ST-DIM (Anand et al., 2019) and DRIML (Mazoure et al., 2020) propose to optimize various temporal contrastive losses in reinforcement learning environments. We perform an ablation comparing such temporal contrastive losses to our method in Section 5. Kipf et al. (2019) propose to learn object-oriented contrastive representations by training a structured transition model based on a graph neural network.
+
+SPR bears some resemblance to DeepMDP (Gelada et al., 2019), which trains a transition model with an unnormalized L2 loss to predict representations of future states, along with a reward prediction objective. However, DeepMDP uses its online encoder to generate prediction targets rather than employing a target encoder, and is thus prone to representational collapse (sec. C.5 in Gelada et al. (2019)). To mitigate this issue, DeepMDP relies on an additional observation reconstruction objective. In contrast, our model is self-supervised, trained entirely in the latent space, and uses a normalized loss. Our ablations (sec. 5) demonstrate that using a target encoder has a large impact on our method.
+
+SPR is also similar to PBL (Guo et al., 2020), which directly predicts representations of future states. However, PBL uses two separate target networks trained via gradient descent, whereas SPR uses a single target encoder, updated without backpropagation. Moreover, PBL studies multitask generalization in the asymptotic limits of data, whereas SPR is concerned with single-task performance in low data regimes, using $0 . 0 1 \%$ as much data as PBL. Unlike PBL, SPR additionally enforces consistency across augmentations, which empirically provides a large boost in performance.
+
+# 4 RESULTS
+
+We test SPR on the sample-efficient Atari setting introduced by Kaiser et al. (2019) and van Hasselt et al. (2019). In this task, only 100,000 environment steps of training data are available – equivalent to
+
+400,000 frames, or just under two hours – compared to the typical standard of 50,000,000 environment steps, or roughly 39 days of experience. When used without data augmentation, SPR demonstrates scores comparable to the previous best result from Yarats et al. (2021). When combined with data augmentation, SPR achieves a median human-normalized score of 0.415, which is a new state-of-theart result on this task. SPR achieves super-human performance on seven games in this data-limited setting: Boxing, Krull, Kangaroo, Road Runner, James Bond and Crazy Climber, compared to a maximum of two for any previous methods, and achieves scores higher than DrQ (the previous state-of-the-art method) on 23 out of 26 games. See Table 1 for aggregate metrics and Figure 3 for a visualization of results. A full list of scores is presented in Table 4 in the appendix. For consistency with previous works, we report human and random scores from Wang et al. (2016).
+
+Table 1: Performance of different methods on the 26 Atari games considered by Kaiser et al. (2019) after $1 0 0 \mathrm { k }$ environment steps. Results are recorded at the end of training and averaged over 10 random seeds for SPR, 20 for CURL, and 5 for other methods. SPR outperforms prior methods on all aggregate metrics, and exceeds expert human performance on 7 out of 26 games.   
+
+<table><tr><td>Metric</td><td>Random</td><td>Human</td><td>SimPLe</td><td>DER</td><td>OTRainbow</td><td>CURL</td><td>DrQ</td><td>SPR (no Aug)</td><td>SPR</td></tr><tr><td>Mean Human-Norm&#x27;d</td><td>0.000</td><td>1.000</td><td>0.443</td><td>0.285</td><td>0.264</td><td>0.381</td><td>0.357</td><td>0.463</td><td>0.704</td></tr><tr><td>Median Human-Norm&#x27;d</td><td>0.000</td><td>1.000</td><td>0.144</td><td>0.161</td><td>0.204</td><td>0.175</td><td>0.268</td><td>0.307</td><td>0.415</td></tr><tr><td>Mean DQN @ 50M-Norm&#x27;d</td><td>0.000</td><td>23.382</td><td>0.232</td><td>0.239</td><td>0.197</td><td>0.325</td><td>0.171</td><td>0.336</td><td>0.510</td></tr><tr><td>Median DQN@50M-Norm&#x27;d</td><td>0.000</td><td>0.994</td><td>0.118</td><td>0.142</td><td>0.103</td><td>0.142</td><td>0.131</td><td>0.225</td><td>0.361</td></tr><tr><td># Games Superhuman</td><td>0</td><td>N/A</td><td>2</td><td>2</td><td>1</td><td>2</td><td>2</td><td>5</td><td>7</td></tr></table>
+
+![](images/e5d7b05ca34630c1f7e357f67bba9843a60502fc26542a3d0096e681f165c19f.jpg)  
+Figure 3: A boxplot of the distribution of human-normalized scores across the 26 Atari games under consideration, after $1 0 0 \mathrm { k }$ environment steps. The whiskers represent the interquartile range of human-normalized scores over the 26 games. Scores for each game are recorded at the end of training and averaged over 10 random seeds for SPR, 20 for CURL, and 5 for other methods.
+
+# 4.1 EVALUATION
+
+We evaluate the performance of different methods by computing the average episodic return at the end of training. We normalize scores with respect to expert human scores to account for different scales of scores in each game, as done in previous works. The human-normalized score of an agent on a game is calculated as $\frac { \mathrm { a g e n t ~ s c o r e - r a n d o m ~ s c o r e } } { \mathrm { h u m a n ~ s c o r e - r a n d o m ~ s c o r e } }$ and aggregated across the 26 games by mean or median.
+
+We find that human scores on some games are so high that differences between methods are washed out by normalization, making it hard for these games to influence aggregate metrics. Moreover, we find that the median score is typically only influenced by a handful of games. Both these factors compound together to make the median human-normalized score an unreliable metric for judging overall performance. To address this, we also report DQN-normalized scores, defined analogously to human-normalized scores and calculated using scores from DQN agents (Mnih et al., 2015) trained over 50 million steps, and report both mean and median of those metrics in all results and ablations, and plot the distribution of scores over all the games in Figure 3.
+
+Table 2: Scores on the 26 Atari games under consideration for ablated variants of SPR. All variants listed here use data augmentation.   
+
+<table><tr><td rowspan="2">Variant</td><td colspan="2">Human-Normalized Score</td><td colspan="2">DQN@ 50M-Normalized Score</td></tr><tr><td>mean</td><td>median</td><td>mean</td><td>median</td></tr><tr><td>SPR</td><td>0.704</td><td>0.415</td><td>0.510</td><td>0.361</td></tr><tr><td>1-step SPR</td><td>0.570</td><td>0.301</td><td>0.337</td><td>0.346</td></tr><tr><td>Non-temporal SPR</td><td>0.507</td><td>0.271</td><td>0.326</td><td>0.295</td></tr><tr><td>Quadratic SPR</td><td>0.047</td><td>0.040</td><td>-0.016</td><td>0.031</td></tr><tr><td>SPR without projections</td><td>0.437</td><td>0.171</td><td>0.247</td><td>0.174</td></tr><tr><td>Rainbow (controlled, w/ aug.)</td><td>0.480</td><td>0.346</td><td>0.284</td><td>0.278</td></tr></table>
+
+Additionally, we note that the standard evaluation protocol of evaluating over only 500,000 frames per game is problematic, as the quantity we are trying to measure is expected return over episodes. Because episodes may last up to up to 108,000 frames, this method may collect as few as four complete episodes. As variance of results is already a concern in deep RL (see Henderson et al., 2018), we recommend evaluating over 100 episodes irrespective of their length. Moreover, to address findings from Henderson et al. (2018) that comparisons based on small numbers of random seeds are unreliable, we average our results over ten random seeds, twice as many as most previous works.
+
+# 5 ANALYSIS
+
+The target encoder We find that using a separate target encoder is vital in all cases. A variant of SPR in which target representations are generated by the online encoder without a stopgradient (as done by e.g., Gelada et al., 2019) exhibits catastrophically reduced performance, with median human-normalized score of 0.278 with augmentation versus 0.415 for SPR. However, there is more flexibility in the EMA constant used for the target encoder. When using augmentation, a value of $\tau = 0$ performs best, while without augmentation we use $\tau = 0 . 9 9$ . The success of $\tau = 0$ is interesting, since the related method BYOL reports very poor representation learning performance in this case. We hypothesize that optimizing a reinforcement learning objective in parallel with the SPR loss explains this difference, as it provides an additional gradient which discourages representational collapse. Full results for these experiments are presented in Appendix C.
+
+![](images/be818b8704340908247494a2e38f7d696c0bc0d09f28ef62baff6e8817cbe475.jpg)  
+Figure 4: Performance of SPR with various prediction depths. Results are averaged across ten seeds per game, for all 26 games. To equalize the importance of games, we calculate an SPR-normalized score analogously to human-normalized scores, and show its mean and median across all 26 games. All other hyperparameters are identical to those used for SPR with augmentation.
+
+Dynamics modeling is key A key distinction between SPR and other recent approaches leveraging representation learning for reinforcement learning, such as CURL (Srinivas et al., 2020) and DRIML (Mazoure et al., 2020), is our use of an explicit multistep dynamics model. To illustrate the impact of dynamics modeling, we test SPR with a variety of prediction depths $K$ . Two of these ablations, one with no dynamics modeling and one that models only a single step of dynamics, are presented in Table 2 (as Non-temporal SPR and $^ { l }$ -step $S P R$ ), and all are visualized in Figure 4. We find that extended dynamics modeling consistently improves performance up to roughly $K = 5$ . Moving beyond this continues to improve performance on a subset of games, at the cost of increased computation. Note that the non-temporal ablation we test is similar to
+
+using BYOL (Grill et al., 2020) as an auxiliary task, with particular architecture choices made for the projection layer and predictor.
+
+Comparison with contrastive losses Though many recent works in representation learning employ contrastive learning, we find that SPR consistently outperforms both temporal and non-temporal variants of contrastive losses (see Table 6, appendix), including CURL (Srinivas et al., 2020).
+
+Using a quadratic loss causes collapse SPR’s use of a cosine similarity objective (or a normalized L2 loss) sets it in contrast to some previous works, such as DeepMDP (Gelada et al., 2019), which have learned latent dynamics models by minimizing an un-normalized L2 loss over predictions of future latents. To examine the importance of this objective, we test a variant of SPR that minimizes un-normalized L2 loss (Quadratic SPR in Table 2), and find that it performs only slightly better than random. This is consistent with results from Gelada et al. (2019), who find that DeepMDP’s representations are prone to collapse, and use an auxiliary reconstruction objective to prevent this.
+
+Projections are critical Another distinguishing feature of SPR is its use of projection and prediction networks. We test a variant of SPR that uses neither, instead computing the SPR loss directly over the $6 4 \times 7 \times 7$ convolutional feature map used by the transition model (SPR without projections in Table 2). We find that this variant has inferior performance, and suggest two possible explanations. First, the convolutional network represents only a small fraction of the capacity of SPR’s network, containing only some 80,000 parameters out of a total of three to four million. Employing the first layer of the DQN head as a projection thus allows the SPR objective to affect far more of the network, while in this variant its impact is limited. Second, the effects of SPR in forcing invariance to augmentation may be undesirable at this level; as the convolutional feature map is the product of only three layers, it may be challenging to learn features that are simultaneously rich and invariant.
+
+# 6 FUTURE WORK
+
+Recent work in both visual (Chen et al., 2020b) and language representation learning (Brown et al., 2020) has suggested that self-supervised models trained on large datasets perform exceedingly well on downstream problems with limited data, often outperforming methods trained using only task-specific data. Future works could similarly exploit large corpora of unlabelled data, perhaps from multiple MDPs or raw videos, to further improve the performance of RL methods in low-data regimes. As the SPR objective is unsupervised, it could be directly applied in such settings.
+
+Another interesting direction is to use the transition model learned by SPR for planning. MuZero (Schrittwieser et al., 2020) has demonstrated that planning with a model supervised via reward and value prediction can work extremely well given sufficient (massive) amounts of data. It remains unclear whether such models can work well in low-data regimes, and whether augmenting such models with self-supervised objectives such as SPR can improve their data efficiency.
+
+It would also be interesting to examine whether self-supervised methods like SPR can improve generalization to unseen tasks or changes in environment, similar to how unsupervised pretraining on ImageNet can generalize to other datasets (He et al., 2020; Grill et al., 2020).
+
+# 7 CONCLUSION
+
+In this paper we introduced Self-Predictive Representations (SPR), a self-supervised representation learning algorithm designed to improve the data efficiency of deep reinforcement learning agents. SPR learns representations that are both temporally predictive and consistent across different views of environment observations, by directly predicting representations of future states produced by a target encoder. SPR achieves state-of-the-art performance on the $1 0 0 \mathrm { k }$ steps Atari benchmark, demonstrating significant improvements over prior work. Our experiments show that SPR is highly robust, and is able to outperform the previous state of the art when either data augmentation or temporal prediction is disabled. We identify important directions for future work, and hope continued research at the intersection of self-supervised learning and reinforcement learning leads to algorithms which rival the efficiency and robustness of humans.
+
+# ACKNOWLEDGEMENTS
+
+We are grateful for the collaborative research environment provided by Mila and Microsoft Research. We would also like to acknowledge Hitachi for providing funding support for this project. We thank Nitarshan Rajkumar and Evan Racah for providing feeback on an earlier draft; Denis Yarats and Aravind Srinivas for answering questions about DrQ and CURL; Michal Valko, Sherjil Ozair and the BYOL team for long discussions about BYOL, and Phong Nguyen for helpful discussions. Finally, we thank Compute Canada and Microsoft Research for providing computational resources used in this project.
+
+# REFERENCES
+
+Ankesh Anand, Evan Racah, Sherjil Ozair, Yoshua Bengio, Marc-Alexandre Côté, and R Devon Hjelm. Unsupervised state representation learning in atari. In NeurIPS, 2019. Cited on page 6.
+
+Philip Bachman, Ouais al Sharif, and Doina Precup. Learning with pseudo-ensembles. In NeurIPS, 2014. Cited on page 5.
+
+Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In NeurIPS, 2019. Cited on page 2.
+
+Adrià Puigdomènech Badia, Bilal Piot, Steven Kapturowski, Pablo Sprechmann, Alex Vitvitskyi, Daniel Guo, and Charles Blundell. Agent57: Outperforming the atari human benchmark. In ICML, 2020. Cited on page 1.
+
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47, 2013. Cited on pages 1 and 3.
+
+Marc G Bellemare, Will Dabney, and Rémi Munos. A distributional perspective on reinforcement learning. In ICML, 2017. Cited on page 3.
+
+Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. In NeurIPS, 2020. Cited on page 9.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In ICML, 2020a. Cited on pages 2, 4, and 16.
+
+Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey Hinton. Big self-supervised models are strong semi-supervised learners. In NeurIPS, 2020b. Cited on pages 2 and 9.
+
+Remi Tachet des Combes, Philip Bachman, and Harm van Seijen. Learning invariances for policy generalization. arXiv preprint arXiv:1809.02591, 2018. Cited on page 6.
+
+Carl Doersch, Abhinav Gupta, and Alexei A Efros. Unsupervised visual representation learning by context prediction. In ICCV, 2015. Cited on page 2.
+
+Gabriel Dulac-Arnold, Daniel Mankowitz, and Todd Hester. Challenges of real-world reinforcement learning. In ICML, 2019. Cited on page 1.
+
+Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Matteo Hessel, Ian Osband, Alex Graves, Volodymyr Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, and Shane Legg. Noisy networks for exploration. In ICLR, 2018. Cited on page 5.
+
+Vincent François-Lavet, Peter Henderson, Riashat Islam, Marc G Bellemare, and Joelle Pineau. An introduction to deep reinforcement learning. arXiv preprint arXiv:1811.12560, 2018. Cited on page 1.
+
+Carles Gelada, Saurabh Kumar, Jacob Buckman, Ofir Nachum, and Marc G Bellemare. Deepmdp: Learning continuous latent space models for representation learning. In ICML, 2019. Cited on pages 6, 8, and 9.
+
+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. In NeurIPS, 2020. Cited on pages 2, 4, 9, and 17.
+
+Daniel Guo, Bernardo Avila Pires, Bilal Piot, Jean-bastien Grill, Florent Altché, Rémi Munos, and Mohammad Gheshlaghi Azar. Bootstrap latent-predictive representations for multitask reinforcement learning. In ICML, 2020. Cited on page 6.
+
+Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, Bilal Piot, Bernardo A Pires, and Rémi Munos. Neural predictive belief representations. ICML, 2018. Cited on pages 6 and 16.
+
+Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. In ICML, 2019. Cited on pages 2 and 6.
+
+Danijar Hafner, Timothy Lillicrap, Jimmy Ba, and Mohammad Norouzi. Dream to control: Learning behaviors by latent imagination. In ICLR, 2020. Cited on page 6.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In CVPR, 2020. Cited on pages 2, 4, and 9.
+
+Olivier J Hénaff, Aravind Srinivas, Jeffrey De Fauw, Ali Razavi, Carl Doersch, SM Eslami, and Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019. Cited on page 2.
+
+Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. In AAAI, 2018. Cited on page 8.
+
+Matteo Hessel, Joseph Modayil, Hado van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Gheshlaghi Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. In AAAI, 2018. Cited on pages 2, 3, and 6.
+
+R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In ICLR, 2019. Cited on page 2.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015. Cited on page 4.
+
+Łukasz Kaiser, Mohammad Babaeizadeh, Piotr Miłos, Błazej Osi ˙ nski, Roy H Campbell, Konrad ´ Czechowski, Dumitru Erhan, Chelsea Finn, Piotr Kozakowski, Sergey Levine, et al. Model based reinforcement learning for atari. In ICLR, 2019. Cited on pages 2, 6, 7, 15, and 18.
+
+Kacper Piotr Kielak. Do recent advancements in model-based deep reinforcement learning really improve data efficiency?, 2020. URL https://openreview.net/forum?id= Bke9u1HFwB. Cited on pages 6 and 15.
+
+Thomas Kipf, Elise van der Pol, and Max Welling. Contrastive learning of structured world models. In ICLR, 2019. Cited on page 6.
+
+Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In ICLR, 2017. Cited on page 5.
+
+Michael Laskin, Kimin Lee, Adam Stooke, Lerrel Pinto, Pieter Abbeel, and Aravind Srinivas. Reinforcement learning with augmented data. In NeurIPS, 2020. Cited on page 6.
+
+Alex X Lee, Anusha Nagabandi, Pieter Abbeel, and Sergey Levine. Stochastic latent actor-critic: Deep reinforcement learning with a latent variable model. arXiv preprint arXiv:1907.00953, 2019. Cited on page 6.
+
+Timothée Lesort, Natalia Díaz-Rodríguez, Jean-Franois Goudou, and David Filliat. State representation learning for control: An overview. Neural Networks, 108, 2018. Cited on page 6.
+
+Marlos C Machado, Marc G Bellemare, Erik Talvitie, Joel Veness, Matthew Hausknecht, and Michael Bowling. Revisiting the arcade learning environment: Evaluation protocols and open problems for general agents. Journal of Artificial Intelligence Research, 61:523–562, 2018. Cited on page 6.
+
+Bogdan Mazoure, Remi Tachet des Combes, Thang Doan, Philip Bachman, and R Devon Hjelm. Deep reinforcement and infomax learning. In NeurIPS, 2020. Cited on pages 6 and 8.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540), 2015. Cited on pages 2, 3, 5, 6, and 7.
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. Cited on pages 2, 6, and 16.
+
+OpenAI, Christopher Berner, Greg Brockman, Brooke Chan, Vicki Cheung, Przemysław D˛ebiak, Christy Dennison, David Farhi, Quirin Fischer, Shariq Hashme, Chris Hesse, Rafal Józefowicz, Scott Gray, Catherine Olsson, Jakub Pachocki, Michael Petrov, Henrique Pondé de Oliveira Pinto, Jonathan Raiman, Tim Salimans, Jeremy Schlatter, Jonas Schneider, Szymon Sidor, Ilya Sutskever, Jie Tang, Filip Wolski, and Susan Zhang. Dota 2 with large scale deep reinforcement learning. arXiv preprint arXiv:1912.06680, 2019. Cited on page 1.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. In NeurIPS, 2019. Cited on page 6.
+
+Edgar Riba, Dmytro Mishkin, Daniel Ponsa, Ethan Rublee, and Gary Bradski. Kornia: an open source differentiable computer vision library for pytorch. In The IEEE Winter Conference on Applications of Computer Vision, 2020. Cited on page 5.
+
+Julian Schrittwieser, Ioannis Antonoglou, Thomas Hubert, Karen Simonyan, Laurent Sifre, Simon Schmitt, Arthur Guez, Edward Lockhart, Demis Hassabis, Thore Graepel, et al. Mastering atari, go, chess and shogi by planning with a learned model. Nature, 2020. Cited on pages 1, 4, 5, and 9.
+
+Aravind Srinivas, Michael Laskin, and Pieter Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. In ICML, 2020. Cited on pages 4, 6, 8, 9, and 16.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1), 2014. Cited on page 5.
+
+Adam Stooke and Pieter Abbeel. rlpyt: A research code base for deep reinforcement learning in pytorch. arXiv preprint arXiv:1909.01500, 2019. Cited on page 6.
+
+Richard Sutton. The bitter lesson. Incomplete Ideas (blog), 2019. http://www. incompleteideas.net/IncIdeas/BitterLesson.html. Cited on page 1.
+
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NeurIPS, 2017. Cited on pages 2, 4, 5, and 17.
+
+Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018. Cited on page 1.
+
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019. Cited on page 2.
+
+Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. In AAAI, 2016. Cited on pages 2 and 3.
+
+Hado P van Hasselt, Matteo Hessel, and John Aslanides. When to use parametric models in reinforcement learning? In NeurIPS, 2019. Cited on pages 2, 3, 5, 6, and 16.
+
+Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 2019. Cited on page 1.
+
+Tongzhou Wang and Phillip Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. In Hal Daumé III and Aarti Singh (eds.), Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pp. 9929–9939. PMLR, 13–18 Jul 2020. URL http://proceedings.mlr.press/v119/wang20k.html. Cited on page 16.
+
+Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Hasselt, Marc Lanctot, and Nando Freitas. Dueling network architectures for deep reinforcement learning. In ICML, 2016. Cited on pages 3, 5, and 7.
+
+Qizhe Xie, Zihang Dai, Eduard Hovy, Minh-Thang Luong, and Quoc V Le. Unsupervised data augmentation for consistency training. arXiv preprint arXiv:1904.12848, 2019. Cited on page 2.
+
+Denis Yarats, Ilya Kostrikov, and Rob Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $=$ GY6-6sTvGaf. Cited on pages 5, 6, and 7.
+
+# A ATARI DETAILS
+
+We provide a full set of hyperparameters used in both the augmentation and no-augmentation cases in Table 3, including new hyperparameters for SPR.
+
+Table 3: Hyperparameters for SPR on Atari, with and without augmentation.   
+
+<table><tr><td>Parameter</td><td>Setting (for both variations)</td></tr><tr><td>Gray-scaling</td><td>True</td></tr><tr><td>Observation down-sampling</td><td>84x84</td></tr><tr><td>Frames stacked</td><td></td></tr><tr><td>Action repetitions</td><td></td></tr><tr><td>Reward clipping</td><td>[-1, 1]</td></tr><tr><td>Terminal on loss of life</td><td>True</td></tr><tr><td>Max frames per episode</td><td>108K</td></tr><tr><td>Update</td><td>Distributional Q</td></tr><tr><td>Dueling</td><td>True 51</td></tr><tr><td>Support of Q-distribution</td><td></td></tr><tr><td>Discount factor</td><td>0.99</td></tr><tr><td>Minibatch size</td><td></td></tr><tr><td>Optimizer</td><td>Adam</td></tr><tr><td>Optimizer: learning rate</td><td>0.0001</td></tr><tr><td>Optimizer: β1</td><td>0.9</td></tr><tr><td>Optimizer: β2</td><td>0.999</td></tr><tr><td>Optimizer: e</td><td>0.00015</td></tr><tr><td>Max gradient norm</td><td></td></tr><tr><td>Priority exponent</td><td>0.5</td></tr><tr><td>Priority correction</td><td>0.4→1</td></tr><tr><td>Exploration</td><td>Noisy nets</td></tr><tr><td>Noisy nets parameter</td><td>0.5</td></tr><tr><td>Training steps</td><td>100K</td></tr><tr><td>Evaluation trajectories</td><td>100</td></tr><tr><td>Min replay size for sampling</td><td>2000</td></tr><tr><td>Replay period every</td><td>1 step</td></tr><tr><td>Updates per step</td><td></td></tr><tr><td>Multi-step return length</td><td></td></tr><tr><td>Q network:channels</td><td>32,64,64</td></tr><tr><td>Q network: flter size</td><td>8×8,4×4,3×3 4,2,1</td></tr><tr><td>Q network: stride</td><td>256</td></tr><tr><td>Q network: hidden units</td><td>ReLU</td></tr><tr><td>Non-linearity</td><td></td></tr><tr><td>Target network: update period</td><td></td></tr><tr><td>入(SPR loss coefficient</td><td></td></tr><tr><td>K (Prediction Depth)</td><td></td></tr><tr><td>Parameter</td><td>With Augmentation Without Augmentation</td></tr><tr><td>Data Augmentation</td><td>Random shifts (±4 pixels)&amp; Intensity(scale=0.05)</td><td>None</td></tr><tr><td>Dropout</td><td>0</td><td>0.5</td></tr><tr><td>T (EMA coefficient)</td><td>0</td><td>0.99</td></tr></table>
+
+# A.1 FULL RESULTS
+
+We provide full results across all 26 games for the methods considered, including SPR with and without augmentation, in Table 4. Methods are ordered in rough order of their date of release or publication.
+
+Table 4: Mean episodic returns on the 26 Atari games considered by Kaiser et al. (2019) after $1 0 0 \mathrm { k }$ environment steps. The results are recorded at the end of training and averaged over 10 random seeds. SPR outperforms prior methods on all aggregate metrics, and exceeds expert human performance on 7 out of 26 games while using a similar amount of experience.   
+
+<table><tr><td>Game</td><td>Random</td><td>Human</td><td>SimPLe</td><td>DER</td><td>OTRainbow</td><td>CURL</td><td>DrQ</td><td>SPR (no Aug)</td><td>SPR</td></tr><tr><td>Alien</td><td>227.8</td><td>7127.7</td><td>616.9</td><td>739.9</td><td>824.7</td><td>558.2</td><td>771.2</td><td>847.2</td><td>801.5</td></tr><tr><td>Amidar</td><td>5.8</td><td>1719.5</td><td>88.0</td><td>188.6</td><td>82.8</td><td>142.1</td><td>102.8</td><td>142.7</td><td>176.3</td></tr><tr><td>Assault</td><td>222.4</td><td>742.0</td><td>527.2</td><td>431.2</td><td>351.9</td><td>600.6</td><td>452.4</td><td>665.0</td><td>571.0</td></tr><tr><td>Asterix</td><td>210.0</td><td>8503.3</td><td>1128.3</td><td>470.8</td><td>628.5</td><td>734.5</td><td>603.5</td><td>820.2</td><td>977.8</td></tr><tr><td>Bank Heist</td><td>14.2</td><td>753.1</td><td>34.2</td><td>51.0</td><td>182.1</td><td>131.6</td><td>168.9</td><td>425.6</td><td>380.9</td></tr><tr><td>BattleZone</td><td>2360.0</td><td>37187.5</td><td>5184.4</td><td>10124.6</td><td>4060.6</td><td>14870.0</td><td>12954.0</td><td>10738.0</td><td>16651.0</td></tr><tr><td>Boxing</td><td>0.1</td><td>12.1</td><td>9.1</td><td>0.2</td><td>2.5</td><td>1.2</td><td>6.0</td><td>12.7</td><td>35.8</td></tr><tr><td>Breakout</td><td>1.7</td><td>30.5</td><td>16.4</td><td>1.9</td><td>9.8</td><td>4.9</td><td>16.1</td><td>12.9</td><td>17.1</td></tr><tr><td>ChopperCommand</td><td>811.0</td><td>7387.8</td><td>1246.9</td><td>861.8</td><td>1033.3</td><td>1058.5</td><td>780.3</td><td>667.3</td><td>974.8</td></tr><tr><td>Crazy Climber</td><td>10780.5</td><td>35829.4</td><td>62583.6</td><td>16185.3</td><td>21327.8</td><td>12146.5</td><td>20516.5</td><td>43391.0</td><td>42923.6</td></tr><tr><td>Demon Attack</td><td>152.1</td><td>1971.0</td><td>208.1</td><td>508.0</td><td>711.8</td><td>817.6</td><td>1113.4</td><td>370.1</td><td>545.2</td></tr><tr><td>Freeway</td><td>0.0</td><td>29.6</td><td>20.3</td><td>27.9</td><td>25.0</td><td>26.7</td><td>9.8</td><td>16.1</td><td>24.4</td></tr><tr><td>Frostbite</td><td>65.2</td><td>4334.7</td><td>254.7</td><td>866.8</td><td>231.6</td><td>1181.3</td><td>331.1</td><td>1657.4</td><td>1821.5</td></tr><tr><td>Gopher</td><td>257.6</td><td>2412.5</td><td>771.0</td><td>349.5</td><td>778.0</td><td>669.3</td><td>636.3</td><td>774.5</td><td>715.2</td></tr><tr><td>Hero</td><td>1027.0</td><td>30826.4</td><td>2656.6</td><td>6857.0</td><td>6458.8</td><td>6279.3</td><td>3736.3</td><td>5707.4</td><td>7019.2</td></tr><tr><td>Jamesbond</td><td>29.0</td><td>302.8</td><td>125.3</td><td>301.6</td><td>112.3</td><td>471.0</td><td>236.0</td><td>367.2</td><td>365.4</td></tr><tr><td>Kangaroo</td><td>52.0</td><td>3035.0</td><td>323.1</td><td>779.3</td><td>605.4</td><td>872.5</td><td>940.6</td><td>1359.5</td><td>3276.4</td></tr><tr><td>Krull</td><td>1598.0</td><td>2665.5</td><td>4539.9</td><td>2851.5</td><td>3277.9</td><td>4229.6</td><td>4018.1</td><td>3123.1</td><td>3688.9</td></tr><tr><td>Kung Fu Master</td><td>258.5</td><td>22736.3</td><td>17257.2</td><td>14346.1</td><td>5722.2</td><td>14307.8</td><td>9111.0</td><td>15469.7</td><td>13192.7</td></tr><tr><td>Ms Pacman</td><td>307.3</td><td>6951.6</td><td>1480.0</td><td>1204.1</td><td>941.9</td><td>1465.5</td><td>960.5</td><td>1247.7</td><td>1313.2</td></tr><tr><td>Pong</td><td>-20.7</td><td>14.6</td><td>12.8</td><td>-19.3</td><td>1.3</td><td>-16.5</td><td>-8.5</td><td>-16.0</td><td>-5.9</td></tr><tr><td>Private Eye</td><td>24.9</td><td>69571.3</td><td>58.3</td><td>97.8</td><td>100.0</td><td>218.4</td><td>-13.6</td><td>52.6</td><td>124.0</td></tr><tr><td>Qbert</td><td>163.9</td><td>13455.0</td><td>1288.8</td><td>1152.9</td><td>509.3</td><td>1042.4</td><td>854.4</td><td>606.6</td><td>669.1</td></tr><tr><td>Road Runner</td><td>11.5</td><td>7845.0</td><td>5640.6</td><td>9600.0</td><td>2696.7</td><td>5661.0</td><td>8895.1</td><td>10511.0</td><td>14220.5</td></tr><tr><td>Seaquest</td><td>68.4</td><td>42054.7</td><td>683.3</td><td>354.1</td><td>286.9</td><td>384.5</td><td>301.2</td><td>580.8</td><td>583.1</td></tr><tr><td>Up N Down</td><td>533.4</td><td>11693.2</td><td>3350.3</td><td>2877.4</td><td>2847.6</td><td>2955.2</td><td>3180.8</td><td>6604.6</td><td>28138.5</td></tr><tr><td>Mean Human-Norm&#x27;d</td><td>0.000</td><td>1.000</td><td>0.443</td><td>0.285</td><td>0.264</td><td>0.381</td><td>0.357</td><td>0.463</td><td>0.704</td></tr><tr><td>Median Human-Norm&#x27;d</td><td>0.000</td><td>1.000</td><td>0.144</td><td>0.161</td><td>0.204</td><td>0.175</td><td>0.268</td><td>0.307</td><td>0.415</td></tr><tr><td>Mean DQN@50M-Norm&#x27;d Median DQN@50M-Norm&#x27;d</td><td>0.000</td><td>23.382</td><td>0.232</td><td>0.239</td><td>0.197</td><td>0.325</td><td>0.171</td><td>0.336</td><td>0.510</td></tr><tr><td># Superhuman</td><td>0.000 0</td><td>0.994 N/A</td><td>0.118 2</td><td>0.142 2</td><td>0.103 1</td><td>0.142 2</td><td>0.131 2</td><td>0.225 5</td><td>0.361</td></tr></table>
+
+Table 5: Scores on the 26 Atari games under consideration for our controlled Rainbow implementation with and without augmentation, compared to previous methods. The high mean DQN-normalized score of our DQN without augmentation is due to an atypically high score on Private Eye, a hard exploration game on which the original DQN achieves a low score.   
+
+<table><tr><td>Variant</td><td colspan="2">Human-Normalized Score</td><td colspan="2">DQN@ 50M-Normalized Score</td></tr><tr><td></td><td>mean</td><td>median</td><td>mean</td><td>median</td></tr><tr><td>Rainbow (controlled, no aug)</td><td>0.240</td><td>0.204</td><td>0.374</td><td>0.149</td></tr><tr><td>OTRainbow</td><td>0.264</td><td>0.204</td><td>0.197</td><td>0.103</td></tr><tr><td>DER</td><td>0.285</td><td>0.161</td><td>0.239</td><td>0.142</td></tr><tr><td>Rainbow (controlled, w/ aug)</td><td>0.480</td><td>0.346</td><td>0.284</td><td>0.278</td></tr><tr><td>DrQ</td><td>0.357</td><td>0.268</td><td>0.171</td><td>0.131</td></tr></table>
+
+# A.2 CONTROLLED BASELINES
+
+To ensure that the minor hyper-parameter changes we make to the DER baseline are not solely responsible for our improved performance, we perform controlled experiments using the same hyperparameters and same random seeds for baselines. We find that our controlled Rainbow implementation without augmentation is slightly stronger than Data-Efficient Rainbow but comparable to Overtrained Rainbow (Kielak, 2020), while with augmentation enabled our results are somewhat stronger than $\mathrm { D r } \mathrm { Q } . ^ { 2 }$ None of these methods, however, are close to the performance of SPR.
+
+Table 6: Scores on the 26 Atari games under consideration for various contrastive alternatives to SPR implemented in our codebase. All variants listed here use data augmentation.   
+
+<table><tr><td>Variant</td><td colspan="2">Human-Normalized Score</td><td colspan="2">DQN@ 50M-Normalized Score</td></tr><tr><td></td><td>mean</td><td>median</td><td>mean</td><td>median</td></tr><tr><td>SPR</td><td>0.704</td><td>0.415</td><td>0.510</td><td>0.361</td></tr><tr><td>Rainbow (controlled)</td><td>0.480</td><td>0.346</td><td>0.284</td><td>0.278</td></tr><tr><td>Non-temporal contrastive</td><td>0.379</td><td>0.200</td><td>0.268</td><td>0.179</td></tr><tr><td>1-step contrastive</td><td>0.473</td><td>0.231</td><td>0.280</td><td>0.213</td></tr><tr><td>5-step contrastive</td><td>0.506</td><td>0.172</td><td>0.239</td><td>0.142</td></tr><tr><td>Uniformity loss</td><td>0.422</td><td>0.176</td><td>0.271</td><td>0.144</td></tr></table>
+
+# B COMPARISON WITH A CONTRASTIVE LOSS
+
+To compare SPR with alternative methods drawn from contrastive learning, we examine several variants of a contrastive losses based on InfoNCE (Oord et al., 2018):
+
+• A contrastive loss based solely on different views of the same state, similar to CURL (Srinivas et al., 2020).   
+• A temporal contrastive loss with both augmentation and where targets are drawn one step in the future, equivalent to single-step CPC (Oord et al., 2018).   
+• A temporal contrastive loss with an explicit dynamics model, similar to CPC|Action (Guo et al., 2018). Predictions are made up to five steps in the future, and encodings of every state except $s _ { t + k }$ are used as negative samples for $s _ { t + k }$ .   
+• A soft contrastive approach inspired by Wang & Isola (2020), who propose to decouple the repulsive and attractive effects of contrastive learning into two separate losses, one of which is similar to the SPR objective and encourages representations to be invariant to augmentation or noise, and one of which encourages representations to be uniformly distributed on the unit hypersphere. We optimize this uniformity objective jointly with the SPR loss, which takes the role of the “invariance” objective proposed by (Wang & Isola, 2020). We use $t = 2$ in the uniformity loss, and give it a weight equal to that given to the SPR loss, based on hyperparameters used by Wang & Isola (2020).
+
+To create as fair a comparison as possible, we use the same augmentation (random shifts and intensity) and the same Rainbow hyperparameters as in SPR with augmentation. As in SPR, we calculate contrastive losses using the output of the first layer of the Q-head MLP, with a bilinear classifier (as in Oord et al., 2018). Following Chen et al. (2020a), we use annealed cosine similarities with a temperature of 0.1 in the contrastive loss. We present results in Table 6.
+
+Although all of these variants outperform the previous contrastive result on this task, CURL, none of them substantially improve performance over the controlled Rainbow they use as a baseline. We consider these results broadly consistent with those of CURL, which observes a relatively small performance boost over their baseline, Data-Efficient Rainbow (van Hasselt et al., 2019).
+
+# C THE ROLE OF THE TARGET ENCODER IN SPR
+
+We consider several variants of SPR with the target network modified, and present aggregate metrics for these experiments in Table 7. We first evaluate a a variant of SPR in which target representations are drawn from the online encoder and gradients allowed to propagate into the online encoder through them, effectively allowing the encoder to learn to make its representations more predictable. We find that this leads to drastic reductions in performance both with and without augmentation, which we attribute to representational collapse.
+
+Table 7: Scores on the 26 Atari games under consideration for variants of SPR with different target encoder schemes, without augmentation.   
+
+<table><tr><td rowspan="2">Variant Without Augmentation</td><td colspan="2">Human-Normalized Score</td><td colspan="2">DQN@ 50M-Normalized Score</td></tr><tr><td>mean</td><td>median</td><td>mean</td><td>median</td></tr><tr><td>SPR</td><td>0.463</td><td>0.307</td><td>0.336</td><td>0.225</td></tr><tr><td>No Stopgradient</td><td>0.375</td><td>0.208</td><td>0.301</td><td>0.233</td></tr><tr><td colspan="5">With Augmentation</td></tr><tr><td>SPR</td><td>0.704</td><td>0.415</td><td>0.510</td><td>0.361</td></tr><tr><td>No Stopgradient</td><td>0.515</td><td>0.278</td><td>0.344</td><td>0.231</td></tr></table>
+
+![](images/91b2bb2bd4be215cd7ea341f5cafcaa33b10e074f9bc7faf3f4a37a6952c3717.jpg)  
+Figure 5: Performance on a subset of 10 Atari games for different values of the EMA parameter $\tau$ with augmentation (left) and without (right). Scores are averaged across 10 seeds per game for each value of $\tau$ . Self-normalized score is calculated separately for the augmentation and no-augmentation cases.
+
+To illustrate the influence of the EMA constant $\tau$ , we evaluate $\tau$ at 9 values logarithmically interpolated3 between 0.999 and 0 on a subset of 10 Atari games.4 We use 10 seeds per game, and evaluate SPR both with and without augmentation; parameters other than $\tau$ are identical to those listed in Table 3. To equalize the importance of games in this analysis, we normalize by the average score across all tested values of $\tau$ for each game to calculate a self-normalized score, as score $\mathrm { s n s }$ , average score−random score agent score−random score
+
+We test $S P R$ both with and without augmentation, and calculate the self-normalized score separately between these cases. Results are shown in Figure 5. With augmentation, we observe a clear peak in performance at $\tau = 0$ , equivalent to a target encoder with no EMA-based smoothing. Without augmentation, however, the story is less clear, and the method appears less sensitive to $\tau$ (note y-axis scales). We use $\tau = 0 . 9 9$ in this case, based on its reasonable performance and consistency with prior work (e.g., Grill et al., 2020). Overall, however, we note that SPR does not appear overly sensitive to $\tau$ , unlike purely unsupervised methods such as BYOL; in no case does SPR fail to train.
+
+We hypothesize that the difference between the augmentation and no-augmentation cases is partially due to augmentation rendering the stabilizing effect of using an EMA target network (e.g., as observed by Grill et al., 2020; Tarvainen & Valpola, 2017) redundant. Prior work has already noted that using an EMA target network can slow down learning early in training (Tarvainen & Valpola, 2017); in our context, where a limited number of environment samples are taken in parallel with optimization, this may “waste” environment samples by collecting them with an inferior policy. To resolve this, Tarvainen & Valpola (2017) proposed to increase $\tau$ over the course of training, slowing down changes to the target network later in training. It is possible that doing so here could allow SPR to achieve the best of both worlds, but it would require tuning an additional hyperparameter, the schedule by which $\tau$ is increased, and we thus leave this topic for future work.
+
+# D WALL CLOCK TIMES
+
+We report wall-clock runtimes for a selection of methods in Table 8. SPR with augmentation for a 100K steps on Atari takes around 4 and a half to finish a complete training and evaluation run on a single game. We find that using data augmentation adds an overhead, and SPR without augmentation can run in just 3 hours.
+
+SPR’s wall-clock run-time compares very favorably to previous works such as SimPLe (Kaiser et al., 2019), which requires roughly three weeks to train on a GPU comparable to those used for SPR.
+
+Table 8: Wall-clock runtimes for various algorithms for a complete training and evaluation run on a single Atari game using a P100 GPU. Rainbow (controlled) is roughly comparable to $_ \mathrm { D r Q }$ , although its runtime will differ due different DQN hyperparameters. Runtime for SimPLe is taken from its v3 version on Arxiv, although the latest version doesn’t mention runtime. All runtimes are approximate, as exact running times vary from game to game.   
+
+<table><tr><td>Model</td><td>Runtime in hours (100k env steps)</td></tr><tr><td>SPR</td><td>4.6</td></tr><tr><td>Rainbow (controlled)</td><td>2.1</td></tr><tr><td>SPR (No aug)</td><td>3.0</td></tr><tr><td>Rainbow (controlled, no aug)</td><td>1.4</td></tr><tr><td>SimPLe</td><td>500</td></tr></table>