Add files using upload-large-folder tool

parse/train/H1Xw62kRZ/H1Xw62kRZ.md

@@ -0,0 +1,386 @@
+# LEVERAGING GRAMMAR AND REINFORCEMENT LEARNING FOR NEURAL PROGRAM SYNTHESIS
+
+Rudy Bunel∗ University of Oxford rudy@robots.ox.ac.uk
+
+Matthew Hausknecht   
+Microsoft Research   
+matthew.hausknecht@microsoft.com   
+Jacob Devlin∗   
+Google   
+jacobdevlin@google.com
+
+Rishabh Singh Microsoft Research risin@microsoft.com
+
+Pushmeet Kohli∗   
+Deepmind   
+pushmeet@google.com
+
+# ABSTRACT
+
+Program synthesis is the task of automatically generating a program consistent with a specification. Recent years have seen proposal of a number of neural approaches for program synthesis, many of which adopt a sequence generation paradigm similar to neural machine translation, in which sequence-to-sequence models are trained to maximize the likelihood of known reference programs. While achieving impressive results, this strategy has two key limitations. First, it ignores Program Aliasing: the fact that many different programs may satisfy a given specification (especially with incomplete specifications such as a few input-output examples). By maximizing the likelihood of only a single reference program, it penalizes many semantically correct programs, which can adversely affect the synthesizer performance. Second, this strategy overlooks the fact that programs have a strict syntax that can be efficiently checked. To address the first limitation, we perform reinforcement learning on top of a supervised model with an objective that explicitly maximizes the likelihood of generating semantically correct programs. For addressing the second limitation, we introduce a training procedure that directly maximizes the probability of generating syntactically correct programs that fulfill the specification. We show that our contributions lead to improved accuracy of the models, especially in cases where the training data is limited.
+
+# 1 INTRODUCTION
+
+The task of program synthesis is to automatically generate a program that is consistent with a specification such as a set of input-output examples, and has been studied since the early days of Artificial Intelligence (Waldinger and Lee, 1969). There has been a lot of recent progress made on neural program induction, where novel neural architectures inspired from computation modules such as RAM, stack, CPU, turing machines, and GPU (Graves et al., 2014; Joulin and Mikolov, 2015; Kurach et al., 2016; Graves et al., 2016; Reed and de Freitas, 2016; Kaiser and Sutskever, 2016) have been proposed to train these architectures in an end-to-end fashion to mimic the behavior of the desired program. While these approaches have achieved impressive results, they do not return explicit interpretable programs, tend not to generalize well on inputs of arbitrary length, and require a lot of examples and computation for learning each program. To mitigate some of these limitations, neural program synthesis approaches (Johnson et al., 2017; Parisotto et al., 2017; Devlin et al., 2017b) have been recently proposed that learn explicit programs in a Domain-specific language (DSL) from as few as five input-output examples. These approaches, instead of using a large number of input-output examples to learn a single program, learn a large number of different programs, each from just a few input-output examples. During training, the correct program is provided as reference, but at test time, the learnt model generates the program from only the input-output examples.
+
+While neural program synthesis techniques improve over program induction techniques in certain domains, they suffer from two key limitations. First, these approaches use supervised learning with reference programs and suffer from the problem of Program Aliasing: For a small number of input-output examples, there can be many programs that correctly transform inputs to outputs. The problem is the discrepancy between the single supervised reference program and the multitude of correct programs. Figure 1 shows an example of this: if maximizing the probability of ground truth program, predicting Program B would be assigned a high loss even though the two programs are semantically equivalent for the input-output example. Maximum likelihood training forces the model to learn to predict ground truth programs, which is different from the true objective of program synthesis: predicting any consistent program. To address this problem, we alter the optimization objective: instead of maximum likelihood, we use policy gradient reinforcement learning to directly encourage generation of any program that is consistent with the given examples.
+
+![](images/da75918d710670223bada7e9820b7a9a2b98c2401abdf44c0cfab4f8b4c145dc.jpg)  
+Figure 1: Program Aliasing is one difficulty of program synthesis: For the input-output specification given in (1a), both programs are semantically correct. However, supervised training would penalize the prediction of Program B, if A is the ground truth.
+
+The second limitation of neural program synthesis techniques based on sequence generation paradigm (Devlin et al., 2017b) is that they often overlook the fact that programs have a strict syntax, which can be checked efficiently. Similarly to the work of Parisotto et al. (2017), we explore a method for leveraging the syntax of the programming language in order to aggressively prune the exponentially large search space of possible programs. In particular, not all sequences of tokens are valid programs and syntactically incorrect programs can be efficiently ignored both during training and at test time. A syntax checker is an additional form of supervision that may not always be present. To address this limitation, we introduce a neural architecture that retains the benefits of aggressive syntax pruning, even without assuming access to the definition of the grammar made in previous work (Parisotto et al., 2017). This model is jointly conditioned on syntactic and program correctness, and can implicitly learn the syntax of the language while training.
+
+We demonstrate the efficacy of our approach by developing a neural program synthesis system for the Karel programming language (Pattis, 1981), an educational programming language, consiting of control flow constructs such as loops and conditionals, making it more complex than the domains tackled by previous neural program synthesis works.
+
+This paper makes the following key contributions:
+
+• We show that Reinforcement Learning can directly optimize for generating any consistent program and improves performance compared to pure supervised learning. • We introduce a method for pruning the space of possible programs using a syntax checker and show that explicit syntax checking helps generate better programs. In the absence of a syntax checker, we introduce a model that jointly learns syntax and the production of correct programs. We demonstrate this model improves performance in instances with limited training data.
+
+# 2 RELATED WORK
+
+Program synthesis is one of the fundamental problems in Artificial Intelligence. To the best of our knowledge, it can be traced back to the work of Waldinger and Lee (1969) where a theorem prover was used to construct LISP programs based on a formal specification of the input-output relation. As formal specification is often as complex as writing the original program, many techniques were developed to achieve the same goal with simpler partial specifications in the form of input-output (IO) examples (Amarel, 1970; Summers, 1977). Rule-based synthesis approaches have recently been successful in delivering on the promise of Programming By Example (Lieberman, 2001), the most widely known example being the FlashFill system (Gulwani et al., 2012) in Excel. However, such systems are extremely complicated to extend and need significant development time from domain experts to provide the pruning rules for efficient search.
+
+As a result, the use of Machine Learning methods have been proposed, based on Bayesian probabilistic models (Liang et al., 2010) or Inductive Logic programming (Muggleton, 1991; Muggleton et al., 2014) to automatically generate programs based on examples. Recently, inspired by the success of Neural Networks in other applications such as vision (Krizhevsky et al., 2012) or speech recognition (Graves et al., 2013) differentiable controllers were made to learn the behaviour of programs by using gradient descent over differentiable version of traditional programming concepts such as memory addressing (Graves et al., 2014), manipulating stacks (Joulin and Mikolov, 2015; Grefenstette et al., 2015), register machines (Kurach et al., 2016), and data manipulation (Neelakantan et al., 2016). These approaches to program induction however tend to struggle with generalization, especially when presented with inputs of a different dimension than the one they were trained with and require a very large amount of training data. Some exceptions to this include Neural Programmer Interpreters (Reed and de Freitas, 2016) and its extensions (Li et al., 2017; Cai et al., 2017) that learn from program traces rather than only examples. However, they still learn a different model for each program and are computationally expensive, unlike our system that uses a single model for learning a large number of programs.
+
+A series of recent works aim to infer explicit program source code with the assumption that code structure provides an inductive bias for better generalization. In particular, explicitly modeling control flow statements such as conditionals and loops can often lead to programs capable of generalizing, regardless of input size (Gaunt et al., 2016; Bunel et al., 2016; Riedel et al., 2017). One remaining drawback of these approaches is the need to restart learning from scratch for each new program. Thus they are largely unsuited for the situation of synthesizing a new program on-the-fly from very few examples. The latest developments use large datasets of artificially generated programs and learn to map embeddings of IO examples to information about the programs to generate. Balog et al. (2017) produce scores over attributes, to be used as heuristics to speed up search-based techniques. Parisotto et al. (2017) use their dataset to learn probability over the expansion rules of a predefined grammar, while (Devlin et al., 2017b) directly predict the source code of the programs. These last two methods use supervised training to maximize the likelihood of a single reference program, while we directly optimize for the generation of any consistent program.
+
+Our approach to optimize program correctness is similar in spirit to advances in Neural Machine Translation (Wu et al., 2016; Ranzato et al., 2016) that leverage reinforcement learning to optimize directly for evaluation metrics. Taking advantage of the fact that programs can be syntactically checked and unit tested against the specification examples, we show how to improve on those REINFORCE (Williams, 1992) based methods. Recently, Guu et al. (2017) proposed a method similar to ours based on Maximum Marginal Likelihood to generate programs based on a description in natural language. From an application point of view, our target domain is more complex as our DSL includes control flow operations such as conditionals and loops. Moreover, natural language utterances fully describe the steps that the program needs to take, while learning from IO examples requires planning over potentially long executions. Their approach is more akin to inferring a formal specification based on a natural language description, as opposed to our generation of imperative programs.
+
+Incorporating knowledge of the grammar of the target domain to enforce syntactical correctness has already proven useful to model arithmetic expressions, molecules (Kusner et al., 2017), and programs (Parisotto et al., 2017; Yin and Neubig, 2017). These approaches define the model over the production rules of the grammar; we instead operate directly over the terminals of the grammar. This allows us to learn the grammar jointly with the model in the case where no formal grammar specification is available. Our approach is extremely general and can be applied to the very recently proposed methods for inferring and executing programs for visual reasoning (Johnson et al., 2017) that to the best of our knowledge does not directly explictly encourage grammar consistency of the resulting program.
+
+# 3 PROBLEM OVERVIEW
+
+Before describing our proposed methods, we establish the necessary notation, present the problem setting and describe the general paradigm of our approach.
+
+# 3.1 PROGRAM SYNTHESIS FORMULATION
+
+To avoid confusion with probabilities, we will use the letter $\lambda$ to denote programs. $I$ and $O$ will be used to denote respectively input states and output states and we will use the shortcut $I O$ to denote a pair of corresponding input/output examples. A state constitutes what the programs are going to be operating on, depending on the application domain. In FlashFill-type applications (Parisotto et al., 2017; Devlin et al., 2017b), Input and Output states would be strings of characters, while in our Karel environment, states are grids describing the presence of objects. If we were to apply our method to actual programming languages, states would represent the content of the machine’s registers and the memory.
+
+At training time, we assume to have access to $N$ training samples, each training sample consisting of a set of $K$ Input/Output states and a program implementing the mapping correctly:
+
+$$
+{ \mathcal { D } } = \left\{ { \left( \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } , \ \lambda _ { i } \right) } \right\} \qquad { \mathrm { s u c h ~ t h a t : } } \quad \lambda _ { i } ( I _ { i } ^ { k } ) = O _ { i } ^ { k } \quad \forall i \in 1 . . N , \quad \forall k \in 1 . . K
+$$
+
+where $\lambda _ { i } ( I _ { i } ^ { k } )$ denotes the resulting state of applying the program $\lambda _ { i }$ to the input state $I _ { i } ^ { k }$ . Our goal is to learn a synthesizer $\sigma$ that, given a set of input/output examples produces a program:
+
+$$
+\sigma : ~ \left\{ { I O } ^ { k } \right\} _ { k = 1 \dots K } ~ \longrightarrow ~ { \hat { \lambda } }
+$$
+
+We evaluate the programs on a set of test cases for which we have both specification examples and held-out examples:
+
+$$
+{ \mathcal D } _ { \mathrm { t e s t } } = \left\{ \left( \left\{ I O _ { j } ^ { k _ { \mathrm { s p e c } } } \right\} _ { k _ { \mathrm { s p e c } } = 1 \dots K } , \quad \left\{ I O _ { j } ^ { k _ { \mathrm { t e s t } } } \right\} _ { k _ { \mathrm { t e s t } } = K + 1 \dots K ^ { \prime } } \right) \right\} _ { j = 1 \dots N _ { \mathrm { t e s t } } } ,
+$$
+
+At test time, we evaluate the performance of our learned synthesizer by generating, for each sample in the test set, a program $\hat { \lambda _ { j } }$ . The metric we care about is Generalization:
+
+$$
+\{ \begin{array} { l l } { j \in \{ 1 . . N _ { \mathrm { t e x } } \} \ \mathrm { s u c h } \mathrm { t h a t } \ \hat { \lambda _ { j } } ( I _ { j } ^ { k } ) = O _ { j } ^ { k } } & { \forall k \in \{ 1 . . K ^ { \prime } \} \ \} \mathrm { w h e r e } \ \ \hat { \lambda _ { j } } = \sigma ( \{ I O _ { j } ^ { k _ { \mathrm { s p e c } } } \} _ { k _ { \mathrm { s p e c } } = 1 . . K } ) . } \end{array} 
+$$
+
+# 3.2 NEURAL PROGRAM SYNTHESIS ARCHITECTURE
+
+Similar to Devlin et al. (2017b) we use a sequential LSTM-based (Hochreiter and Schmidhuber, 1997) language model, conditioned on an embedding of the input-output pairs. Each pair is encoded independently by a convolutional neural network (CNN) to generate a joint embedding. A succinct description of the architecture can be found in section 6.1 and the exact dimensions are available in the supplementary materials.
+
+Each program is represented by a sequence of tokens $\lambda = [ s _ { 1 } , s _ { 2 } , . . . , s _ { L } ]$ where each token comes from an alphabet $\Sigma$ . We model the program one token at a time using an LSTM. At each timestep, the input consists of the concatenation of the embedding of the IO pair and of the last predicted token. One such decoder LSTM is run for each of the IO pairs, all using the same weights. The probability of the next token is defined as the Softmax of a linear layer over the max-pooled hidden state of all the decoder LSTMs. A schema representing this architecture can be seen in Figure 2.
+
+The form of the model that we are learning is:
+
+$$
+p _ { \theta } ( \lambda _ { i } \mid \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } ) = \prod _ { t = 1 } ^ { L _ { i } } p _ { \theta } ( s _ { t } \mid s _ { 1 } , . . . , s _ { t - 1 } , \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . . K } )
+$$
+
+At test time, the most likely programs are obtained by running a beam search. One of the advantages of program synthesis is the ability to execute hypothesized programs. Through execution, we remove syntactically incorrect programs and programs that are not consistent with the observed examples. Among the remaining programs, we return the most likely according to the model.
+
+![](images/2a0a88c147a38409c6453040414a01e83b66bff4e8779b4a6684ec70c945ff06.jpg)  
+Figure 2: Architecture of our model. Each pair of Input-Output is embedded jointly by a CNN. One decoder LSTM is run for each example, getting fed in a concatenation of the previous token and the IO pair embedding (constant across timestep). Results of all the decoders are maxpooled and the prediction is modulated by the mask generated by the syntax model. The probability over the next token is then obtained by a Softmax transformation.
+
+# 4 OBJECTIVE FUNCTIONS
+
+# 4.1 MAXIMUM LIKELIHOOD OPTIMIZATION
+
+To estimate the parameters $\theta$ of our model, the default solution is to perform supervised training, framing the problem as Maximum Likelihood estimation. Devlin et al. (2017b) follow this approach and use stochastic gradient descent to solve:
+
+$$
+\theta ^ { \star } = \operatorname * { a r g m a x } _ { \theta } \prod _ { i = 1 . . N } p _ { \theta } ( \lambda _ { i } \mid \{ I O _ { i } ^ { i } \} _ { i = 1 . . K } ) = \operatorname * { a r g m a x } _ { \theta } \sum _ { i = 1 . . N } \log \left( p _ { \theta } ( \lambda _ { i } \mid \{ I O _ { i } ^ { k } \} _ { k = 1 . . K } ) \right)
+$$
+
+However, this training objective exhibits several drawbacks. First, at training time, the model is only exposed to the training data distribution, while at test time, it is fed back the token from its own previous predictions. This discrepancy in distribution of the inputs is well known in Natural Language Processing under the name of exposure bias (Ranzato et al., 2016).
+
+Moreover, this loss does not represent the true objective of program synthesis. In practice, any equivalent program should be as valid a prediction as the reference one. This property, that we call program aliasing, is not taken into account by the MLE training. Ideally, we would like the model to learn to reason about the necessary steps needed to map the input to the output. As a result, the loss shouldn’t penalize correct programs, even if they do not correspond to the ground truth.
+
+# 4.2 OPTIMIZING EXPECTED CORRECTNESS
+
+The first modification that we propose is to change the target objective to bring it more in line with the goal of program synthesis. We replace the optimization problem of (6) by
+
+$$
+\theta ^ { \star } = { \underset { \theta } { \operatorname { a r g m a x } } } \ \mathcal { L } _ { R } ( \theta ) , \qquad { \mathrm { w h e r e ~ } } \mathcal { L } _ { R } ( \theta ) = \sum _ { i . . N } \left( \sum _ { \lambda } p \theta ( \lambda \mid \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } ) \ R _ { i } ( \lambda ) \right) ,
+$$
+
+where $R _ { i } ( \lambda )$ is a reward function designed to encode the quality of the sampled programs. Note that this formulation is extremely generic and would allow to represent a wide range of different objective functions. If we assume that we have access to a simulator to run our programs, we can design $R _ { i }$ so as to optimize for generalization on held-out examples, preventing the model to overfit on its inputs. Additional property such as program conciseness, or runtime efficiency could also be encoded into the reward.
+
+![](images/6162ab9de360efe363cf765e8ca2dcf1b6d329f7160feb3a3ba2ed750da8c054.jpg)  
+Figure 3: Approximation using a beamsearch. All possibles next tokens are tried for each candidates, the $S$ (here 3) most likely according to $p _ { \theta }$ are kept. When an End-Of-Sequence token (green) is reached, the candidate is held out. At the end, the most likely complete sequences are used to construct an approximate distribution, through rescaling.
+
+However, this expressiveness comes at a cost: the inner sum in (7) is over all possible programs and therefore is not tractable to compute. The standard method consists of approximating the objective by defining a Monte Carlo estimate of the expected reward, using $S$ samples from the model. To perform optimization, an estimator of the gradient of the expected reward is built based on the REINFORCE trick (Williams, 1992).
+
+$$
+\begin{array} { r l r } {  { \mathcal { L } _ { R } ( \theta ) \approx \sum _ { i = 1 . . N } \sum _ { r = 1 } ^ { S } \frac { 1 } { S } R _ { i } ( \lambda _ { r } ) , } } & { \mathrm { ~ w h e r e ~ } \lambda _ { r } \sim p _ { \theta } ( \cdot \vert \{ I O _ { i } ^ { k } \} _ { k = 1 . . K } ) }  \\ & { } & { \nabla _ { \theta } \mathcal { L } _ { R } ( \theta ) \approx \sum _ { i = 1 . . N } \sum _ { r = 1 } ^ { S } \frac { 1 } { S } R _ { i } ( \lambda _ { r } ) \log \big ( p _ { \theta } ( \lambda _ { r } \vert \{ I O _ { i } ^ { k } \} _ { k = 1 . . K } ) \big ) } \end{array}
+$$
+
+However, given that we sample from a unique model, there is a high chance that we will sample the same programs repeatedly when estimating the gradient. This is especially true when the model has been pre-trained in a supervised manner. A different approach is to approximate the distribution of the learned distribution by another one with a smaller support.
+
+To obtain this smaller distribution, one possible solution is to employ the $S$ most likely samples as returned by a Beam Search. We generate the embedding of the IO grids and perform decoding, keeping at each step the $S$ most likely candidates prefixes based on the probability $p _ { \theta }$ given by the model. At step $t$ , we evaluate $p _ { \theta } ( s _ { 1 } \cdot \cdot . s _ { t } , \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 \dots K } ^ { \cdot } )$ for all the possible next token $s _ { t }$ and all the candidates $\left( s _ { 1 } \ldots s _ { t - 1 } \right)$ previously obtained. The $S$ most likely sequences will be the candidates at the $( t + 1 )$ step. Figure 3 represents this process.
+
+Based on the final samples obtained, we define a probability distribution to use as an approximation of $p _ { \theta }$ in (7). As opposed to (8), this approximation introduces a bias. It however has the advantage of aligning the training procedure more closely with the testing procedure where only likely samples are going to be decoded. Formally, this corresponds to performing the following approximation of the objective function, $( \mathrm { B S } ( p _ { \theta } , S )$ being the $S$ samples returned by a beam search with beam size $S$ ):
+
+$$
+\begin{array} { r l } & { { \mathcal { L } } _ { R } ( \theta ) \approx \displaystyle \sum _ { i = . . . N } \left( \sum _ { \lambda } q \theta \big ( \lambda \big | \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } \big ) R _ { i } ( \lambda ) \right) } \\ & { \mathrm { ~ w h e r e ~ } \qquad q \theta \big ( \lambda _ { r } \big | \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } \big ) = \left\{ \begin{array} { l l } { \displaystyle \frac { p _ { \theta } \big ( \lambda _ { r } \big | \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } \big ) } { \sum _ { \lambda _ { r } \in \mathsf { B S } ( r _ { \theta } , s ) } p _ { \theta } \big ( \lambda _ { r } \big | \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } \big ) } \qquad } & { \mathrm { i f ~ } \lambda _ { r } \in \mathsf { B S } ( p _ { \theta } , S ) } \\ { 0 \qquad } & { \mathrm { o t h e r w i s e . } } \end{array} \right. } \end{array}
+$$
+
+With this approximation, the support of the distribution $q _ { \theta }$ is much smaller as it contains only the $S$ elements returned by the beam search. As a result, the sum become tractable and no estimator are needed. We can simply differentiate this new objective function to obtain the gradients of the loss with regards to $p _ { \theta }$ and use the chain-rule to subsequently obtain gradient with regards to $\theta$ necessary for the optimization. Note that if $S$ is large enough to cover all possible programs, we recover the objective of (7).
+
+Based on this more tractable distribution, we can define more complex objective functions. In program synthesis, we have the possibility to prune out several predictions by using the specification. Therefore, we can choose to go beyond optimizing the expected reward when sampling a single program and optimize the expected reward when sampling a bag of $C$ programs and keeping the best one. This results in a new objective function:
+
+$$
+\boldsymbol \theta ^ { \star } = \underset { \boldsymbol \theta } { \operatorname { a r g m a x } } \sum _ { i = 1 . . N } \left( \sum _ { \{ \lambda _ { 1 } , \dots , \lambda _ { C } \} \in \mathbf { B } \setminus ( p _ { \theta , s } ) ^ { C } } \left[ \underset { j \in 1 . . C } { \operatorname* { m a x } } R _ { i } ( \lambda _ { j } ) \right] \left( \prod _ { r \in 1 . . C } q _ { \theta } \left( \lambda _ { r } \mid \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . R } \right) \right) \right) ,
+$$
+
+where $q _ { \theta }$ is defined as previously. We argue that by optimizing this objective function, the model gets the capability of “hedging its bets” and assigning probability mass to several candidates programs, resulting in a higher diversity of outputs.
+
+In the special case where the reward function only takes values in $\{ 0 , 1 \}$ , as it is when we are using correctness as a reward, this can be more easily computed as:
+
+$$
+\theta ^ { \star } = \operatorname * { a r g m a x } _ { \theta } \sum _ { i = 1 \dots N } \left( 1 - \left( \sum _ { \lambda _ { r } \in \mathrm { B S } ( p _ { \theta } , S ) } \left[ R _ { i } ( \lambda _ { r } ) = = 0 \right] q _ { \theta } ( \lambda _ { r } \mid \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 \dots K } ) \right) ^ { C } \right) 
+$$
+
+The derivation leading to this formulation as well as a description on how to efficiently compute the more general loss(10) can be found in appendix A. Note that although this formulation brings the training objective function closer to the testing procedure, it is still not ideal. It indeed makes the assumption that if we have a correct program in our bag of samples, we can identify it, ignoring the fact that it is possible to have some incorrect program consistent with the IO pairs partial specification (and therefore not prunable). In addition, this represents a probability where the $C$ programs are sampled independently, which in practice we wouldn’t do.
+
+# 5 MODEL
+
+# 5.1 CONDITIONING ON THE SYNTAX
+
+One aspect of the program synthesis task is that syntactically incorrect programs can be trivially identified and pruned before making a prediction. As a result, if we use stx to denote the event that the sampled program is syntactically correct, what we care about modeling correctly is $p ( \lambda | \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 \ldots K } , \dot { \mathbf { s t x } } )$ k=1..K , stx). Using Bayes rule, we can rewrite this:
+
+$$
+\begin{array} { r l } & { p \left( \boldsymbol { \lambda } \mid \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } , \mathbf { s t x } \right) \propto p \left( \mathbf { s t x } \mid \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } , \boldsymbol { \lambda } \right) \times p \left( \boldsymbol { \lambda } \mid \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } \right) } \\ & { \qquad \propto p \left( \mathbf { s t x } \mid \boldsymbol { \lambda } \right) \times p \left( \boldsymbol { \lambda } \mid \left\{ I O _ { i } ^ { k } \right\} _ { k = 1 . . K } \right) } \end{array}
+$$
+
+We drop the conditional dependency on the IO pairs in the second line of (12) as the syntactical correctness of the program is independent from the specification when conditioned on the program. We can do the same operation at the token level, denoting by $\mathtt { s t x } _ { 1 \dots t }$ the event that the sequence of the first $t$ tokens $s _ { 1 } \cdot \cdot \cdot s _ { t }$ doesn’t contain any syntax error and may therefore be a prefix to a valid program.
+
+$$
+\begin{array} { r l } { p ( \textit { s } _ { t } | \textit { s } _ { 1 } \cdot \cdot \cdot \mathscr { s } _ { t - 1 } , \{ I O _ { i } ^ { k } \} _ { k = 1 . . . K } , \mathfrak { s t x } _ { 1 . . . t } ) \propto } & { p ( \mathfrak { s t x } _ { 1 . . . t } | \mathscr { s } _ { 1 } \cdot \cdot \cdot \mathscr { s } _ { t }  ) \times } \\ & { \quad p ( \textit { s } _ { t } | \mathscr { s } _ { 1 } \cdot \cdot \cdot \mathscr { s } _ { t - 1 } , \{ I O _ { i } ^ { k } \} _ { k = 1 . . . K } ) } \end{array}
+$$
+
+Given a grammar, it is possible to construct a checker to determine valid prefixes of programs. Example applications include compilers to signal syntax errors to the user and autocomplete features of Integrated Development Environments (IDEs) to restrict the list of suggested completions.
+
+The quantity $p \left( \left. \mathbf { s t x } _ { 1 \ldots t } \right| s _ { 1 } \cdot \cdot \cdot s _ { t } \right)$ is therefore not a probability but can be implemented as a deterministic process for a given target programming language. In practice, this is implemented by getting at each timestep a mask $M = \{ - \operatorname { i n f } , 0 \} ^ { | \Sigma | }$ where $M _ { j } = - \operatorname { i n f }$ if the $j$ -th token in the alphabet is not a valid token in the current context, and 0 otherwise. This mask is added to the output of the network, just before the Softmax operation that normalizes the output to a probability over the tokens.
+
+Conditioning on the syntactical correctness of the programs provides several advantages: First, sampled programs become syntactically correct by construction. At test time, it allows the beam search to only explore useful candidates. It also ensures that when we are optimizing for correctness, the samples used to approximate the distribution are all going to be valid candidates. Restricting the dimension of the space on which our model is defined also makes the problem simpler to learn.
+
+It may not always be feasible to assume access to a syntax checker. In general, we wish to retain the syntax checker’s ability to aggressively prune the search in program space without requiring access to the syntax itself. To this end, we propose to represent the syntax checker as a neural network module and learn it jointly. Similar to the base model, we implement learned syntax checking using an LSTM $g _ { \phi }$ . Comparing to the decoder LSTM, there are two major differences:
+
+• The syntaxLSTM is conditioned only on the program tokens, not on the IO pairs. This ensures that the learned checker models only the syntax of the language. • The output of the syntaxLSTM is passed through an elementwise $x \mapsto - \exp ( x )$ activation function and added to the decoder LSTM’s output. Similar to the mask in Section 5.1, the exponential activation function allows the syntaxLSTM to output high penalties to any tokens deemed syntactically incorrect.
+
+The addition of the syntaxLSTM doesn’t necessitate any change to the training procedure as it is simply equivalent to a change of architecture. However, in the supervised setting, when we have access to syntactically correct programs, we have the possibility of adding an additional term to the loss (6) to prevent the model from masking valid programs:
+
+$$
+\mathcal { L } _ { \mathrm { s y n t a x } } = - \sum _ { i = 1 } \cdots N \sum _ { t = 1 } \cdots L _ { \varnothing } \left( \boldsymbol s _ { t } ^ { i } | \boldsymbol s _ { 1 } ^ { i } \cdots \boldsymbol s _ { t - 1 } ^ { i } \right) , \qquad \mathrm { w h e r e } \lambda _ { i } = [ \boldsymbol s _ { 1 } ^ { i } , \boldsymbol s _ { 2 } ^ { i } \cdots \boldsymbol s _ { L } ^ { i } ]
+$$
+
+This loss penalizes the syntaxLSTM for giving negative scores to each token belonging to a known valid program. We use the reference programs as example of valid programs when we perform supervised training.
+
+# 6 EXPERIMENTS
+
+# 6.1 THE DOMAIN: KAREL
+
+The Karel programming language is an educational programming language (Pattis, 1981), used for example in Stanford CS introductory classes (cs1) or in the Hour of Code initiative (hoc). It features an agent inside a gridworld (See Figure 1), capable of moving (move, turn{Left,Right}), modifying world state ({pick,put}Marker), and querying the state of the nearby environment for its own markers (markerPresent, noMarkerPresent) or for natural obstacles (frontIsClear, leftIsClear, rightIsClear). Our goal is to learn to generate a program in the Karel DSL given a small set of input and output grids. The language supports for loops, while loops, and conditionals, but no variable assignment. Compared to the original Karel language, we only removed the possibility of defining subroutines. The specification for the DSL can be found in appendix B.
+
+To evaluate our method, we follow the standard practice (Devlin et al., 2017b; Parisotto et al., 2017; Neelakantan et al., 2016; Balog et al., 2017) and use a synthetic dataset generated by randomly sampling programs from the DSL. We perform a few simple heuristic checks to ensure generated programs have observable effect on the world and prune out programs performing spurious actions (e.g. executing a turnLeft just after a turnRight for example). For each program, we a set of IO pairs are generated by sampling random input grids and executing the program on them to obtain the corresponding output grids. A large number of them are sampled and 6 are kept for each program, ensuring that all conditionals in a program are hit by at least one of the examples. The first 5 samples serve as the specification, and the sixth one is kept as held-out test pair. 5000 programs are not used for training, and get split out between a validation set and a test set.
+
+We represent the input and output elements as grids where each cell in the grid is a vector with 16 channels, indicating the presence of elements (AgentFacingNorth, AgentFacingSouth, · · · , Obstacle, OneMarkerPresent, TwoMarkersPresent, · · · ). The input and output grids are initially passed through independent convolution layers, before being concatenated and passed through two convolutional residual blocks and a fully connected layer, mapping them to a final 512-dimensional representation. We run one decoder per IO pair and perform a maxpooling operation over the output of all the decoders, out of which we perform the prediction of the next token. Our models are implemented using the Pytorch framework (pyt). Code and data will be made available.
+
+<table><tr><td></td><td colspan="2">Full Dataset</td><td colspan="2">Small Dataset</td></tr><tr><td>Top-1</td><td>Generalization</td><td>Exact Match</td><td>Generalization</td><td>Exact Match</td></tr><tr><td>MLE</td><td>71.91</td><td>39.94</td><td>12.58</td><td>8.93</td></tr><tr><td>RL</td><td>68.39</td><td>34.74</td><td>0</td><td>0</td></tr><tr><td>RL_beam</td><td>75.72</td><td>8.21</td><td>25.28</td><td>17.63</td></tr><tr><td>RL_beam_div</td><td>76.20</td><td>31.25</td><td>23.72</td><td>16.31</td></tr><tr><td>RL_beam_div_opt</td><td>77.12</td><td>32.17</td><td>24.24</td><td>16.63</td></tr></table>
+
+Table 1: RL_beam optimization of program correctness results in consistent improvements in top-1 generalization accuracy over supervised learning MLE, even though the exact match of recovering the reference program drops. The improved objective function results in further improvements.
+
+# 6.2 RESULTS
+
+We trained a variety of models on the full Karel dataset containing 1-million examples as well as a reduced dataset containing only $1 0 , 0 0 0$ examples. In general, the small dataset serves to help understand the data efficiency of the program synthesis methods and is motivated by the expected difficulty of obtaining many labeled examples in real-world program synthesis domains.
+
+The Karel DSL was previously used by Devlin et al. (2017a) to study the relative perfomances of a range of methods depending on the available amount of data. The task considered was however different as they attempted to perform program induction as opposed to program synthesis. Rather than predicting a program implementing the desired transformation, they simply output a specification of the changes that would result from applying the program so a direct number comparison wouldn’t be meaningful.
+
+Models are grouped according to training objectives. As a baseline, we use MLE, which corresponds to the maximum likelihood objective (Eq.6), similar to the method proposed by Devlin et al. (2017b). Unless otherwise specified, the reward considered for our other methods is generalization: $+ 1$ if the program matches all samples, including the held out one and 0 otherwise. RL uses the expected reward objective (Eq.7), using REINFORCE to obtain a gradient estimate (Eq.8). RL_beam attempts to solve the proxy problem described by Equation (9) and RL_beam_div the richer loss function of Equation (10). RL_beam_div_opt also optimizes the loss of equation (10) but the reward additionally includes a term inversly proportional to the number of timesteps it takes for the program to finish executing. All RL models are initialized from pretrained supervised models.
+
+Optimizing for correctness (RL): Results in Table 1 show that optimizing for the expected program correctness consistently provides improvements in top-1 generalization accuracy. Top-1 Generalization Accuracy (Eq. 4) denotes the accuracy of the most likely program synthesized by beam search decoding having the correct behaviour across all input-output examples. We didn’t perform any pruning of programs that were incorrect on the 5 specification examples. The improved performance of RL methods confirms our hypothesis that better loss functions can effectively combat the program aliasing problem.
+
+On the full dataset, when optimizing for correctness, Exact Match Accuracy decreases, indicating that the RL models no longer prioritize generating programs that exactly match the references. On the small dataset, RL_beam methods improves both exact match accuracy and generalization.
+
+Comparing RL_beam to standard RL, we note improvements across all levels of generalization. By better aligning the RL objective with the sampling that happens during beam search decoding, consistent improvements can be made in accuracy. Further improvements are made by encouraging diversity in the beam of solutions (RL_beam_div) and penalizing long running programs (RL_beam_div_opt).
+
+In the settings where little training data is available, RL methods show more dramatic improvements over MLE, indicating that data efficiency of program synthesis methods can be greatly improved by using a small number of samples first for supervised training and again for Reinforcement Learning.
+
+As a side note, we were unable to achieve high performance when training the RL methods from scratch. The necessity of extensive supervised pretraining to get benefits from Reinforcement
+
+<table><tr><td>Top-1 Generalization</td><td>Full Dataset</td><td>Small Dataset</td></tr><tr><td>MLE</td><td>71.91</td><td>12.58</td></tr><tr><td>MLE_learned</td><td>69.37</td><td>17.02</td></tr><tr><td>MLE _handwritten</td><td>72.07</td><td>9.81</td></tr><tr><td>MLE _large</td><td>73.67</td><td>13.14</td></tr></table>
+
+Table 2: Top-k accuracies: MLE shows greater relative accuracy increases as k increases than RL. Methods employing beam search and diversity objectives reduce this accuracy gap by encouraging diversity in the beam of partial programs.   
+
+<table><tr><td>Generalization</td><td>Top-1 Top-5 Top-50</td></tr><tr><td>MLE</td><td>71.91 79.56 86.37</td></tr><tr><td>RL_beam</td><td>75.72 79.29 83.49</td></tr><tr><td>RL_beam_div</td><td>76.20 82.09 85.86</td></tr><tr><td>RL_beam_div_opt</td><td>77.12 82.17 85.38</td></tr></table>
+
+Table 3: Grammar prunes the space of possible programs: On the full dataset, handwritten syntax checking MLE_handwritten improves accuracy over no grammar MLE, although MLE_large shows that simply adding more parameters results in even greater gains. On the small dataset, learning the syntax MLE_learned outperforms handwritten grammar and larger models.
+
+Learning fine-tuning is well-known in the Neural Machine Translation literature (Ranzato et al., 2016;   
+Wu et al., 2016; Wiseman and Rush, 2016; Bahdanau et al., 2017).
+
+Table 2 examines the top-1, top-5, and top-50 generalization accuracy of supervised and RL models. RL_beam methods performs best for top-1 but their advantage drops for higher-rank accuracy. Inspection of generated programs shows that the top predictions all become diverse variations of the same program, up to addition/removal of no-operations (turnLeft followed by turnRight, full circle obtained by a series of four turnLeft). The RL_beam_div objective helps alleviate this effect as does RL_beam_div_opt, which penalizes redundant programs. This is important as in the task of Program Synthesis, we may not necessarily need to return the most likely output if it can be pruned by our specification.
+
+Impact of syntax: We also compare models according to the use of syntax: MLE_handwritten denotes the use of a handwritten syntax checker (Sec 5.1), MLE_learned denotes a learned syntax (Sec 5.2), while no suffix denotes no syntax usage. Table 3 compares syntax models.
+
+On the full dataset, leveraging the handwritten syntax leads to marginally better accuracies than learning the syntax or using no syntax. Given access to enough data, the network seems to be capable of learning to model the syntax using the sheer volume of training examples.
+
+On the other hand, when the amount of training data is limited, learning the syntax produces significantly better performance. By incorporating syntactic structure in the model architecture and objective, more leverage is gained from small training data. Interestingly, the learned syntax model even outperforms the handwritten syntax model. We posit the syntaxLSTM is free to learn a richer syntax. For example, the syntaxLSTM could learn to model the distribution of programs and discourage the prediction of not only syntactically incorrect programs, but also the unlikely ones.
+
+To control for the extra parameters introduced by the syntaxLSTM, we compare against MLE_large, which uses no syntax but features a larger decoder LSTM, resulting in the same number of parameters as MLE_learned. Results show that the larger number of parameters is not enough to explain the difference in performance, which again indicates the utility of jointly learning syntax.
+
+Analysis of learned syntax: Section 5.2 claimed that by decomposing our models into two separate decoders, we could decompose the learning so that one decoder would specialize in picking the likely tokens given the IO pairs, while the other would enforce the grammar of the language. We now provide experimental evidence that this decomposition happens in practice.
+
+Table 4 shows the percentage of syntactically correct programs among the most likely predictions of the ${ \bf M L E + }$ learned model trained on the full dataset. Both columns correspond to the same set of parameters but the second column doesn’t apply the syntaxLSTM’s mask to constrain the decoding process. The precipitous drop in syntax accuracy indicates the extent to which the program decoder has learned to rely on the syntaxLSTM to produce syntactically correct programs.
+
+Figure 3 compares the syntax masks generated by the learned and handwritten syntax models while decoding Program A in Figure 1. (3a) shows output of the handwritten syntax checker; (3b) shows syntaxLSTM output. White cells indicates tokens that are labeled syntactically correct at each decoding step.
+
+Figure 3c analyzes the difference between the handwritten and learned syntax masks. White indicates similar output, which occupies the majority of the visualization. Blue cells correspond to instances where the syntaxLSTM labeled a token correct when it actually was syntactically incorrect. This type of error can be recovered if the program decoder predicts those tokens as unlikely.
+
+<table><tr><td>% Synctactically Correct</td><td>Joint Model</td><td>Without Learned Syntax</td></tr><tr><td>Amongst Top1</td><td>100%</td><td>0%</td></tr><tr><td>Amongst Top5</td><td>100 %</td><td>0%</td></tr><tr><td>Amongst Top50</td><td>100 %</td><td>0%</td></tr><tr><td>Amongst Top100</td><td>99.79 %</td><td>.04%</td></tr></table>
+
+On the other hand, red cells indicate the syntaxLSTM predicted a valid token is syntactically incorrect. This type of error is more dangerous because the program decoder cannot recover the valid token once it is declared incorrect. The majority of red errors correspond to tokens which are rarely observed in the training dataset, indicating that the syntaxLSTM learns to model more than just syntax - it also captures the distribution over programs. Given a large enough dataset of real programs, the syntaxLSTM learns to consider non-sensical and unlikely programs as syntactically incorrect, ensuring that generated programs are both syntactically correct and likely.
+
+![](images/e35294641612e826d101b53ba678d4ef72143e4a9050fd2d1f76a85e7228fa3e.jpg)  
+Table 4: Importance of Syntax   
+Figure 3: Syntax Comparison
+
+# 7 CONCLUSION
+
+We presented two novel contributions to improve stateof-the-art neural program synthesis techniques. Our first contribution uses Reinforcement Learning to optimize for generating any consistent program, which we show helps in improving generalization accuracy of the learned programs for large training datasets. Our second contribution incorporates syntax checking as an additional conditioning mechanism for pruning the space of programs during decoding. We show that incorporating syntax leads to significant improvements with limited training datasets.
+
+# REFERENCES
+
+Stanford CS106A course page. https://see.stanford.edu/Course/CS106A. Accessed: 2017-05- 16.
+
+Hour of Code. http://hourofcode.codehs.com/. Accessed: 2017-05-16.
+
+Pytorch. http://pytorch.org/.
+
+Saul Amarel. Representations and modeling in problems of program formation. Rutgers University. Livingstone College. Department of Computer Science, 1970.
+
+Dzmitry Bahdanau, Philemon Brakel, Kelvin Xu, Anirudh Goyal, Ryan Lowe, Joelle Pineau, Aaron Courville, and Yoshua Bengio. An actor-critic algorithm for sequence prediction. ICLR, 2017.
+
+Matej Balog, Alexander L Gaunt, Marc Brockschmidt, Sebastian Nowozin, and Daniel Tarlow. Deepcoder: Learning to write programs. In ICLR, 2017.
+
+Rudy R Bunel, Alban Desmaison, Pawan K Mudigonda, Pushmeet Kohli, and Philip Torr. Adaptive neural compilation. In NIPS, 2016.
+
+Jonathon Cai, Richard Shin, and Dawn Song. Making neural programming architectures generalize via recursion. In ICLR, 2017.
+
+Jacob Devlin, Rudy R Bunel, Rishabh Singh, Matthew Hausknecht, and Pushmeet Kohli. Neural program meta-induction. 2017a.
+
+Jacob Devlin, Jonathan Uesato, Surya Bhupatiraju, Rishabh Singh, Abdel-rahman Mohamed, and Pushmeet Kohli. Robustfill: Neural program learning under noisy I/O. In ICML, 2017b.
+
+Alexander L Gaunt, Marc Brockschmidt, Rishabh Singh, Nate Kushman, Pushmeet Kohli, Jonathan Taylor, and Daniel Tarlow. Terpret: A probabilistic programming language for program induction. arXiv preprint arXiv:1608.04428, 2016.
+
+Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In ICASSP, 2013.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka Grabska-Barwinska, ´ Sergio Gómez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, et al. Hybrid computing using a neural network with dynamic external memory. Nature, 2016.
+
+Edward Grefenstette, Karl Moritz Hermann, Mustafa Suleyman, and Phil Blunsom. Learning to transduce with unbounded memory. In NIPS, 2015.
+
+Sumit Gulwani, William R Harris, and Rishabh Singh. Spreadsheet data manipulation using examples. Communications of the ACM, 2012.
+
+Kelvin Guu, Panupong Pasupat, Evan Zheran Liu, and Percy Liang. From language to programs: Bridging reinforcement learning and maximum marginal likelihood. In ACL, 2017.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 1997.
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Judy Hoffman, Fei-Fei Li, C. Lawrence Zitnick, and Ross B. Girshick. Inferring and executing programs for visual reasoning. 2017.
+
+Armand Joulin and Tomas Mikolov. Inferring algorithmic patterns with stack-augmented recurrent nets. In NIPS, 2015.
+
+Łukasz Kaiser and Ilya Sutskever. Neural gpus learn algorithms. In ICLR, 2016.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012.
+
+Karol Kurach, Marcin Andrychowicz, and Ilya Sutskever. Neural random-access machines. In ICLR, 2016.
+
+Matt J Kusner, Brooks Paige, and José Miguel Hernández-Lobato. Grammar variational autoencoder. In ICML, 2017.
+
+Chengtao Li, Daniel Tarlow, Alexander L. Gaunt, Marc Brockschmidt, and Nate Kushman. Neural program lattices. In ICLR, 2017.
+
+Percy Liang, Michael I Jordan, and Dan Klein. Learning programs: A hierarchical bayesian approach. In ICML, 2010.
+
+Henry Lieberman. Your wish is my command: Programming by example. 2001.
+
+Stephen Muggleton. Inductive logic programming. New generation computing, 1991.
+
+Stephen H Muggleton, Dianhuan Lin, Niels Pahlavi, and Alireza Tamaddoni-Nezhad. Meta-interpretive learning: application to grammatical inference. Machine learning, 2014.
+
+Arvind Neelakantan, Quoc V Le, and Ilya Sutskever. Neural programmer: Inducing latent programs with gradient descent. In ICLR, 2016.
+
+Emilio Parisotto, Abdelrahman Mohamed, Rishabh Singh, Lihong Li, Denny Zhou, and Pushmeet Kohli. Neuro-symbolic program synthesis. In ICLR, 2017.
+
+Richard E Pattis. Karel the robot: a gentle introduction to the art of programming. John Wiley & Sons, Inc., 1981.
+
+Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. In ICLR, 2016.
+
+Scott Reed and Nando de Freitas. Neural programmer-interpreters. In ICLR, 2016.
+
+Sebastian Riedel, Matko Bosnjak, and Tim Rocktäschel. Programming with a differentiable forth interpreter. In ICML, 2017.
+
+Phillip D Summers. A methodology for lisp program construction from examples. Journal of the ACM, 1977.
+
+Richard J Waldinger and Richard CT Lee. Prow: A step toward automatic program writing. In IJCAI, 1969.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 1992.
+
+Sam Wiseman and Alexander M Rush. Sequence-to-sequence learning as beam-search optimization. In EMNLP, 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.
+
+Pengcheng Yin and Graham Neubig. A syntactic neural model for general-purpose code generation. In ACL, 2017.
+
+# A COMPUTING THE RICHER LOSS FUNCTION
+
+In this section, we describe how the objective function of Equation (10) can be computed.
+
+We have a distribution $q _ { \theta }$ over $S$ programs, as obtained by performing a beam search over $p _ { \theta }$ and renormalizing. We are going to get $C$ independent samples from this distribution and obtain a reward corresponding to the best performing of all of them.
+
+In the case where the reward function $R _ { i } ( \lambda _ { r } )$ is built on a boolean property, such as for example “correctness of the generated program”, Equation (10) can be simplified. As $R _ { i } ( \lambda _ { r } )$ can only take the values 0 or 1, the term $\operatorname* { m a x } _ { j \in 1 \ldots C } R _ { i } ( \lambda _ { j } )$ is going to be equal to 0 only if all of the $C$ sampled programs give a reward of zero. For each sample, there is a probability of $\begin{array} { r } { q _ { \mathrm { i n c o r r e c t } } = \sum _ { \lambda _ { r } \in { \bf B S } ( p _ { \theta } , S ) } [ R _ { i } ( \bar { \lambda _ { r } } ) = = 0 ] q _ { \theta } ( \lambda _ { r } \mid \{ I O _ { i } ^ { k } \} _ { k = 1 \dots K } ) } \end{array}$ of samput of the g a prograsamples is ewards. From $C$ $q _ { \mathrm { i n c o r r e c t } } ^ { C }$ this, we can derive the form of Equation (11). Note that this can be computed without any additional sampling steps as we have a close form solution for this expectation.
+
+In the general case, a similar derivation can be obtained. Assume that the programs outputted by the beam search have associated rewards $R _ { 0 } , R _ { 1 } , . . . , R _ { S }$ and assume without loss of generality that $R _ { 0 } < R _ { 1 } < . . < R _ { S }$ . The probability of sampling a program with a reward smaller than $R _ { i }$ is $\begin{array} { r } { q _ { \le R _ { i } } = \sum _ { \lambda _ { r } \in \mathrm { B S } ( p _ { \theta } , S ) } [ R _ { i } ( \lambda _ { r } ) \le R _ { i } ] \stackrel { \cdot } { q _ { \theta } } ( \lambda _ { r } \mid \{ { \hat { I } } { \hat { O } } _ { i } ^ { k } \} _ { k = 1 \ldots K } ^ { - } ) } \end{array}$ so the probability of obtaining a final reward of less than $R _ { i }$ when sampling $\textrm { C }$ samples is $q _ { \leq { R _ { i } } } ^ { C }$ . As a result, the probability of obtaining a reward of exactly $R _ { i }$ is $\left( q _ { \leq R _ { i } } ^ { C } - q _ { \leq R _ { i - 1 } } ^ { C } \right)$ . Based on this, it is easy to evaluate (and differentiate) the loss function described by Equation (10).
+
+# B KAREL LANGAGE SPECIFICATION
+
+$$
+\begin{array} { r c l } { \operatorname { P r o g } p } & { : = } & { \det \operatorname { r u n } ( ) : s } \\ { \operatorname { S t m } \textstyle * } & { : = } & { \textstyle \operatorname { w h i l } \textstyle \mathrm { 1 } \cdot \boldsymbol { \mathrm { s } } \left| \operatorname { r e p e a t } ( r ) : s \right| \textstyle \mathrm { s } _ { 1 } ; \boldsymbol { s } _ { 2 } \left| \alpha \right. } \\ & { \big | } & { \big | \big | \big | \big | \big | \big | \operatorname { s } : \big | \operatorname { i f e l s e } ( b ) : \boldsymbol { s } _ { 1 } \big . \mathrm { e l s e } : \boldsymbol { s } _ { 2 } } \\ { \operatorname { C o n d } b } & { : = } & { \textstyle \operatorname { f r o n t } \operatorname { I s C l e a r } ( ) \big | \big | \operatorname { l e f t } \operatorname { I s C l e a r } ( ) \big | \big | \operatorname { r i g h t } \operatorname { I s C l e a r } ( ) } \\ & { \big | } & { \textstyle \operatorname { m a r k e r s p r e s e n t } ( ) \big | \operatorname { n o M a r k e r s P r e s e n t } ( ) \big | \operatorname { n o t } b } \\ { \operatorname { A c t i o n } \big . } & { : = } & { \operatorname { m o v e } \big ( ) \big | \operatorname { t u r n R i g h t } \big ( ) \big | \operatorname { t u r n L e f t } ( ) } \\ & { \big | } & { \big | \operatorname { p i c k M a r k e r } ( ) \big | \operatorname { p u t M a r k e r } ( ) } \\ { \operatorname { C s t e r } } & { : = } & { 0 \big | 1 \big | \operatorname { 1 } \dots | \operatorname { l 9 } } \end{array}
+$$
+
+Figure 4: The Domain-specific language for Karel programs.
+
+# C EXPERIMENTS HYPERPARAMETERS
+
+The state of the grid word are represented as a $1 6 \times 1 8 \times 1 8$ tensor. For each cell of the grid, the 16-dimensional vector corresponds to the feature indicated in Table 5
+
+The decoders are two-layer LSTM with a hidden size of 256. Tokens of the DSL are embedded to a 256 dimensional vector. The input of the LSTM is therefore of dimension 768 (256 dimensional of the token $+ 5 1 2$ dimensional of the IO pair embedding). The LSTM used to model the syntax is similarly sized but doesn’t take the embedding of the IO pairs as input so its input size is only 256.
+
+One decoder LSTM is run on the embedding of each IO pair. The topmost activation are passed through a MaxPooling operation to obtain a 256 dimensional vector representing all pairs. This is passed through a linear layer to obtain a score for each of the 52 possible tokens. We add the output of the model and of the eventual syntax model, whether learned or handwritten and pass it through a SoftMax layer to obtain a probability distribution over the next token.
+
+All training is performed using the Adam optimizer, with a learning rate of $1 0 ^ { - } 4$ . Supervised training used a batch size of 128 and RL methods used a batch size of 16. We used 100 rollouts per samples for the Reinforce method and a beam size of 64 for methods based on the beam search. The value of C used for the methods computing a loss on bags of programs was 5.
+
+Table 5: Representation of the grid   
+
+<table><tr><td rowspan=1 colspan=1>Hero facingNorth</td></tr><tr><td rowspan=1 colspan=1>Hero facingSouth</td></tr><tr><td rowspan=1 colspan=1>Hero facing West</td></tr><tr><td rowspan=1 colspan=1>Hero facing East</td></tr><tr><td rowspan=1 colspan=1>Obstacle</td></tr><tr><td rowspan=1 colspan=1>Grid boundary</td></tr><tr><td rowspan=1 colspan=1>1 marker</td></tr><tr><td rowspan=1 colspan=1>2 marker</td></tr><tr><td rowspan=1 colspan=1>3 marker</td></tr><tr><td rowspan=1 colspan=1>4 marker</td></tr><tr><td rowspan=1 colspan=1>5marker</td></tr><tr><td rowspan=1 colspan=1>6 marker</td></tr><tr><td rowspan=1 colspan=1>7 marker</td></tr><tr><td rowspan=1 colspan=1>8 marker</td></tr><tr><td rowspan=1 colspan=1>9 marker</td></tr><tr><td rowspan=1 colspan=1>10 marker</td></tr></table>
+
+Table 6: Encoding of the Input/Output Pairs   
+
+<table><tr><td rowspan="2">Grid Embedding</td><td>Input Grid Conv2D,kernel size= 3, padding=1,16 →32</td><td>Output Grid Conv2D,kernel size=3,padding=1,16-&gt;32</td></tr><tr><td>ReLU</td><td>ReLU Conv2D,kernel size=3,padding1,64 → 64</td></tr><tr><td>Residual Block 1</td><td colspan="2">ReLU Conv2D, kernel size = 3, padding 1, 64 → 64 ReLU Conv2D,kernel size = 3,padding1,64 →→ 64 ReLU</td></tr><tr><td rowspan="2">Residual Block 1</td><td>Conv2D,kernel size =3,padding1, 64 -→ 64 Conv2D,kernel size = 3, padding 1, 64 -→ 64</td><td>ReLU</td></tr><tr><td>Conv2D,kernel size = 3, padding 1, 64 -→ 64</td><td>ReLU</td></tr><tr><td>Fully Connected</td><td colspan="2">ReLU Linear,20736→512</td></tr></table>

parse/train/H1Xw62kRZ/H1Xw62kRZ_content_list.json

@@ -0,0 +1,2027 @@
+[
+    {
+        "type": "text",
+        "text": "LEVERAGING GRAMMAR AND REINFORCEMENT LEARNING FOR NEURAL PROGRAM SYNTHESIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rudy Bunel∗ University of Oxford rudy@robots.ox.ac.uk ",
+        "bbox": [
+            184,
+            170,
+            382,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Matthew Hausknecht   \nMicrosoft Research   \nmatthew.hausknecht@microsoft.com   \nJacob Devlin∗   \nGoogle   \njacobdevlin@google.com ",
+        "bbox": [
+            498,
+            170,
+            813,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            233,
+            401,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rishabh Singh Microsoft Research risin@microsoft.com ",
+        "bbox": [
+            418,
+            233,
+            607,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pushmeet Kohli∗   \nDeepmind   \npushmeet@google.com ",
+        "bbox": [
+            624,
+            233,
+            813,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            313,
+            544,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Program synthesis is the task of automatically generating a program consistent with a specification. Recent years have seen proposal of a number of neural approaches for program synthesis, many of which adopt a sequence generation paradigm similar to neural machine translation, in which sequence-to-sequence models are trained to maximize the likelihood of known reference programs. While achieving impressive results, this strategy has two key limitations. First, it ignores Program Aliasing: the fact that many different programs may satisfy a given specification (especially with incomplete specifications such as a few input-output examples). By maximizing the likelihood of only a single reference program, it penalizes many semantically correct programs, which can adversely affect the synthesizer performance. Second, this strategy overlooks the fact that programs have a strict syntax that can be efficiently checked. To address the first limitation, we perform reinforcement learning on top of a supervised model with an objective that explicitly maximizes the likelihood of generating semantically correct programs. For addressing the second limitation, we introduce a training procedure that directly maximizes the probability of generating syntactically correct programs that fulfill the specification. We show that our contributions lead to improved accuracy of the models, especially in cases where the training data is limited. ",
+        "bbox": [
+            233,
+            343,
+            766,
+            593
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            336,
+            631
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The task of program synthesis is to automatically generate a program that is consistent with a specification such as a set of input-output examples, and has been studied since the early days of Artificial Intelligence (Waldinger and Lee, 1969). There has been a lot of recent progress made on neural program induction, where novel neural architectures inspired from computation modules such as RAM, stack, CPU, turing machines, and GPU (Graves et al., 2014; Joulin and Mikolov, 2015; Kurach et al., 2016; Graves et al., 2016; Reed and de Freitas, 2016; Kaiser and Sutskever, 2016) have been proposed to train these architectures in an end-to-end fashion to mimic the behavior of the desired program. While these approaches have achieved impressive results, they do not return explicit interpretable programs, tend not to generalize well on inputs of arbitrary length, and require a lot of examples and computation for learning each program. To mitigate some of these limitations, neural program synthesis approaches (Johnson et al., 2017; Parisotto et al., 2017; Devlin et al., 2017b) have been recently proposed that learn explicit programs in a Domain-specific language (DSL) from as few as five input-output examples. These approaches, instead of using a large number of input-output examples to learn a single program, learn a large number of different programs, each from just a few input-output examples. During training, the correct program is provided as reference, but at test time, the learnt model generates the program from only the input-output examples. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While neural program synthesis techniques improve over program induction techniques in certain domains, they suffer from two key limitations. First, these approaches use supervised learning with reference programs and suffer from the problem of Program Aliasing: For a small number of input-output examples, there can be many programs that correctly transform inputs to outputs. The problem is the discrepancy between the single supervised reference program and the multitude of correct programs. Figure 1 shows an example of this: if maximizing the probability of ground truth program, predicting Program B would be assigned a high loss even though the two programs are semantically equivalent for the input-output example. Maximum likelihood training forces the model to learn to predict ground truth programs, which is different from the true objective of program synthesis: predicting any consistent program. To address this problem, we alter the optimization objective: instead of maximum likelihood, we use policy gradient reinforcement learning to directly encourage generation of any program that is consistent with the given examples. ",
+        "bbox": [
+            176,
+            872,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/da75918d710670223bada7e9820b7a9a2b98c2401abdf44c0cfab4f8b4c145dc.jpg",
+        "image_caption": [
+            "Figure 1: Program Aliasing is one difficulty of program synthesis: For the input-output specification given in (1a), both programs are semantically correct. However, supervised training would penalize the prediction of Program B, if A is the ground truth. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            823,
+            210
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            292,
+            825,
+            433
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The second limitation of neural program synthesis techniques based on sequence generation paradigm (Devlin et al., 2017b) is that they often overlook the fact that programs have a strict syntax, which can be checked efficiently. Similarly to the work of Parisotto et al. (2017), we explore a method for leveraging the syntax of the programming language in order to aggressively prune the exponentially large search space of possible programs. In particular, not all sequences of tokens are valid programs and syntactically incorrect programs can be efficiently ignored both during training and at test time. A syntax checker is an additional form of supervision that may not always be present. To address this limitation, we introduce a neural architecture that retains the benefits of aggressive syntax pruning, even without assuming access to the definition of the grammar made in previous work (Parisotto et al., 2017). This model is jointly conditioned on syntactic and program correctness, and can implicitly learn the syntax of the language while training. ",
+        "bbox": [
+            174,
+            439,
+            825,
+            592
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the efficacy of our approach by developing a neural program synthesis system for the Karel programming language (Pattis, 1981), an educational programming language, consiting of control flow constructs such as loops and conditionals, making it more complex than the domains tackled by previous neural program synthesis works. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper makes the following key contributions: ",
+        "bbox": [
+            174,
+            661,
+            501,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We show that Reinforcement Learning can directly optimize for generating any consistent program and improves performance compared to pure supervised learning. • We introduce a method for pruning the space of possible programs using a syntax checker and show that explicit syntax checking helps generate better programs. In the absence of a syntax checker, we introduce a model that jointly learns syntax and the production of correct programs. We demonstrate this model improves performance in instances with limited training data. ",
+        "bbox": [
+            215,
+            688,
+            825,
+            797
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            811,
+            341,
+            828
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Program synthesis is one of the fundamental problems in Artificial Intelligence. To the best of our knowledge, it can be traced back to the work of Waldinger and Lee (1969) where a theorem prover was used to construct LISP programs based on a formal specification of the input-output relation. As formal specification is often as complex as writing the original program, many techniques were developed to achieve the same goal with simpler partial specifications in the form of input-output (IO) examples (Amarel, 1970; Summers, 1977). Rule-based synthesis approaches have recently been successful in delivering on the promise of Programming By Example (Lieberman, 2001), the most widely known example being the FlashFill system (Gulwani et al., 2012) in Excel. However, such systems are extremely complicated to extend and need significant development time from domain experts to provide the pruning rules for efficient search. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As a result, the use of Machine Learning methods have been proposed, based on Bayesian probabilistic models (Liang et al., 2010) or Inductive Logic programming (Muggleton, 1991; Muggleton et al., 2014) to automatically generate programs based on examples. Recently, inspired by the success of Neural Networks in other applications such as vision (Krizhevsky et al., 2012) or speech recognition (Graves et al., 2013) differentiable controllers were made to learn the behaviour of programs by using gradient descent over differentiable version of traditional programming concepts such as memory addressing (Graves et al., 2014), manipulating stacks (Joulin and Mikolov, 2015; Grefenstette et al., 2015), register machines (Kurach et al., 2016), and data manipulation (Neelakantan et al., 2016). These approaches to program induction however tend to struggle with generalization, especially when presented with inputs of a different dimension than the one they were trained with and require a very large amount of training data. Some exceptions to this include Neural Programmer Interpreters (Reed and de Freitas, 2016) and its extensions (Li et al., 2017; Cai et al., 2017) that learn from program traces rather than only examples. However, they still learn a different model for each program and are computationally expensive, unlike our system that uses a single model for learning a large number of programs. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            375
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A series of recent works aim to infer explicit program source code with the assumption that code structure provides an inductive bias for better generalization. In particular, explicitly modeling control flow statements such as conditionals and loops can often lead to programs capable of generalizing, regardless of input size (Gaunt et al., 2016; Bunel et al., 2016; Riedel et al., 2017). One remaining drawback of these approaches is the need to restart learning from scratch for each new program. Thus they are largely unsuited for the situation of synthesizing a new program on-the-fly from very few examples. The latest developments use large datasets of artificially generated programs and learn to map embeddings of IO examples to information about the programs to generate. Balog et al. (2017) produce scores over attributes, to be used as heuristics to speed up search-based techniques. Parisotto et al. (2017) use their dataset to learn probability over the expansion rules of a predefined grammar, while (Devlin et al., 2017b) directly predict the source code of the programs. These last two methods use supervised training to maximize the likelihood of a single reference program, while we directly optimize for the generation of any consistent program. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            563
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our approach to optimize program correctness is similar in spirit to advances in Neural Machine Translation (Wu et al., 2016; Ranzato et al., 2016) that leverage reinforcement learning to optimize directly for evaluation metrics. Taking advantage of the fact that programs can be syntactically checked and unit tested against the specification examples, we show how to improve on those REINFORCE (Williams, 1992) based methods. Recently, Guu et al. (2017) proposed a method similar to ours based on Maximum Marginal Likelihood to generate programs based on a description in natural language. From an application point of view, our target domain is more complex as our DSL includes control flow operations such as conditionals and loops. Moreover, natural language utterances fully describe the steps that the program needs to take, while learning from IO examples requires planning over potentially long executions. Their approach is more akin to inferring a formal specification based on a natural language description, as opposed to our generation of imperative programs. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Incorporating knowledge of the grammar of the target domain to enforce syntactical correctness has already proven useful to model arithmetic expressions, molecules (Kusner et al., 2017), and programs (Parisotto et al., 2017; Yin and Neubig, 2017). These approaches define the model over the production rules of the grammar; we instead operate directly over the terminals of the grammar. This allows us to learn the grammar jointly with the model in the case where no formal grammar specification is available. Our approach is extremely general and can be applied to the very recently proposed methods for inferring and executing programs for visual reasoning (Johnson et al., 2017) that to the best of our knowledge does not directly explictly encourage grammar consistency of the resulting program. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            867
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            382,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Before describing our proposed methods, we establish the necessary notation, present the problem setting and describe the general paradigm of our approach. ",
+        "bbox": [
+            173,
+            131,
+            823,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROGRAM SYNTHESIS FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            170,
+            475,
+            185
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To avoid confusion with probabilities, we will use the letter $\\lambda$ to denote programs. $I$ and $O$ will be used to denote respectively input states and output states and we will use the shortcut $I O$ to denote a pair of corresponding input/output examples. A state constitutes what the programs are going to be operating on, depending on the application domain. In FlashFill-type applications (Parisotto et al., 2017; Devlin et al., 2017b), Input and Output states would be strings of characters, while in our Karel environment, states are grids describing the presence of objects. If we were to apply our method to actual programming languages, states would represent the content of the machine’s registers and the memory. ",
+        "bbox": [
+            173,
+            196,
+            826,
+            309
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At training time, we assume to have access to $N$ training samples, each training sample consisting of a set of $K$ Input/Output states and a program implementing the mapping correctly: ",
+        "bbox": [
+            171,
+            315,
+            825,
+            345
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cd6dbe8dc5943ef92139ea016e3daa79daf06131f034eb971c3ce242fca2b469.jpg",
+        "text": "$$\n{ \\mathcal { D } } = \\left\\{ { \\left( \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } , \\ \\lambda _ { i } \\right) } \\right\\} \\qquad { \\mathrm { s u c h ~ t h a t : } } \\quad \\lambda _ { i } ( I _ { i } ^ { k } ) = O _ { i } ^ { k } \\quad \\forall i \\in 1 . . N , \\quad \\forall k \\in 1 . . K\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            347,
+            792,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { i } ( I _ { i } ^ { k } )$ denotes the resulting state of applying the program $\\lambda _ { i }$ to the input state $I _ { i } ^ { k }$ . Our goal is to learn a synthesizer $\\sigma$ that, given a set of input/output examples produces a program: ",
+        "bbox": [
+            174,
+            395,
+            826,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3ff478f222fd1d7d34c45916a21847cd5616e12664375c90c4db0517bc5123b1.jpg",
+        "text": "$$\n\\sigma : ~ \\left\\{ { I O } ^ { k } \\right\\} _ { k = 1 \\dots K } ~ \\longrightarrow ~ { \\hat { \\lambda } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            426,
+            607,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the programs on a set of test cases for which we have both specification examples and held-out examples: ",
+        "bbox": [
+            176,
+            449,
+            828,
+            477
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b5652d1eeb277530083648635a050facf7ce3a7177a248b05a231357bac3ab3.jpg",
+        "text": "$$\n{ \\mathcal D } _ { \\mathrm { t e s t } } = \\left\\{ \\left( \\left\\{ I O _ { j } ^ { k _ { \\mathrm { s p e c } } } \\right\\} _ { k _ { \\mathrm { s p e c } } = 1 \\dots K } , \\quad \\left\\{ I O _ { j } ^ { k _ { \\mathrm { t e s t } } } \\right\\} _ { k _ { \\mathrm { t e s t } } = K + 1 \\dots K ^ { \\prime } } \\right) \\right\\} _ { j = 1 \\dots N _ { \\mathrm { t e s t } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            479,
+            732,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At test time, we evaluate the performance of our learned synthesizer by generating, for each sample in the test set, a program $\\hat { \\lambda _ { j } }$ . The metric we care about is Generalization: ",
+        "bbox": [
+            171,
+            526,
+            825,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3da2f7a805a4fb5e58e3a035ff5861f516918ecc8ff2d026322582289706b0f4.jpg",
+        "text": "$$\n\\{ \\begin{array} { l l } { j \\in \\{ 1 . . N _ { \\mathrm { t e x } } \\} \\ \\mathrm { s u c h } \\mathrm { t h a t } \\ \\hat { \\lambda _ { j } } ( I _ { j } ^ { k } ) = O _ { j } ^ { k } } & { \\forall k \\in \\{ 1 . . K ^ { \\prime } \\} \\ \\} \\mathrm { w h e r e } \\ \\ \\hat { \\lambda _ { j } } = \\sigma ( \\{ I O _ { j } ^ { k _ { \\mathrm { s p e c } } } \\} _ { k _ { \\mathrm { s p e c } } = 1 . . K } ) . } \\end{array} \n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            560,
+            794,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 NEURAL PROGRAM SYNTHESIS ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            549,
+            630
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to Devlin et al. (2017b) we use a sequential LSTM-based (Hochreiter and Schmidhuber, 1997) language model, conditioned on an embedding of the input-output pairs. Each pair is encoded independently by a convolutional neural network (CNN) to generate a joint embedding. A succinct description of the architecture can be found in section 6.1 and the exact dimensions are available in the supplementary materials. ",
+        "bbox": [
+            173,
+            641,
+            825,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each program is represented by a sequence of tokens $\\lambda = [ s _ { 1 } , s _ { 2 } , . . . , s _ { L } ]$ where each token comes from an alphabet $\\Sigma$ . We model the program one token at a time using an LSTM. At each timestep, the input consists of the concatenation of the embedding of the IO pair and of the last predicted token. One such decoder LSTM is run for each of the IO pairs, all using the same weights. The probability of the next token is defined as the Softmax of a linear layer over the max-pooled hidden state of all the decoder LSTMs. A schema representing this architecture can be seen in Figure 2. ",
+        "bbox": [
+            173,
+            718,
+            826,
+            803
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The form of the model that we are learning is: ",
+        "bbox": [
+            173,
+            808,
+            475,
+            823
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d60e9c51e9eef30e20c0c9eb73f9e7c7df87439ae35f4cbe0aa4b7ecc1f0cb2.jpg",
+        "text": "$$\np _ { \\theta } ( \\lambda _ { i } \\mid \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } ) = \\prod _ { t = 1 } ^ { L _ { i } } p _ { \\theta } ( s _ { t } \\mid s _ { 1 } , . . . , s _ { t - 1 } , \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . . K } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            827,
+            700,
+            864
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At test time, the most likely programs are obtained by running a beam search. One of the advantages of program synthesis is the ability to execute hypothesized programs. Through execution, we remove syntactically incorrect programs and programs that are not consistent with the observed examples. Among the remaining programs, we return the most likely according to the model. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a0a88c147a38409c6453040414a01e83b66bff4e8779b4a6684ec70c945ff06.jpg",
+        "image_caption": [
+            "Figure 2: Architecture of our model. Each pair of Input-Output is embedded jointly by a CNN. One decoder LSTM is run for each example, getting fed in a concatenation of the previous token and the IO pair embedding (constant across timestep). Results of all the decoders are maxpooled and the prediction is modulated by the mask generated by the syntax model. The probability over the next token is then obtained by a Softmax transformation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            98,
+            821,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 OBJECTIVE FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            433,
+            405,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 MAXIMUM LIKELIHOOD OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            463,
+            490,
+            478
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To estimate the parameters $\\theta$ of our model, the default solution is to perform supervised training, framing the problem as Maximum Likelihood estimation. Devlin et al. (2017b) follow this approach and use stochastic gradient descent to solve: ",
+        "bbox": [
+            176,
+            489,
+            825,
+            532
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb5f8db4bfd54b81c7749e7704742c33680b2a10550cb81ba7fe098c864166ac.jpg",
+        "text": "$$\n\\theta ^ { \\star } = \\operatorname * { a r g m a x } _ { \\theta } \\prod _ { i = 1 . . N } p _ { \\theta } ( \\lambda _ { i } \\mid \\{ I O _ { i } ^ { i } \\} _ { i = 1 . . K } ) = \\operatorname * { a r g m a x } _ { \\theta } \\sum _ { i = 1 . . N } \\log \\left( p _ { \\theta } ( \\lambda _ { i } \\mid \\{ I O _ { i } ^ { k } \\} _ { k = 1 . . K } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            539,
+            785,
+            573
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, this training objective exhibits several drawbacks. First, at training time, the model is only exposed to the training data distribution, while at test time, it is fed back the token from its own previous predictions. This discrepancy in distribution of the inputs is well known in Natural Language Processing under the name of exposure bias (Ranzato et al., 2016). ",
+        "bbox": [
+            174,
+            585,
+            825,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Moreover, this loss does not represent the true objective of program synthesis. In practice, any equivalent program should be as valid a prediction as the reference one. This property, that we call program aliasing, is not taken into account by the MLE training. Ideally, we would like the model to learn to reason about the necessary steps needed to map the input to the output. As a result, the loss shouldn’t penalize correct programs, even if they do not correspond to the ground truth. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            718
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 OPTIMIZING EXPECTED CORRECTNESS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            488,
+            744
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The first modification that we propose is to change the target objective to bring it more in line with the goal of program synthesis. We replace the optimization problem of (6) by ",
+        "bbox": [
+            173,
+            757,
+            826,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3eaa9ce4c5abc218dcadf8832559ef89968664433439ae37ae9de8a3a375401.jpg",
+        "text": "$$\n\\theta ^ { \\star } = { \\underset { \\theta } { \\operatorname { a r g m a x } } } \\ \\mathcal { L } _ { R } ( \\theta ) , \\qquad { \\mathrm { w h e r e ~ } } \\mathcal { L } _ { R } ( \\theta ) = \\sum _ { i . . N } \\left( \\sum _ { \\lambda } p \\theta ( \\lambda \\mid \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } ) \\ R _ { i } ( \\lambda ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            791,
+            779,
+            834
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $R _ { i } ( \\lambda )$ is a reward function designed to encode the quality of the sampled programs. Note that this formulation is extremely generic and would allow to represent a wide range of different objective functions. If we assume that we have access to a simulator to run our programs, we can design $R _ { i }$ so as to optimize for generalization on held-out examples, preventing the model to overfit on its inputs. Additional property such as program conciseness, or runtime efficiency could also be encoded into the reward. ",
+        "bbox": [
+            173,
+            839,
+            826,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6162ab9de360efe363cf765e8ca2dcf1b6d329f7160feb3a3ba2ed750da8c054.jpg",
+        "image_caption": [
+            "Figure 3: Approximation using a beamsearch. All possibles next tokens are tried for each candidates, the $S$ (here 3) most likely according to $p _ { \\theta }$ are kept. When an End-Of-Sequence token (green) is reached, the candidate is held out. At the end, the most likely complete sequences are used to construct an approximate distribution, through rescaling. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            101,
+            815,
+            183
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, this expressiveness comes at a cost: the inner sum in (7) is over all possible programs and therefore is not tractable to compute. The standard method consists of approximating the objective by defining a Monte Carlo estimate of the expected reward, using $S$ samples from the model. To perform optimization, an estimator of the gradient of the expected reward is built based on the REINFORCE trick (Williams, 1992). ",
+        "bbox": [
+            173,
+            275,
+            826,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fba3acc0737630a8e51c5c1575c4e08b3d707b7475992b047997e739ce0eb0e8.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\mathcal { L } _ { R } ( \\theta ) \\approx \\sum _ { i = 1 . . N } \\sum _ { r = 1 } ^ { S } \\frac { 1 } { S } R _ { i } ( \\lambda _ { r } ) , } } & { \\mathrm { ~ w h e r e ~ } \\lambda _ { r } \\sim p _ { \\theta } ( \\cdot \\vert \\{ I O _ { i } ^ { k } \\} _ { k = 1 . . K } ) }  \\\\ & { } & { \\nabla _ { \\theta } \\mathcal { L } _ { R } ( \\theta ) \\approx \\sum _ { i = 1 . . N } \\sum _ { r = 1 } ^ { S } \\frac { 1 } { S } R _ { i } ( \\lambda _ { r } ) \\log \\big ( p _ { \\theta } ( \\lambda _ { r } \\vert \\{ I O _ { i } ^ { k } \\} _ { k = 1 . . K } ) \\big ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            351,
+            745,
+            441
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, given that we sample from a unique model, there is a high chance that we will sample the same programs repeatedly when estimating the gradient. This is especially true when the model has been pre-trained in a supervised manner. A different approach is to approximate the distribution of the learned distribution by another one with a smaller support. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            507
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To obtain this smaller distribution, one possible solution is to employ the $S$ most likely samples as returned by a Beam Search. We generate the embedding of the IO grids and perform decoding, keeping at each step the $S$ most likely candidates prefixes based on the probability $p _ { \\theta }$ given by the model. At step $t$ , we evaluate $p _ { \\theta } ( s _ { 1 } \\cdot \\cdot . s _ { t } , \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 \\dots K } ^ { \\cdot } )$ for all the possible next token $s _ { t }$ and all the candidates $\\left( s _ { 1 } \\ldots s _ { t - 1 } \\right)$ previously obtained. The $S$ most likely sequences will be the candidates at the $( t + 1 )$ step. Figure 3 represents this process. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            599
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Based on the final samples obtained, we define a probability distribution to use as an approximation of $p _ { \\theta }$ in (7). As opposed to (8), this approximation introduces a bias. It however has the advantage of aligning the training procedure more closely with the testing procedure where only likely samples are going to be decoded. Formally, this corresponds to performing the following approximation of the objective function, $( \\mathrm { B S } ( p _ { \\theta } , S )$ being the $S$ samples returned by a beam search with beam size $S$ ): ",
+        "bbox": [
+            173,
+            606,
+            825,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ce239a0cae9d9fef1f0a98e5bee4a55e2b173bfbe4dec75fbdcc9909ccc609be.jpg",
+        "text": "$$\n\\begin{array} { r l } & { { \\mathcal { L } } _ { R } ( \\theta ) \\approx \\displaystyle \\sum _ { i = . . . N } \\left( \\sum _ { \\lambda } q \\theta \\big ( \\lambda \\big | \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } \\big ) R _ { i } ( \\lambda ) \\right) } \\\\ & { \\mathrm { ~ w h e r e ~ } \\qquad q \\theta \\big ( \\lambda _ { r } \\big | \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } \\big ) = \\left\\{ \\begin{array} { l l } { \\displaystyle \\frac { p _ { \\theta } \\big ( \\lambda _ { r } \\big | \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } \\big ) } { \\sum _ { \\lambda _ { r } \\in \\mathsf { B S } ( r _ { \\theta } , s ) } p _ { \\theta } \\big ( \\lambda _ { r } \\big | \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } \\big ) } \\qquad } & { \\mathrm { i f ~ } \\lambda _ { r } \\in \\mathsf { B S } ( p _ { \\theta } , S ) } \\\\ { 0 \\qquad } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            681,
+            823,
+            776
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With this approximation, the support of the distribution $q _ { \\theta }$ is much smaller as it contains only the $S$ elements returned by the beam search. As a result, the sum become tractable and no estimator are needed. We can simply differentiate this new objective function to obtain the gradients of the loss with regards to $p _ { \\theta }$ and use the chain-rule to subsequently obtain gradient with regards to $\\theta$ necessary for the optimization. Note that if $S$ is large enough to cover all possible programs, we recover the objective of (7). ",
+        "bbox": [
+            173,
+            794,
+            825,
+            878
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Based on this more tractable distribution, we can define more complex objective functions. In program synthesis, we have the possibility to prune out several predictions by using the specification. Therefore, we can choose to go beyond optimizing the expected reward when sampling a single program and optimize the expected reward when sampling a bag of $C$ programs and keeping the best one. This results in a new objective function: ",
+        "bbox": [
+            176,
+            883,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            131
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1a7cb6168d28a46c7449375686270d1f1fcc2cfe564c6e650fd50316e83eb165.jpg",
+        "text": "$$\n\\boldsymbol \\theta ^ { \\star } = \\underset { \\boldsymbol \\theta } { \\operatorname { a r g m a x } } \\sum _ { i = 1 . . N } \\left( \\sum _ { \\{ \\lambda _ { 1 } , \\dots , \\lambda _ { C } \\} \\in \\mathbf { B } \\setminus ( p _ { \\theta , s } ) ^ { C } } \\left[ \\underset { j \\in 1 . . C } { \\operatorname* { m a x } } R _ { i } ( \\lambda _ { j } ) \\right] \\left( \\prod _ { r \\in 1 . . C } q _ { \\theta } \\left( \\lambda _ { r } \\mid \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . R } \\right) \\right) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            136,
+            784,
+            183
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $q _ { \\theta }$ is defined as previously. We argue that by optimizing this objective function, the model gets the capability of “hedging its bets” and assigning probability mass to several candidates programs, resulting in a higher diversity of outputs. ",
+        "bbox": [
+            176,
+            188,
+            826,
+            231
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the special case where the reward function only takes values in $\\{ 0 , 1 \\}$ , as it is when we are using correctness as a reward, this can be more easily computed as: ",
+        "bbox": [
+            173,
+            236,
+            825,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d1017ca0e81c3431a07e21187091c73dacd43a2631e297e157072ccb749822a1.jpg",
+        "text": "$$\n\\theta ^ { \\star } = \\operatorname * { a r g m a x } _ { \\theta } \\sum _ { i = 1 \\dots N } \\left( 1 - \\left( \\sum _ { \\lambda _ { r } \\in \\mathrm { B S } ( p _ { \\theta } , S ) } \\left[ R _ { i } ( \\lambda _ { r } ) = = 0 \\right] q _ { \\theta } ( \\lambda _ { r } \\mid \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 \\dots K } ) \\right) ^ { C } \\right) \n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            270,
+            759,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The derivation leading to this formulation as well as a description on how to efficiently compute the more general loss(10) can be found in appendix A. Note that although this formulation brings the training objective function closer to the testing procedure, it is still not ideal. It indeed makes the assumption that if we have a correct program in our bag of samples, we can identify it, ignoring the fact that it is possible to have some incorrect program consistent with the IO pairs partial specification (and therefore not prunable). In addition, this represents a probability where the $C$ programs are sampled independently, which in practice we wouldn’t do. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            420
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            433,
+            269,
+            449
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 CONDITIONING ON THE SYNTAX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            439,
+            479
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One aspect of the program synthesis task is that syntactically incorrect programs can be trivially identified and pruned before making a prediction. As a result, if we use stx to denote the event that the sampled program is syntactically correct, what we care about modeling correctly is $p ( \\lambda | \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 \\ldots K } , \\dot { \\mathbf { s t x } } )$ k=1..K , stx). Using Bayes rule, we can rewrite this: ",
+        "bbox": [
+            173,
+            491,
+            825,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de14d9669e6163c801d78526cab69832cafd0836d9d00c6beaa5b589ab1a6510.jpg",
+        "text": "$$\n\\begin{array} { r l } & { p \\left( \\boldsymbol { \\lambda } \\mid \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } , \\mathbf { s t x } \\right) \\propto p \\left( \\mathbf { s t x } \\mid \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } , \\boldsymbol { \\lambda } \\right) \\times p \\left( \\boldsymbol { \\lambda } \\mid \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } \\right) } \\\\ & { \\qquad \\propto p \\left( \\mathbf { s t x } \\mid \\boldsymbol { \\lambda } \\right) \\times p \\left( \\boldsymbol { \\lambda } \\mid \\left\\{ I O _ { i } ^ { k } \\right\\} _ { k = 1 . . K } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            554,
+            767,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We drop the conditional dependency on the IO pairs in the second line of (12) as the syntactical correctness of the program is independent from the specification when conditioned on the program. We can do the same operation at the token level, denoting by $\\mathtt { s t x } _ { 1 \\dots t }$ the event that the sequence of the first $t$ tokens $s _ { 1 } \\cdot \\cdot \\cdot s _ { t }$ doesn’t contain any syntax error and may therefore be a prefix to a valid program. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            674
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/27d084def02f78d9ed92316c7213ee1271c55cd7d3dd55bcf3b565c2a8eb588a.jpg",
+        "text": "$$\n\\begin{array} { r l } { p ( \\textit { s } _ { t } | \\textit { s } _ { 1 } \\cdot \\cdot \\cdot \\mathscr { s } _ { t - 1 } , \\{ I O _ { i } ^ { k } \\} _ { k = 1 . . . K } , \\mathfrak { s t x } _ { 1 . . . t } ) \\propto } & { p ( \\mathfrak { s t x } _ { 1 . . . t } | \\mathscr { s } _ { 1 } \\cdot \\cdot \\cdot \\mathscr { s } _ { t }  ) \\times } \\\\ & { \\quad p ( \\textit { s } _ { t } | \\mathscr { s } _ { 1 } \\cdot \\cdot \\cdot \\mathscr { s } _ { t - 1 } , \\{ I O _ { i } ^ { k } \\} _ { k = 1 . . . K } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            679,
+            769,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Given a grammar, it is possible to construct a checker to determine valid prefixes of programs. Example applications include compilers to signal syntax errors to the user and autocomplete features of Integrated Development Environments (IDEs) to restrict the list of suggested completions. ",
+        "bbox": [
+            176,
+            727,
+            825,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The quantity $p \\left( \\left. \\mathbf { s t x } _ { 1 \\ldots t } \\right| s _ { 1 } \\cdot \\cdot \\cdot s _ { t } \\right)$ is therefore not a probability but can be implemented as a deterministic process for a given target programming language. In practice, this is implemented by getting at each timestep a mask $M = \\{ - \\operatorname { i n f } , 0 \\} ^ { | \\Sigma | }$ where $M _ { j } = - \\operatorname { i n f }$ if the $j$ -th token in the alphabet is not a valid token in the current context, and 0 otherwise. This mask is added to the output of the network, just before the Softmax operation that normalizes the output to a probability over the tokens. ",
+        "bbox": [
+            173,
+            775,
+            826,
+            848
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Conditioning on the syntactical correctness of the programs provides several advantages: First, sampled programs become syntactically correct by construction. At test time, it allows the beam search to only explore useful candidates. It also ensures that when we are optimizing for correctness, the samples used to approximate the distribution are all going to be valid candidates. Restricting the dimension of the space on which our model is defined also makes the problem simpler to learn. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It may not always be feasible to assume access to a syntax checker. In general, we wish to retain the syntax checker’s ability to aggressively prune the search in program space without requiring access to the syntax itself. To this end, we propose to represent the syntax checker as a neural network module and learn it jointly. Similar to the base model, we implement learned syntax checking using an LSTM $g _ { \\phi }$ . Comparing to the decoder LSTM, there are two major differences: ",
+        "bbox": [
+            174,
+            130,
+            825,
+            200
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• The syntaxLSTM is conditioned only on the program tokens, not on the IO pairs. This ensures that the learned checker models only the syntax of the language. • The output of the syntaxLSTM is passed through an elementwise $x \\mapsto - \\exp ( x )$ activation function and added to the decoder LSTM’s output. Similar to the mask in Section 5.1, the exponential activation function allows the syntaxLSTM to output high penalties to any tokens deemed syntactically incorrect. ",
+        "bbox": [
+            215,
+            212,
+            825,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The addition of the syntaxLSTM doesn’t necessitate any change to the training procedure as it is simply equivalent to a change of architecture. However, in the supervised setting, when we have access to syntactically correct programs, we have the possibility of adding an additional term to the loss (6) to prevent the model from masking valid programs: ",
+        "bbox": [
+            174,
+            314,
+            825,
+            371
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ed181f612d67ff47e82ec6f2b9c272876ac88a8287e86297250e9c583084ef8a.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { s y n t a x } } = - \\sum _ { i = 1 } \\cdots N \\sum _ { t = 1 } \\cdots L _ { \\varnothing } \\left( \\boldsymbol s _ { t } ^ { i } | \\boldsymbol s _ { 1 } ^ { i } \\cdots \\boldsymbol s _ { t - 1 } ^ { i } \\right) , \\qquad \\mathrm { w h e r e } \\lambda _ { i } = [ \\boldsymbol s _ { 1 } ^ { i } , \\boldsymbol s _ { 2 } ^ { i } \\cdots \\boldsymbol s _ { L } ^ { i } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            378,
+            763,
+            412
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This loss penalizes the syntaxLSTM for giving negative scores to each token belonging to a known valid program. We use the reference programs as example of valid programs when we perform supervised training. ",
+        "bbox": [
+            174,
+            419,
+            823,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            326,
+            492
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 THE DOMAIN: KAREL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            367,
+            521
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The Karel programming language is an educational programming language (Pattis, 1981), used for example in Stanford CS introductory classes (cs1) or in the Hour of Code initiative (hoc). It features an agent inside a gridworld (See Figure 1), capable of moving (move, turn{Left,Right}), modifying world state ({pick,put}Marker), and querying the state of the nearby environment for its own markers (markerPresent, noMarkerPresent) or for natural obstacles (frontIsClear, leftIsClear, rightIsClear). Our goal is to learn to generate a program in the Karel DSL given a small set of input and output grids. The language supports for loops, while loops, and conditionals, but no variable assignment. Compared to the original Karel language, we only removed the possibility of defining subroutines. The specification for the DSL can be found in appendix B. ",
+        "bbox": [
+            174,
+            534,
+            826,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our method, we follow the standard practice (Devlin et al., 2017b; Parisotto et al., 2017; Neelakantan et al., 2016; Balog et al., 2017) and use a synthetic dataset generated by randomly sampling programs from the DSL. We perform a few simple heuristic checks to ensure generated programs have observable effect on the world and prune out programs performing spurious actions (e.g. executing a turnLeft just after a turnRight for example). For each program, we a set of IO pairs are generated by sampling random input grids and executing the program on them to obtain the corresponding output grids. A large number of them are sampled and 6 are kept for each program, ensuring that all conditionals in a program are hit by at least one of the examples. The first 5 samples serve as the specification, and the sixth one is kept as held-out test pair. 5000 programs are not used for training, and get split out between a validation set and a test set. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We represent the input and output elements as grids where each cell in the grid is a vector with 16 channels, indicating the presence of elements (AgentFacingNorth, AgentFacingSouth, · · · , Obstacle, OneMarkerPresent, TwoMarkersPresent, · · · ). The input and output grids are initially passed through independent convolution layers, before being concatenated and passed through two convolutional residual blocks and a fully connected layer, mapping them to a final 512-dimensional representation. We run one decoder per IO pair and perform a maxpooling operation over the output of all the decoders, out of which we perform the prediction of the next token. Our models are implemented using the Pytorch framework (pyt). Code and data will be made available. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/afc5e611a1fc3e7a43fdcecfa14ccc8229ccd7d8780052ddb371093f6a2c6b43.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Full Dataset</td><td colspan=\"2\">Small Dataset</td></tr><tr><td>Top-1</td><td>Generalization</td><td>Exact Match</td><td>Generalization</td><td>Exact Match</td></tr><tr><td>MLE</td><td>71.91</td><td>39.94</td><td>12.58</td><td>8.93</td></tr><tr><td>RL</td><td>68.39</td><td>34.74</td><td>0</td><td>0</td></tr><tr><td>RL_beam</td><td>75.72</td><td>8.21</td><td>25.28</td><td>17.63</td></tr><tr><td>RL_beam_div</td><td>76.20</td><td>31.25</td><td>23.72</td><td>16.31</td></tr><tr><td>RL_beam_div_opt</td><td>77.12</td><td>32.17</td><td>24.24</td><td>16.63</td></tr></table>",
+        "bbox": [
+            235,
+            101,
+            763,
+            212
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 1: RL_beam optimization of program correctness results in consistent improvements in top-1 generalization accuracy over supervised learning MLE, even though the exact match of recovering the reference program drops. The improved objective function results in further improvements. ",
+        "bbox": [
+            176,
+            222,
+            823,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            303,
+            277,
+            316
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We trained a variety of models on the full Karel dataset containing 1-million examples as well as a reduced dataset containing only $1 0 , 0 0 0$ examples. In general, the small dataset serves to help understand the data efficiency of the program synthesis methods and is motivated by the expected difficulty of obtaining many labeled examples in real-world program synthesis domains. ",
+        "bbox": [
+            174,
+            332,
+            823,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The Karel DSL was previously used by Devlin et al. (2017a) to study the relative perfomances of a range of methods depending on the available amount of data. The task considered was however different as they attempted to perform program induction as opposed to program synthesis. Rather than predicting a program implementing the desired transformation, they simply output a specification of the changes that would result from applying the program so a direct number comparison wouldn’t be meaningful. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            478
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Models are grouped according to training objectives. As a baseline, we use MLE, which corresponds to the maximum likelihood objective (Eq.6), similar to the method proposed by Devlin et al. (2017b). Unless otherwise specified, the reward considered for our other methods is generalization: $+ 1$ if the program matches all samples, including the held out one and 0 otherwise. RL uses the expected reward objective (Eq.7), using REINFORCE to obtain a gradient estimate (Eq.8). RL_beam attempts to solve the proxy problem described by Equation (9) and RL_beam_div the richer loss function of Equation (10). RL_beam_div_opt also optimizes the loss of equation (10) but the reward additionally includes a term inversly proportional to the number of timesteps it takes for the program to finish executing. All RL models are initialized from pretrained supervised models. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            611
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Optimizing for correctness (RL): Results in Table 1 show that optimizing for the expected program correctness consistently provides improvements in top-1 generalization accuracy. Top-1 Generalization Accuracy (Eq. 4) denotes the accuracy of the most likely program synthesized by beam search decoding having the correct behaviour across all input-output examples. We didn’t perform any pruning of programs that were incorrect on the 5 specification examples. The improved performance of RL methods confirms our hypothesis that better loss functions can effectively combat the program aliasing problem. ",
+        "bbox": [
+            173,
+            630,
+            825,
+            728
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On the full dataset, when optimizing for correctness, Exact Match Accuracy decreases, indicating that the RL models no longer prioritize generating programs that exactly match the references. On the small dataset, RL_beam methods improves both exact match accuracy and generalization. ",
+        "bbox": [
+            176,
+            734,
+            825,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparing RL_beam to standard RL, we note improvements across all levels of generalization. By better aligning the RL objective with the sampling that happens during beam search decoding, consistent improvements can be made in accuracy. Further improvements are made by encouraging diversity in the beam of solutions (RL_beam_div) and penalizing long running programs (RL_beam_div_opt). ",
+        "bbox": [
+            176,
+            784,
+            825,
+            839
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the settings where little training data is available, RL methods show more dramatic improvements over MLE, indicating that data efficiency of program synthesis methods can be greatly improved by using a small number of samples first for supervised training and again for Reinforcement Learning. ",
+        "bbox": [
+            176,
+            845,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As a side note, we were unable to achieve high performance when training the RL methods from scratch. The necessity of extensive supervised pretraining to get benefits from Reinforcement ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/06c0f90ae2e392841808239c2489ab612550dba80a983232a5770eac1763b1f7.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Top-1 Generalization</td><td>Full Dataset</td><td>Small Dataset</td></tr><tr><td>MLE</td><td>71.91</td><td>12.58</td></tr><tr><td>MLE_learned</td><td>69.37</td><td>17.02</td></tr><tr><td>MLE _handwritten</td><td>72.07</td><td>9.81</td></tr><tr><td>MLE _large</td><td>73.67</td><td>13.14</td></tr></table>",
+        "bbox": [
+            467,
+            101,
+            805,
+            179
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/4c4b7879740a87e2f4e1346ea3a5ee195e432b73780f2eca2e31970bd8efc9a9.jpg",
+        "table_caption": [
+            "Table 2: Top-k accuracies: MLE shows greater relative accuracy increases as k increases than RL. Methods employing beam search and diversity objectives reduce this accuracy gap by encouraging diversity in the beam of partial programs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Generalization</td><td>Top-1 Top-5 Top-50</td></tr><tr><td>MLE</td><td>71.91 79.56 86.37</td></tr><tr><td>RL_beam</td><td>75.72 79.29 83.49</td></tr><tr><td>RL_beam_div</td><td>76.20 82.09 85.86</td></tr><tr><td>RL_beam_div_opt</td><td>77.12 82.17 85.38</td></tr></table>",
+        "bbox": [
+            183,
+            101,
+            444,
+            180
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Grammar prunes the space of possible programs: On the full dataset, handwritten syntax checking MLE_handwritten improves accuracy over no grammar MLE, although MLE_large shows that simply adding more parameters results in even greater gains. On the small dataset, learning the syntax MLE_learned outperforms handwritten grammar and larger models. ",
+        "bbox": [
+            457,
+            190,
+            818,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Learning fine-tuning is well-known in the Neural Machine Translation literature (Ranzato et al., 2016;   \nWu et al., 2016; Wiseman and Rush, 2016; Bahdanau et al., 2017). ",
+        "bbox": [
+            173,
+            325,
+            823,
+            354
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 2 examines the top-1, top-5, and top-50 generalization accuracy of supervised and RL models. RL_beam methods performs best for top-1 but their advantage drops for higher-rank accuracy. Inspection of generated programs shows that the top predictions all become diverse variations of the same program, up to addition/removal of no-operations (turnLeft followed by turnRight, full circle obtained by a series of four turnLeft). The RL_beam_div objective helps alleviate this effect as does RL_beam_div_opt, which penalizes redundant programs. This is important as in the task of Program Synthesis, we may not necessarily need to return the most likely output if it can be pruned by our specification. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Impact of syntax: We also compare models according to the use of syntax: MLE_handwritten denotes the use of a handwritten syntax checker (Sec 5.1), MLE_learned denotes a learned syntax (Sec 5.2), while no suffix denotes no syntax usage. Table 3 compares syntax models. ",
+        "bbox": [
+            176,
+            492,
+            823,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "On the full dataset, leveraging the handwritten syntax leads to marginally better accuracies than learning the syntax or using no syntax. Given access to enough data, the network seems to be capable of learning to model the syntax using the sheer volume of training examples. ",
+        "bbox": [
+            176,
+            541,
+            821,
+            583
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, when the amount of training data is limited, learning the syntax produces significantly better performance. By incorporating syntactic structure in the model architecture and objective, more leverage is gained from small training data. Interestingly, the learned syntax model even outperforms the handwritten syntax model. We posit the syntaxLSTM is free to learn a richer syntax. For example, the syntaxLSTM could learn to model the distribution of programs and discourage the prediction of not only syntactically incorrect programs, but also the unlikely ones. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To control for the extra parameters introduced by the syntaxLSTM, we compare against MLE_large, which uses no syntax but features a larger decoder LSTM, resulting in the same number of parameters as MLE_learned. Results show that the larger number of parameters is not enough to explain the difference in performance, which again indicates the utility of jointly learning syntax. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Analysis of learned syntax: Section 5.2 claimed that by decomposing our models into two separate decoders, we could decompose the learning so that one decoder would specialize in picking the likely tokens given the IO pairs, while the other would enforce the grammar of the language. We now provide experimental evidence that this decomposition happens in practice. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows the percentage of syntactically correct programs among the most likely predictions of the ${ \\bf M L E + }$ learned model trained on the full dataset. Both columns correspond to the same set of parameters but the second column doesn’t apply the syntaxLSTM’s mask to constrain the decoding process. The precipitous drop in syntax accuracy indicates the extent to which the program decoder has learned to rely on the syntaxLSTM to produce syntactically correct programs. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 compares the syntax masks generated by the learned and handwritten syntax models while decoding Program A in Figure 1. (3a) shows output of the handwritten syntax checker; (3b) shows syntaxLSTM output. White cells indicates tokens that are labeled syntactically correct at each decoding step. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Figure 3c analyzes the difference between the handwritten and learned syntax masks. White indicates similar output, which occupies the majority of the visualization. Blue cells correspond to instances where the syntaxLSTM labeled a token correct when it actually was syntactically incorrect. This type of error can be recovered if the program decoder predicts those tokens as unlikely. ",
+        "bbox": [
+            174,
+            138,
+            549,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/71c290110c3bef8c7d5977cbbd33de177aab4f332e02779dcc33e8c860e76302.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>% Synctactically Correct</td><td>Joint Model</td><td>Without Learned Syntax</td></tr><tr><td>Amongst Top1</td><td>100%</td><td>0%</td></tr><tr><td>Amongst Top5</td><td>100 %</td><td>0%</td></tr><tr><td>Amongst Top50</td><td>100 %</td><td>0%</td></tr><tr><td>Amongst Top100</td><td>99.79 %</td><td>.04%</td></tr></table>",
+        "bbox": [
+            565,
+            155,
+            833,
+            233
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, red cells indicate the syntaxLSTM predicted a valid token is syntactically incorrect. This type of error is more dangerous because the program decoder cannot recover the valid token once it is declared incorrect. The majority of red errors correspond to tokens which are rarely observed in the training dataset, indicating that the syntaxLSTM learns to model more than just syntax - it also captures the distribution over programs. Given a large enough dataset of real programs, the syntaxLSTM learns to consider non-sensical and unlikely programs as syntactically incorrect, ensuring that generated programs are both syntactically correct and likely. ",
+        "bbox": [
+            174,
+            243,
+            549,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/e35294641612e826d101b53ba678d4ef72143e4a9050fd2d1f76a85e7228fa3e.jpg",
+        "image_caption": [
+            "Table 4: Importance of Syntax ",
+            "Figure 3: Syntax Comparison "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            566,
+            263,
+            820,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            424,
+            318,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We presented two novel contributions to improve stateof-the-art neural program synthesis techniques. Our first contribution uses Reinforcement Learning to optimize for generating any consistent program, which we show helps in improving generalization accuracy of the learned programs for large training datasets. Our second contribution incorporates syntax checking as an additional conditioning mechanism for pruning the space of programs during decoding. We show that incorporating syntax leads to significant improvements with limited training datasets. ",
+        "bbox": [
+            174,
+            453,
+            550,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            522,
+            823,
+            564
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stanford CS106A course page. https://see.stanford.edu/Course/CS106A. Accessed: 2017-05- 16. ",
+        "bbox": [
+            174,
+            132,
+            823,
+            159
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hour of Code. http://hourofcode.codehs.com/. Accessed: 2017-05-16. ",
+        "bbox": [
+            173,
+            166,
+            665,
+            181
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pytorch. http://pytorch.org/. ",
+        "bbox": [
+            174,
+            189,
+            401,
+            205
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Saul Amarel. Representations and modeling in problems of program formation. Rutgers University. Livingstone College. Department of Computer Science, 1970. ",
+        "bbox": [
+            176,
+            213,
+            823,
+            239
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Philemon Brakel, Kelvin Xu, Anirudh Goyal, Ryan Lowe, Joelle Pineau, Aaron Courville, and Yoshua Bengio. An actor-critic algorithm for sequence prediction. ICLR, 2017. ",
+        "bbox": [
+            174,
+            247,
+            823,
+            275
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matej Balog, Alexander L Gaunt, Marc Brockschmidt, Sebastian Nowozin, and Daniel Tarlow. Deepcoder: Learning to write programs. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            284,
+            821,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rudy R Bunel, Alban Desmaison, Pawan K Mudigonda, Pushmeet Kohli, and Philip Torr. Adaptive neural compilation. In NIPS, 2016. ",
+        "bbox": [
+            171,
+            319,
+            823,
+            347
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonathon Cai, Richard Shin, and Dawn Song. Making neural programming architectures generalize via recursion. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            354,
+            823,
+            382
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Rudy R Bunel, Rishabh Singh, Matthew Hausknecht, and Pushmeet Kohli. Neural program meta-induction. 2017a. ",
+        "bbox": [
+            173,
+            390,
+            823,
+            417
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Jonathan Uesato, Surya Bhupatiraju, Rishabh Singh, Abdel-rahman Mohamed, and Pushmeet Kohli. Robustfill: Neural program learning under noisy I/O. In ICML, 2017b. ",
+        "bbox": [
+            173,
+            425,
+            825,
+            453
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander L Gaunt, Marc Brockschmidt, Rishabh Singh, Nate Kushman, Pushmeet Kohli, Jonathan Taylor, and Daniel Tarlow. Terpret: A probabilistic programming language for program induction. arXiv preprint arXiv:1608.04428, 2016. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            501
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In ICASSP, 2013. ",
+        "bbox": [
+            173,
+            508,
+            823,
+            536
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014. ",
+        "bbox": [
+            173,
+            544,
+            823,
+            559
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka Grabska-Barwinska, ´ Sergio Gómez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, et al. Hybrid computing using a neural network with dynamic external memory. Nature, 2016. ",
+        "bbox": [
+            174,
+            566,
+            823,
+            608
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Edward Grefenstette, Karl Moritz Hermann, Mustafa Suleyman, and Phil Blunsom. Learning to transduce with unbounded memory. In NIPS, 2015. ",
+        "bbox": [
+            171,
+            614,
+            823,
+            642
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sumit Gulwani, William R Harris, and Rishabh Singh. Spreadsheet data manipulation using examples. Communications of the ACM, 2012. ",
+        "bbox": [
+            174,
+            650,
+            823,
+            678
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Guu, Panupong Pasupat, Evan Zheran Liu, and Percy Liang. From language to programs: Bridging reinforcement learning and maximum marginal likelihood. In ACL, 2017. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 1997. ",
+        "bbox": [
+            174,
+            722,
+            743,
+            736
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Judy Hoffman, Fei-Fei Li, C. Lawrence Zitnick, and Ross B. Girshick. Inferring and executing programs for visual reasoning. 2017. ",
+        "bbox": [
+            171,
+            744,
+            823,
+            772
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin and Tomas Mikolov. Inferring algorithmic patterns with stack-augmented recurrent nets. In NIPS, 2015. ",
+        "bbox": [
+            174,
+            780,
+            823,
+            808
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Łukasz Kaiser and Ilya Sutskever. Neural gpus learn algorithms. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            815,
+            650,
+            830
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            173,
+            838,
+            823,
+            866
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karol Kurach, Marcin Andrychowicz, and Ilya Sutskever. Neural random-access machines. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            875,
+            805,
+            888
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matt J Kusner, Brooks Paige, and José Miguel Hernández-Lobato. Grammar variational autoencoder. In ICML, 2017. ",
+        "bbox": [
+            174,
+            897,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chengtao Li, Daniel Tarlow, Alexander L. Gaunt, Marc Brockschmidt, and Nate Kushman. Neural program lattices. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            131
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Percy Liang, Michael I Jordan, and Dan Klein. Learning programs: A hierarchical bayesian approach. In ICML, 2010. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            166
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Henry Lieberman. Your wish is my command: Programming by example. 2001. ",
+        "bbox": [
+            174,
+            174,
+            645,
+            189
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Stephen Muggleton. Inductive logic programming. New generation computing, 1991. ",
+        "bbox": [
+            174,
+            196,
+            679,
+            212
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Stephen H Muggleton, Dianhuan Lin, Niels Pahlavi, and Alireza Tamaddoni-Nezhad. Meta-interpretive learning: application to grammatical inference. Machine learning, 2014. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            247
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Arvind Neelakantan, Quoc V Le, and Ilya Sutskever. Neural programmer: Inducing latent programs with gradient descent. In ICLR, 2016. ",
+        "bbox": [
+            174,
+            255,
+            825,
+            282
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Emilio Parisotto, Abdelrahman Mohamed, Rishabh Singh, Lihong Li, Denny Zhou, and Pushmeet Kohli. Neuro-symbolic program synthesis. In ICLR, 2017. ",
+        "bbox": [
+            176,
+            290,
+            823,
+            318
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard E Pattis. Karel the robot: a gentle introduction to the art of programming. John Wiley & Sons, Inc., 1981. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            352
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            361,
+            823,
+            387
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed and Nando de Freitas. Neural programmer-interpreters. In ICLR, 2016. ",
+        "bbox": [
+            174,
+            395,
+            665,
+            411
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Riedel, Matko Bosnjak, and Tim Rocktäschel. Programming with a differentiable forth interpreter. In ICML, 2017. ",
+        "bbox": [
+            173,
+            417,
+            823,
+            445
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Phillip D Summers. A methodology for lisp program construction from examples. Journal of the ACM, 1977. ",
+        "bbox": [
+            173,
+            453,
+            820,
+            468
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard J Waldinger and Richard CT Lee. Prow: A step toward automatic program writing. In IJCAI, 1969. ",
+        "bbox": [
+            171,
+            477,
+            812,
+            491
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 1992. ",
+        "bbox": [
+            173,
+            500,
+            823,
+            526
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sam Wiseman and Alexander M Rush. Sequence-to-sequence learning as beam-search optimization. In EMNLP, 2016. ",
+        "bbox": [
+            174,
+            534,
+            823,
+            561
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016. ",
+        "bbox": [
+            174,
+            569,
+            823,
+            609
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Pengcheng Yin and Graham Neubig. A syntactic neural model for general-purpose code generation. In ACL, 2017. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            645
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A COMPUTING THE RICHER LOSS FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            560,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe how the objective function of Equation (10) can be computed. ",
+        "bbox": [
+            173,
+            130,
+            759,
+            145
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We have a distribution $q _ { \\theta }$ over $S$ programs, as obtained by performing a beam search over $p _ { \\theta }$ and renormalizing. We are going to get $C$ independent samples from this distribution and obtain a reward corresponding to the best performing of all of them. ",
+        "bbox": [
+            174,
+            151,
+            821,
+            194
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In the case where the reward function $R _ { i } ( \\lambda _ { r } )$ is built on a boolean property, such as for example “correctness of the generated program”, Equation (10) can be simplified. As $R _ { i } ( \\lambda _ { r } )$ can only take the values 0 or 1, the term $\\operatorname* { m a x } _ { j \\in 1 \\ldots C } R _ { i } ( \\lambda _ { j } )$ is going to be equal to 0 only if all of the $C$ sampled programs give a reward of zero. For each sample, there is a probability of $\\begin{array} { r } { q _ { \\mathrm { i n c o r r e c t } } = \\sum _ { \\lambda _ { r } \\in { \\bf B S } ( p _ { \\theta } , S ) } [ R _ { i } ( \\bar { \\lambda _ { r } } ) = = 0 ] q _ { \\theta } ( \\lambda _ { r } \\mid \\{ I O _ { i } ^ { k } \\} _ { k = 1 \\dots K } ) } \\end{array}$ of samput of the g a prograsamples is ewards. From $C$ $q _ { \\mathrm { i n c o r r e c t } } ^ { C }$ this, we can derive the form of Equation (11). Note that this can be computed without any additional sampling steps as we have a close form solution for this expectation. ",
+        "bbox": [
+            173,
+            200,
+            825,
+            316
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In the general case, a similar derivation can be obtained. Assume that the programs outputted by the beam search have associated rewards $R _ { 0 } , R _ { 1 } , . . . , R _ { S }$ and assume without loss of generality that $R _ { 0 } < R _ { 1 } < . . < R _ { S }$ . The probability of sampling a program with a reward smaller than $R _ { i }$ is $\\begin{array} { r } { q _ { \\le R _ { i } } = \\sum _ { \\lambda _ { r } \\in \\mathrm { B S } ( p _ { \\theta } , S ) } [ R _ { i } ( \\lambda _ { r } ) \\le R _ { i } ] \\stackrel { \\cdot } { q _ { \\theta } } ( \\lambda _ { r } \\mid \\{ { \\hat { I } } { \\hat { O } } _ { i } ^ { k } \\} _ { k = 1 \\ldots K } ^ { - } ) } \\end{array}$ so the probability of obtaining a final reward of less than $R _ { i }$ when sampling $\\textrm { C }$ samples is $q _ { \\leq { R _ { i } } } ^ { C }$ . As a result, the probability of obtaining a reward of exactly $R _ { i }$ is $\\left( q _ { \\leq R _ { i } } ^ { C } - q _ { \\leq R _ { i - 1 } } ^ { C } \\right)$ . Based on this, it is easy to evaluate (and differentiate) the loss function described by Equation (10). ",
+        "bbox": [
+            173,
+            323,
+            825,
+            436
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B KAREL LANGAGE SPECIFICATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            450,
+            490,
+            467
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a3e9426d10477a1607372e874fd8f7d7e405c0b2aa489a49720581ed82f16dcb.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\operatorname { P r o g } p } & { : = } & { \\det \\operatorname { r u n } ( ) : s } \\\\ { \\operatorname { S t m } \\textstyle * } & { : = } & { \\textstyle \\operatorname { w h i l } \\textstyle \\mathrm { 1 } \\cdot \\boldsymbol { \\mathrm { s } } \\left| \\operatorname { r e p e a t } ( r ) : s \\right| \\textstyle \\mathrm { s } _ { 1 } ; \\boldsymbol { s } _ { 2 } \\left| \\alpha \\right. } \\\\ & { \\big | } & { \\big | \\big | \\big | \\big | \\big | \\big | \\operatorname { s } : \\big | \\operatorname { i f e l s e } ( b ) : \\boldsymbol { s } _ { 1 } \\big . \\mathrm { e l s e } : \\boldsymbol { s } _ { 2 } } \\\\ { \\operatorname { C o n d } b } & { : = } & { \\textstyle \\operatorname { f r o n t } \\operatorname { I s C l e a r } ( ) \\big | \\big | \\operatorname { l e f t } \\operatorname { I s C l e a r } ( ) \\big | \\big | \\operatorname { r i g h t } \\operatorname { I s C l e a r } ( ) } \\\\ & { \\big | } & { \\textstyle \\operatorname { m a r k e r s p r e s e n t } ( ) \\big | \\operatorname { n o M a r k e r s P r e s e n t } ( ) \\big | \\operatorname { n o t } b } \\\\ { \\operatorname { A c t i o n } \\big . } & { : = } & { \\operatorname { m o v e } \\big ( ) \\big | \\operatorname { t u r n R i g h t } \\big ( ) \\big | \\operatorname { t u r n L e f t } ( ) } \\\\ & { \\big | } & { \\big | \\operatorname { p i c k M a r k e r } ( ) \\big | \\operatorname { p u t M a r k e r } ( ) } \\\\ { \\operatorname { C s t e r } } & { : = } & { 0 \\big | 1 \\big | \\operatorname { 1 } \\dots | \\operatorname { l 9 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            497,
+            735,
+            641
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "",
+        "image_caption": [
+            "Figure 4: The Domain-specific language for Karel programs. "
+        ],
+        "image_footnote": [],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C EXPERIMENTS HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            693,
+            503,
+            708
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The state of the grid word are represented as a $1 6 \\times 1 8 \\times 1 8$ tensor. For each cell of the grid, the 16-dimensional vector corresponds to the feature indicated in Table 5 ",
+        "bbox": [
+            176,
+            719,
+            823,
+            750
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The decoders are two-layer LSTM with a hidden size of 256. Tokens of the DSL are embedded to a 256 dimensional vector. The input of the LSTM is therefore of dimension 768 (256 dimensional of the token $+ 5 1 2$ dimensional of the IO pair embedding). The LSTM used to model the syntax is similarly sized but doesn’t take the embedding of the IO pairs as input so its input size is only 256. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            811
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "One decoder LSTM is run on the embedding of each IO pair. The topmost activation are passed through a MaxPooling operation to obtain a 256 dimensional vector representing all pairs. This is passed through a linear layer to obtain a score for each of the 52 possible tokens. We add the output of the model and of the eventual syntax model, whether learned or handwritten and pass it through a SoftMax layer to obtain a probability distribution over the next token. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "All training is performed using the Adam optimizer, with a learning rate of $1 0 ^ { - } 4$ . Supervised training used a batch size of 128 and RL methods used a batch size of 16. We used 100 rollouts per samples for the Reinforce method and a beam size of 64 for methods based on the beam search. The value of C used for the methods computing a loss on bags of programs was 5. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/c23c96d93e164557f86b91c8c405961a35388c0e83e6e6b66539b0561a4eadb0.jpg",
+        "table_caption": [
+            "Table 5: Representation of the grid "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Hero facingNorth</td></tr><tr><td rowspan=1 colspan=1>Hero facingSouth</td></tr><tr><td rowspan=1 colspan=1>Hero facing West</td></tr><tr><td rowspan=1 colspan=1>Hero facing East</td></tr><tr><td rowspan=1 colspan=1>Obstacle</td></tr><tr><td rowspan=1 colspan=1>Grid boundary</td></tr><tr><td rowspan=1 colspan=1>1 marker</td></tr><tr><td rowspan=1 colspan=1>2 marker</td></tr><tr><td rowspan=1 colspan=1>3 marker</td></tr><tr><td rowspan=1 colspan=1>4 marker</td></tr><tr><td rowspan=1 colspan=1>5marker</td></tr><tr><td rowspan=1 colspan=1>6 marker</td></tr><tr><td rowspan=1 colspan=1>7 marker</td></tr><tr><td rowspan=1 colspan=1>8 marker</td></tr><tr><td rowspan=1 colspan=1>9 marker</td></tr><tr><td rowspan=1 colspan=1>10 marker</td></tr></table>",
+        "bbox": [
+            428,
+            101,
+            570,
+            333
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/3df5e05947fa987499a3c503dceba26ce851d3b6ea7551b5f6b7d5bbc8914514.jpg",
+        "table_caption": [
+            "Table 6: Encoding of the Input/Output Pairs "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Grid Embedding</td><td>Input Grid Conv2D,kernel size= 3, padding=1,16 →32</td><td>Output Grid Conv2D,kernel size=3,padding=1,16-&gt;32</td></tr><tr><td>ReLU</td><td>ReLU Conv2D,kernel size=3,padding1,64 → 64</td></tr><tr><td>Residual Block 1</td><td colspan=\"2\">ReLU Conv2D, kernel size = 3, padding 1, 64 → 64 ReLU Conv2D,kernel size = 3,padding1,64 →→ 64 ReLU</td></tr><tr><td rowspan=\"2\">Residual Block 1</td><td>Conv2D,kernel size =3,padding1, 64 -→ 64 Conv2D,kernel size = 3, padding 1, 64 -→ 64</td><td>ReLU</td></tr><tr><td>Conv2D,kernel size = 3, padding 1, 64 -→ 64</td><td>ReLU</td></tr><tr><td>Fully Connected</td><td colspan=\"2\">ReLU Linear,20736→512</td></tr></table>",
+        "bbox": [
+            173,
+            363,
+            968,
+            590
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            641,
+            825,
+            670
+        ],
+        "page_idx": 14
+    }
+]

parse/train/UEtNMTl6yN/UEtNMTl6yN.md

@@ -0,0 +1,240 @@
+# NEURAL POOLING FOR GRAPH NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Tasks such as graph classification, require graph pooling to learn graph-level representations from constituent node representations. In this work, we propose two novel methods using fully connected neural network layers for graph pooling, namely Neural Pooling Method 1 and 2. Our proposed methods have the ability to handle variable number of nodes in different graphs, and are also invariant to the isomorphic structures of graphs. In addition, compared to existing graph pooling methods, our proposed methods are able to capture information from all nodes, collect second-order statistics, and leverage the ability of neural networks to learn relationships among node representations, making them more powerful. We perform experiments on graph classification tasks in the bio-informatics and social network domains to determine the effectiveness of our proposed methods. Experimental results show that our methods lead to an absolute increase of upto $1 . 2 \%$ in classification accuracy over previous works and a general decrease in standard deviation across multiple runs indicating greater reliability. Experimental results also indicate that this improvement in performance is consistent across several datasets.
+
+# 1 INTRODUCTION
+
+Over the past several years, there is a growing number of applications where data is generated from non-Euclidean domains and is represented as graphs with complex relationships and interdependency between entities. Deep learning generalised from grid-like data to the graph domain has led to the development of the remarkably successful Graph Neural Networks (GNNs) (Fan et al., 2019; Gao et al., 2019; Ma et al., $2 0 1 9 \mathrm { a }$ ; Wang et al., 2019b) and its numerous variants such the Graph Convolutional Network (GCN) (Kipf & Welling, 2017), GraphSAGE (Hamilton et al., 2017), graph attention network (GAT) (Velickovi ˇ c et al., 2018), jumping knowledge network (JK) (Xu et al., ´ 2018), and graph isomorphism networks (GINs) (Xu et al., 2019), etc.
+
+Pooling is a common operation in deep learning on grid-like data, such as images. Pooling layers provide an approach to down sampling feature maps by summarizing the presence of features in patches of the feature map. It reduces dimensionality and also provides local translational invariance. In the case of graph data, pooling is used to obtain a representation of a graph using its constituent node representations. However, it is challenging to develop graph pooling methods due to the some special properties of graph data such as the variable number of nodes in different graphs and the isomorphic structures of graphs. Firstly, the number of nodes varies in different graphs, while the graph representations are usually required to have the same fixed size to fit into other downstream machine learning models where they are used for tasks such as classification. Therefore, graph pooling should be capable of handling the variable number of node representations as inputs and producing fixed-sized graph representations. Secondly, unlike images and texts where we can order pixels and words according to the spatial structural information, there is no inherent ordering relationship among nodes in graphs. Therefore, isomorphic graphs should have the same graph representation, and hence, graph pooling should give the same output by taking node representations in any order as inputs.
+
+Our main contributions in this work are two novel graph pooling methods, Neural Pooling Method 1 and 2. These new pooling methods allow us to do the following,i) produce the same dimensional graph representation for graphs with variable number of nodes, ii) remain invariant to the isomorphic structures of graphs, iii) collect second- order statistics, iv) leverage trainable parameters in the form of fully connected neural networks to learn relationships between underlying node representations to generate high quality graph representations which are then used for graph classification tasks.
+
+Experiments are performed on four benchmark bio-informatics datasets and five popular social network datasets to demonstrate the effectiveness and superiority of our proposed graph pooling methods. Experimental results show that our methods lead to an improvement in classification accuracy over existing methods and are also more reliable as compared to previous works.
+
+# 2 RELATED WORK
+
+# 2.1 GRAPH NEURAL NETWORKS
+
+A graph can be represented by its adjacency matrix and node features. Formally, for a graph $\mathcal { G }$ consisting of $n$ nodes, its topology information can be represented by an adjacency matrix ${ \pmb A } \in$ $\{ 0 , 1 \} ^ { n \times n }$ and the node features can be represented as $\dot { \boldsymbol { X } } \in \mathbb { R } ^ { n \times d }$ , assuming each node has a d-dimensional feature vector. GNNs learn feature representations for different nodes using these matrices (Gilmer et al., 2017). Several approaches are proposed to investigate deep GNNs, and they generally follow a neighborhood information aggregation scheme (Gilmer et al., 2017; Xu et al., 2019; Kipf & Welling, 2017; Hamilton et al., 2017; Velickovi ˇ c et al., 2018). In each step, ´ the representation of a node is updated by aggregating the representations of its neighbors. Graph Convolutional Networks (GCNs) are popular variants of GNNs and inspired by the first order graph Laplacian methods (Kipf & Welling, 2017). Graph pooling is used to connect embedded graphs outputted by GNN layers with classifiers for graph classification. Given a graph, GNN layers produce node representations, where each node is embedded as a vector. Graph pooling is applied after GNN layers to process node representations into a single feature vector as the graph representation. A classifier takes the graph representation and performs graph classification.
+
+# 2.2 GRAPH POOLING
+
+Early studies employ simple methods such as averaging and summation as graph pooling (Xu et al., 2019; Duvenaud et al., 2015; Defferrard et al., 2016). However, averaging and summation do not capture the feature correlation information, curtailing the overall model performance (Zhang et al., 2018). Other studies have proposed advanced graph pooling methods, including DIFFPOOL (Ying et al., 2018), SORT-POOL (Zhang et al., 2018), TOPKPOOL (Gao & Ji, 2019), SAGPOOL (Lee et al., 2019), and EIGENPOOL (Ma et al., 2019b), and achieve great performance on multiple benchmark datasets. EIGENPOOL involves the computation of eigenvectors, which is slow and expensive. DIFFPOOL (Ying et al., 2018) treats the graph pooling as a node clustering problem. A cluster of nodes from the original graph are merged to form a new node in the new graph. DIFFPOOL (Ying et al., 2018) proposes to perform the graph convolution operation on node features to obtain node clustering assignment matrix. Intuitively, the class assignment of a given node should depend on the class assignments of other neighbouring nodes. However, DIFFPOOL does not explicitly consider high-order structural relationships, which we that are important for graph pooling. SORTPOOL (Zhang et al., 2018), TOPKPOOL (Gao & Ji, 2019), and SAGPOOL (Lee et al., 2019) learn to select important nodes from the original graph and use these nodes to build a new graph. They share the similar idea to learn a sorting vector based on node representations, which indicates the importance of different nodes. Then only the top $\mathrm { k }$ important nodes are selected to form a new graph while the other nodes are ignored. However, the ignored nodes may contain important features and this information is lost during pooling. It is worth noting that all the graph pooling methods mentioned till now only collect first-order statistics (Boureau et al., 2010). A recent study has proposed second order graph pooling methods $S O P o o l _ { b i m a p }$ and $S O P o o l _ { a t t e n t i o n }$ (Wang & Ji, 2020). In this work, we propose two novel methods using fully connected neural network layers for graph pooling, namely Neural Pooling Method 1 and 2. Compared to existing graph pooling methods, our proposed methods are able to capture information from all nodes, collect second-order statistics, and leverage the ability of neural networks to learn relationships among node representations, making them more powerful.
+
+# 3 METHODOLOGY
+
+# 3.1 PROPERTIES OF GRAPH POOLING
+
+Consider a graph $\mathcal { G } = ( A , X )$ represented by its adjacency matrix $\pmb { A } \in \{ 0 , 1 \} ^ { n \times n }$ and node feature matrix $\ b { X } \in \mathbb { R } ^ { n \times d }$ , where $n$ is the number of nodes in $\mathcal { G }$ and $d$ is the dimension of node features. The node features may come from node labels or node degrees. Graph neural networks are known to be powerful in learning good node representation matrix $\pmb { H }$ from $\pmb { A }$ and $\boldsymbol { X }$ :
+
+$$
+\pmb { H } = [ h _ { 1 } , h _ { 2 } , . . . . . . . . . , h _ { n } ] ^ { T } = \mathbf { G } \mathbf { N } \mathbf { N } ( \pmb { A } , \pmb { X } ) \in \mathbb { R } ^ { n \times \textit { f } }
+$$
+
+where rows of $H , h _ { i } \in \mathbb { R } ^ { f } , i = 1 , 2 , . . . , n$ , are representations of $n$ nodes, and $f$ is the dimension of the node representation obtained from the GNN and depends on the architecture of the GNN. The task that we focus on in this work is to obtain a graph representation vector $_ { h _ { G } }$ from $\pmb { H }$ , which is then fed into a classifier to perform graph classification:
+
+$$
+h _ { G } = \operatorname { g } ( [ A ] , H ) \in \mathbb { R } ^ { c }
+$$
+
+where $\mathrm { g } ( \cdot )$ is the graph pooling function and $c$ is the dimension of $_ { h _ { G } }$ . Here, $[ A ]$ means that the information from $\pmb { A }$ can be optionally used in graph pooling. For simplicity, we omit it in the following discussion.
+
+Note that the function $\mathrm { g } ( \cdot )$ must satisfy two requirements to serve as graph pooling. First, $\mathrm { g } ( \cdot )$ should be able to take $\pmb { H }$ with variable number of rows as the inputs and produce fixed-sized outputs. Specifically, different graphs may have different number of nodes, which means that $n$ is a variable. On the other hand, $c$ , which is the dimension of the graph representation $_ { h _ { G } }$ is supposed to be fixed to fit into the classifier. Second, $\mathrm { g } ( \cdot )$ should output the same $_ { h _ { G } }$ when the order of rows of $\pmb { H }$ changes. This permutation invariance property is necessary to handle isomorphic graphs. To be concrete, if two graph $\mathcal { G } _ { 1 } = ( A _ { 1 } , X _ { 1 } )$ and $\mathcal { G } _ { 2 } = ( A _ { 2 } , X _ { 2 } )$ are isomorphic, GNNs will output the same multi set of node representations. That is, there exists a permutation matrix $P \in \{ 0 , \bar { 1 } \bar  \} ^ { n \times n }$ such that $H _ { 1 } = P H _ { 2 }$ , for $\pmb { H } _ { 1 } = \mathbf { G } \mathbf { N } \mathbf { N } ( \pmb { A } _ { 1 } , \pmb { X } _ { 1 } )$ and $H _ { 2 } = \mathrm { G N N } ( A _ { 2 } , X _ { 2 } )$ . However, the graph representation computed by $\mathrm { g } ( \cdot )$ should be the same, i.e., $\begin{array} { r } { \mathrm { g } ( \pmb { H } _ { 1 } ) = \mathrm { g } ( \pmb { H } _ { 2 } ) } \end{array}$ if ${ \cal H } _ { 1 } = { \cal P } { \cal H } _ { 2 }$ .
+
+# 3.2 NEURAL POOLING METHOD 1
+
+Our first proposed method is called Neural Pooling Method 1. Consider a node representation matrix $\pmb { H }$ obtained following Equation 1 in Section 3.1.
+
+![](images/4a464ce1dec9d058abdf8c5f8e85f74243f223cbe400ccb32842325b50311b2a.jpg)  
+Figure 1: Illustration of our proposed Neural Pooling Method 1. This is an example for a graph $\mathcal { G }$ with 8 nodes. GNNs can learn representations for each node and graph pooling processes node representations into a graph representation vector.
+
+$\pmb { H }$ is passed through a Fully Connected Neural Network Layer $( F C L ^ { 1 } )$ to obtain $H ^ { \prime }$ as:
+
+$$
+\pmb { H } ^ { \prime } = F C L ^ { 1 } ( \pmb { H } ) \in \mathbb { R } ^ { n \times \textit { f } ^ { \prime } } \mathrm { \bf ~ w h e r e ~ } f ^ { \prime } < f
+$$
+
+After this $H ^ { \prime }$ is again passed through a second Fully Connected Neural Network Layer $( F C L ^ { 2 } )$ to obtain $Q$ as:
+
+$$
+Q = F C L ^ { 2 } ( H ^ { \prime } ) \in \mathbb { R } ^ { n \times 1 }
+$$
+
+Finally the graph representation $h _ { G }$ is obtained as:
+
+$$
+\pmb { h } _ { G } = \pmb { H } ^ { \prime T } \pmb { Q } \in \mathbb { R } ^ { f ^ { \prime } \times 1 }
+$$
+
+where $H ^ { \prime T }$ denotes the transpose of $H ^ { \prime }$ .
+
+Neural Pooling Method 1 always outputs an $f ^ { \prime }$ -dimensional graph representation for $\ b { H } \in \mathbb { R } ^ { n \times f }$ , regardless of the value of $\mathbf { n }$ . It is also invariant to permutation so that it outputs the same graph representation, even when the order of rows of $\pmb { H }$ changes.
+
+Intuition: The $F C L ^ { 1 }$ performs the role of reducing the dimensionality of the input node representations. The trainable parameters of this $F C L ^ { 1 }$ can be thought of as learning a mapping from the $f$ to the $f ^ { \prime }$ -dimensional space. The $F C L ^ { 2 }$ reduces the $f ^ { \prime }$ -dimensional node representations to a 1 dimensional representation, $Q$ . $\pmb { H } ^ { \prime } \in \mathbb { R } ^ { n \times \ f ^ { \prime } }$ can be viewed as $H ^ { \prime } = [ l _ { 1 } , l _ { 2 } , \ldots \ldots , l _ { f ^ { \prime } } ] .$ , where $l _ { j }$ $\in \mathbb { R } ^ { n }$ , $j { = } 1 , 2 , . . . , f ^ { \prime }$ . The vector $l _ { j }$ encodes the spatial distribution of the $j$ -th feature in the graph. Based on this view, $H ^ { \prime T } \pmb { Q }$ is able to capture the topology information and $Q$ can be thought of as roughly encoding the position of nodes by learning the weights according to which the $j$ -th feature is aggregated across the nodes.
+
+Neural Pooling Method 1 hence, leverages the ability of neural networks to learn the topological structure as well as correlation among the node representations in $\pmb { H }$ . It captures the essential features and connections between underlying data. It also reduces the dimensionality of $\pmb { H }$ , and results in an accurate representation of the input graph.
+
+# 3.3 NEURAL POOLING METHOD 2
+
+Our second proposed method is called Neural Pooling Method 2. Consider a node representation matrix $\pmb { H }$ obtained following Equation 1 in Section 3.1.
+
+![](images/550267784e0cc753e84314e02422fdc4a7e97d7ea04f2d5dfefc8ec628a99301.jpg)  
+Figure 2: Illustration of our proposed Neural Pooling Method 2. This is an example for a graph $\mathcal { G }$ with 8 nodes. GNNs can learn representations for each node and graph pooling processes node representations into a graph representation vector.
+
+$\pmb { H }$ is passed through a Fully Connected Neural Network Layer $( F C L ^ { 1 } )$ to obtain $H ^ { \prime \prime }$ as:
+
+$$
+\pmb { H } ^ { \prime \prime } = F C L ^ { 1 } ( \pmb { H } ) \in \mathbb { R } ^ { n \times \textit { f } ^ { \prime \prime } } \mathrm { \bf ~ w h e r e ~ } f ^ { \prime \prime } < f
+$$
+
+After this $H ^ { \prime \prime }$ is again passed through a second Fully Connected Neural Network Layer $( F C L ^ { 2 } )$ to obtain $H ^ { \prime }$ as:
+
+$$
+\pmb { H } ^ { \prime } = F C L ^ { 2 } ( \pmb { H } ^ { \prime \prime } ) \in \mathbb { R } ^ { n \times \textit { f } ^ { \prime } } \mathrm { w h e r e } \ f ^ { \prime } < f ^ { \prime \prime }
+$$
+
+Finally the graph representation $h _ { G }$ is obtained as:
+
+$$
+\pmb { h } _ { G } = \mathrm { F l a t t e n } ( \pmb { H } ^ { \prime T } \pmb { H } ^ { \prime } ) \in \mathbb { R } ^ { f ^ { 2 } \times 1 }
+$$
+
+where $H ^ { \prime T }$ denotes the transpose of $H ^ { \prime }$ .
+
+Intuition: The $F C L ^ { 1 }$ performs the role of reducing the dimensionality of the input node representations. The trainable parameters of this $F C L ^ { 1 }$ can be thought of as learning a mapping from the $f$ to the $f ^ { \prime \prime }$ -dimensional space. The $F C L ^ { 2 }$ further reduces the $f ^ { \prime \prime }$ -dimensional node representations to a $f ^ { \prime }$ dimensional representation. $\pmb { H } ^ { \prime } \in \mathbb { R } ^ { n \times \textit { f } ^ { \prime } }$ can be viewed as $H ^ { \prime } = [ l _ { 1 } , l _ { 2 } , \dots \dots , l _ { f ^ { \prime } } ]$ , where $\boldsymbol { l } _ { j } \in \mathbb { R } ^ { n }$ , $j { = } 1 , 2 , . . . , f ^ { \prime }$ . The vector $l _ { j }$ encodes the spatial distribution of the $j$ -th feature in the graph. Based on this view, ${ \pmb { H } } ^ { \prime T } { \pmb { H } } ^ { \prime }$ is able to capture the topology information.
+
+Similar to the previous method, Neural Pooling Method 2 satisfies both the conditions of graph pooling which is that it always outputs an $f ^ { \prime 2 }$ -dimensional graph representation for $H \in \mathbb { R } ^ { \breve { n } \times ^ { \bullet } } $ , regardless of the value of $n$ . It is also invariant to permutation so that it outputs the same graph representation when the order of rows of $\pmb { H }$ changes.
+
+# 4 EXPERIMENTAL SETUP
+
+We perform experiments on graph classification tasks in the bio-informatics and social network domains to demonstrate the effectiveness and superiority of our proposed methods, namely Neural Pooling Methods 1 and 2. Details of datasets and parameter settings are described below.
+
+# 4.1 DATASETS
+
+We use nine graph classification datasets from (Yanardag & Vishwanathan, 2015), including four bioinformatics datasets and five social network datasets. Only bioinformatics datasets come with node labels. For the social network datasets, we use one-hot encoding of node degrees as features. The details of the datasets are summarized in Table 1 and Table 2.
+
+• MUTAG (Debnath et al., 1991) is a bioinformatics dataset of 188 graphs representing nitro compounds. The task is to classify each graph by determining whether the compound is mutagenic aromatic or heteroaromatic.   
+• PTC (Toivonen et al., 2003) is a bioinformatics dataset of 344 graphs representing chemical compounds. Each node comes with one of 19 discrete node labels. The task is to predict the rodent carcinogenicity for each graph.   
+PROTEINS (Borgwardt et al., 2005) is a bioinformatics dataset of 1,113 graph structures of proteins. Nodes in the graphs refer to secondary structure elements (SSEs) and have discrete node labels indicating whether they represent a helix, sheet or turn. And edges mean that two nodes are neighbors along the amino-acid sequence or in space. The task is to predict the protein function for each graph.   
+NCI1 (Wale et al., 2008) is a bioinformatics dataset of 4,110 graphs representing chemical compounds. The graph classification label is decided by anti-cancer screens for ability to suppress or inhibit the growth of a panel of human tumor cell lines.   
+• COLLAB is a scientific collaboration dataset of 5,000 graphs corresponding to egonetworks.The dataset is derived from 3 public collaboration datasets (Leskovec et al., 2005). Each ego-network contains different researchers from each field and is labeled by the corresponding field. The three fields are High Energy Physics, Condensed Matter Physics, and Astro Physics.   
+IMDB-BINARY is a movie collaboration dataset of 1,000 graphs representing egonetworks for actors/actresses. The dataset is derived from collaboration graphs on Action and Romance genres. In each graph, nodes represent actors/actresses and edges simply mean they collaborate the same movie. The graphs are labeled by the corresponding genre and the task is to identify the genre for each graph.   
+IMDB-MULTI is multi-class version of IMDB-BINARY. It contains 1,500 ego-networks and has three extra genres, namely, Comedy, Romance and Sci-Fi.   
+• REDDIT-BINARY is a dataset of 2,000 graphs where each graph represents an online discussion thread. Nodes in a graph correspond to users appearing in the corresponding discussion thread and an edge means that one user responded to another. TrollXChromosomes and atheism are discussion-based subreddits, forming two classes to be classified.
+
+Table 1: Details of bioinformatics datasets   
+
+<table><tr><td>Name</td><td>MUTAG</td><td>PTC PROTEINS</td><td>NCI1</td></tr><tr><td># graphs</td><td>188 344</td><td>1113</td><td>4110</td></tr><tr><td># classes</td><td>2 2</td><td>2</td><td>2</td></tr><tr><td># nodes(max)</td><td>28 109</td><td>620</td><td>111</td></tr><tr><td># nodes(avg.)</td><td>18.0 25.6</td><td>39.1</td><td>29.9</td></tr></table>
+
+Table 2: Details of social network datasets   
+
+<table><tr><td>Name</td><td>COLLAB IMDB-B</td><td>IMDB-M</td><td>RDT-B</td><td>RDT-M5K</td></tr><tr><td># graphs</td><td>5000 1000</td><td>1500</td><td>2000</td><td>5000</td></tr><tr><td># classes</td><td>3 2</td><td>3</td><td>2</td><td>5</td></tr><tr><td># nodes(max)</td><td>492 136</td><td>89</td><td>3783</td><td>3783</td></tr><tr><td># nodes(avg.)</td><td>74.5 19.8</td><td>13.0</td><td>429.6</td><td>508.5</td></tr></table>
+
+• REDDIT-MULTI5K is a similar dataset as REDDIT- BINARY, which contains 5,000 graphs. The difference lies in that REDDIT-MULTI5K crawled data from five different subreddits, namely, worldnews, videos, AdviceAnimals, aww and mildlyinteresting. And the task is to identify the subreddit of each graph instead of determining the type of subreddits.
+
+# 4.2 TRAINING AND EVALUATION
+
+Following (Yanardag & Vishwanathan, 2015; Niepert et al., 2016), model performance is evaluated using 10-fold cross-validation and reported as the average and standard deviation of validation accuracies across the 10 folds. For GNNs, we follow the same training process in (Xu et al., 2019). The GNN has 5 layers. Each multi-layer perceptron (MLP) has 2 layers with batch normalization (Ioffe & Szegedy, 2015). Dropout (Srivastava et al., 2014) is applied in the classifiers. The Adam (Kingma & Ba, 2015) optimizer is used with the learning rate initialized as 0.01 and decayed by 0.5 every 50 epochs. The number of total epochs is selected according to the best cross-validation accuracy. We tune the number of hidden units (16, 32, 64) and the batch size (32, 128) using grid search.
+
+# 4.3 BASELINES
+
+We compare our methods with various other graph pooling methods on the graph classification task, including DIFFPOOL (Ying et al., 2018), SORT-POOL (Zhang et al., 2018), TOPKPOOL (Gao & Ji, 2019), SAGPOOL (Lee et al., 2019), and EIGEN-POOL (Ma et al., 2019b). DIFFPOOL maps nodes to a pre-defined number of clusters but is hard to train. EIGENPOOL involves the computation of eigenvectors, which is slow and expensive. SORTPOOL, SAGPOOL and TOPKPOOL rely on the top-K sorting to select a fixed number (K) of nodes and order them, during which the information from unselected nodes is discarded. We also compare with some recent methods including COVPOOL (Wang et al., 2019a), ATTNPOOL (Girdhar & Ramanan, 2017) as well as second order pooling methods $\mathbf { S O P o o l } _ { b i m a p }$ and SOPoolattention (Wang & Ji, 2020).
+
+# 5 RESULTS & DISCUSSION
+
+The results of our experiments are summarized in Table 3 and Table 4 .From the results we can see that our methods lead to an improvement in classification accuracy over existing methods and are also more reliable as compared previous works as observed from the lower values of standard deviation.This enhancement in performance is consistent across all the datasets. The results may be attributed to the fact that compared to existing graph pooling methods, our pooling methods are able to use information from all nodes, collect second-order statistics, and leverage the ability of neural networks to learn from underlying data, making them more powerful. The Neural Pooling methods utilize the ability of neural networks to learn the topological structure as well as correlation among the node representations in, capturing essential features and connections between underlying data.
+
+Table 3: Comparison results of our proposed methods with other graph pooling methods on bioinformatics datasets. Results shown are the average classification accuracy and standard deviation across 10-fold cross-validation.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>PTC</td><td rowspan=1 colspan=1>PROTEINS</td><td rowspan=1 colspan=1>MUTAG</td><td rowspan=1 colspan=1>NCI1</td></tr><tr><td rowspan=1 colspan=1>SUM/AVG(Xu et al., 2019)</td><td rowspan=1 colspan=1>64.6 ± 7.0</td><td rowspan=1 colspan=1>76.2 ± 2.8</td><td rowspan=1 colspan=1>89.4 ±5.6</td><td rowspan=1 colspan=1>82.7 ± 1.7</td></tr><tr><td rowspan=1 colspan=1>DIFFPOOL(Ying et al., 2018)</td><td rowspan=1 colspan=1>66.1 ± 7.7</td><td rowspan=1 colspan=1>78.8± 3.1</td><td rowspan=1 colspan=1>94.8± 4.8</td><td rowspan=1 colspan=1>76.6 ± 1.3</td></tr><tr><td rowspan=1 colspan=1>SORTPOOL(Zhang et al., 2018)</td><td rowspan=1 colspan=1>69.5± 6.3</td><td rowspan=1 colspan=1>79.2 ± 3.0</td><td rowspan=1 colspan=1>95.2 ± 3.9</td><td rowspan=1 colspan=1>78.9 ± 2.7</td></tr><tr><td rowspan=1 colspan=1>TOPKPOOL(Gao &amp; Ji, 2019)</td><td rowspan=1 colspan=1>68.4 ± 6.4</td><td rowspan=1 colspan=1>79.1 ± 2.2</td><td rowspan=1 colspan=1>94.7± 3.5</td><td rowspan=1 colspan=1>79.6 ± 1.7</td></tr><tr><td rowspan=1 colspan=1>SAGPOOL(Lee et al., 2019)</td><td rowspan=1 colspan=1>69.0 ± 6.6</td><td rowspan=1 colspan=1>78.4± 3.1</td><td rowspan=1 colspan=1>93.9 ± 3.3</td><td rowspan=1 colspan=1>79.0 ± 2.8</td></tr><tr><td rowspan=1 colspan=1>ATTNPOOL(Girdhar &amp; Ramanan, 2017)</td><td rowspan=1 colspan=1>71.2± 8.0</td><td rowspan=1 colspan=1>77.5± 3.3</td><td rowspan=1 colspan=1>93.2± 5.8</td><td rowspan=1 colspan=1>80.6± 2.1</td></tr><tr><td rowspan=1 colspan=1>EIGENPOOL(Ma et al.,2019b)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>76.6± 2.3</td><td rowspan=1 colspan=1>80.6± 4.3</td><td rowspan=1 colspan=1>77.0 ± 2.3</td></tr><tr><td rowspan=1 colspan=1>COVPOOL(Wang et al.,2019a)</td><td rowspan=1 colspan=1>73.3 ± 5.1</td><td rowspan=1 colspan=1>80.1 ± 2.2</td><td rowspan=1 colspan=1>95.3 ± 3.7</td><td rowspan=1 colspan=1>83.5 ± 1.9</td></tr><tr><td rowspan=1 colspan=1>SOPOOLattn(Wang &amp; Ji, 2020)</td><td rowspan=1 colspan=1>72.9 ± 6.2</td><td rowspan=1 colspan=1>79.4 ± 3.2</td><td rowspan=1 colspan=1>93.6 ± 4.1</td><td rowspan=1 colspan=1>82.8± 1.4</td></tr><tr><td rowspan=1 colspan=1> SOPOOLbimap(Wang &amp; Ji, 2020)</td><td rowspan=1 colspan=1>75.0 ± 4.3</td><td rowspan=1 colspan=1>80.1 ± 2.7</td><td rowspan=1 colspan=1>95.3 ± 4.4</td><td rowspan=1 colspan=1>83.6 ± 1.4</td></tr><tr><td rowspan=1 colspan=1>Neural Pooling 1(ours)</td><td rowspan=1 colspan=1>74.5 ± 3.7</td><td rowspan=1 colspan=1>80.6 ± 2.7</td><td rowspan=1 colspan=1>94.0 ± 2.3</td><td rowspan=1 colspan=1>83.1 ± 1.2</td></tr><tr><td rowspan=1 colspan=1>Neural Pooling 2(ours)</td><td rowspan=1 colspan=1>76.2 ± 4.2</td><td rowspan=1 colspan=1>79.6± 3.0</td><td rowspan=1 colspan=1>95.5 ± 2.4</td><td rowspan=1 colspan=1>83.4 ± 1.9</td></tr></table>
+
+Table 4: Comparison results of our proposed methods with other graph pooling methods on social network datsets. Results shown are the average classification accuracy and standard deviation across 10-fold cross-validation.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>COLLAB</td><td rowspan=1 colspan=1>RDT-B</td><td rowspan=1 colspan=1>IMDB-B</td><td rowspan=1 colspan=1>IMDB-M</td><td rowspan=1 colspan=1>RDT-M5K</td></tr><tr><td rowspan=1 colspan=1> SUM/AVG</td><td rowspan=1 colspan=1>80.2 ± 1.9</td><td rowspan=1 colspan=1>92.4 ± 2.5</td><td rowspan=1 colspan=1>75.1 ± 5.1</td><td rowspan=1 colspan=1>52.3 ± 2.8</td><td rowspan=1 colspan=1>57.5 ± 1.5</td></tr><tr><td rowspan=1 colspan=1>DIFFPOOL</td><td rowspan=1 colspan=1>75.3 ± 2.2</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>74.4 ± 4.0</td><td rowspan=1 colspan=1>50.1 ± 3.2</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>SORTPOOL</td><td rowspan=1 colspan=1>78.2 ± 1.6</td><td rowspan=1 colspan=1>81.6 ± 4.6</td><td rowspan=1 colspan=1>77.5± 2.7</td><td rowspan=1 colspan=1>53.1 ± 2.9</td><td rowspan=1 colspan=1>48.4± 4.8</td></tr><tr><td rowspan=1 colspan=1>TOPKPOOL</td><td rowspan=1 colspan=1>79.6 ± 2.1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>77.8 ± 5.1</td><td rowspan=1 colspan=1>53.7 ± 2.8</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>SAGPOOL</td><td rowspan=1 colspan=1>78.9 ± 1.7</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>77.8 ± 2.9</td><td rowspan=1 colspan=1>53.1 ± 2.8</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>ATTNPOOL</td><td rowspan=1 colspan=1>81.8± 2.2</td><td rowspan=1 colspan=1>92.5± 2.3</td><td rowspan=1 colspan=1>77.1 ± 4.4</td><td rowspan=1 colspan=1>53.8 ± 2.5</td><td rowspan=1 colspan=1>57.9 ± 1.7</td></tr><tr><td rowspan=1 colspan=1>COVPOOL</td><td rowspan=1 colspan=1>79.3 ± 1.8</td><td rowspan=1 colspan=1>90.3± 3.6</td><td rowspan=1 colspan=1>72.1± 5.1</td><td rowspan=1 colspan=1>47.8 ± 2.7</td><td rowspan=1 colspan=1>58.4±1.7</td></tr><tr><td rowspan=1 colspan=1>SOPOOLattn</td><td rowspan=1 colspan=1>81.1 ± 1.8</td><td rowspan=1 colspan=1>91.7 ± 2.7</td><td rowspan=1 colspan=1>78.1 ± 4.0</td><td rowspan=1 colspan=1>54.3± 2.6</td><td rowspan=1 colspan=1>58.3 ± 1.4</td></tr><tr><td rowspan=1 colspan=1>SOPOOLbimap</td><td rowspan=1 colspan=1>79.9 ± 1.9</td><td rowspan=1 colspan=1>89.6±3.3</td><td rowspan=1 colspan=1>78.4± 4.7</td><td rowspan=1 colspan=1>54.6± 3.6</td><td rowspan=1 colspan=1>58.4 ± 1.6</td></tr><tr><td rowspan=1 colspan=1>Neural Pooling 1(ours)</td><td rowspan=1 colspan=1>80.5± 1.5</td><td rowspan=1 colspan=1>90.6± 2.3</td><td rowspan=1 colspan=1>79.0 ± 2.3</td><td rowspan=1 colspan=1>55.1± 2.2</td><td rowspan=1 colspan=1>58.5 ± 1.8</td></tr><tr><td rowspan=1 colspan=1>Neural Pooling 2(ours)</td><td rowspan=1 colspan=1>81.0 ± 1.7</td><td rowspan=1 colspan=1>91.5 ± 3.0</td><td rowspan=1 colspan=1>78.5 ± 2.4</td><td rowspan=1 colspan=1>54.4 ± 1.9</td><td rowspan=1 colspan=1>59.1 ± 1.4</td></tr></table>
+
+# 6 COMPLEXITY
+
+Consider a graph $\mathcal { G } = ( A , X )$ represented by its adjacency matrix $\pmb { A } \in \{ 0 , 1 \} ^ { n \times n }$ and node feature matrix $\ b { X } \in \ b { \mathbb { R } ^ { n } } \times \ b { d }$ , where $n$ is the number of nodes in $\mathcal { G }$ and $d$ is the dimension of node features. Consider, $H = [ h _ { 1 } , h _ { 2 }$ , ........., $\pmb { h } _ { n } ] ^ { T } = \mathbf { G } \mathbf { N } \mathbf { N } ( \pmb { A } , \pmb { X } ) \in \mathbb { R } ^ { n \times \pmb { f } }$ where rows of $\pmb { H }$ , $\boldsymbol { h } _ { i } \in \mathbb { R } ^ { f }$ , $i$ $= 1 , 2 , . . . , n$ , are representations of $n$ nodes. Consider a direct application of second-order graph pooling to obtain the graph representation $h _ { G }$ as:
+
+$$
+\pmb { h } _ { G } = \mathrm { F l a t t e n } ( \pmb { H } ^ { T } \pmb { H } ) \in \mathbb { R } ^ { f ^ { 2 } \times 1 }
+$$
+
+where $H ^ { T }$ denotes the transpose of $\pmb { H }$
+
+However, it causes an explosion in the number of training parameters in the following classifier when $f$ is large, making the learning process harder to converge and easier to overfit. While each layer in a GNN usually has outputs with a small number of hidden units (e.g. 16, 32, 64), it has been pointed out that graph representation learning benefits from using information from outputs of all layers, obtaining better performance and generalization ability. It is usually achieved by concatenating outputs across all layers in a GNN. In this case, $\pmb { H }$ has a large final $f$ , making direct use of secondorder pooling infeasible. For example, if a GNN has 5 layers and each layer’s outputs have 32 hidden units, $f$ becomes $3 2 \times 5 = 1 6 0$ . Suppose $h _ { G }$ is sent into a 1-layer fully-connected classifier for $c$ graph categories in a graph classification task. It results in $1 6 0 ^ { \dot { 2 } } c = 2 \dot { 5 } , 6 0 0 c$ training parameters, which is excessive. We omit the bias term for simplicity. On the other hand, both of our proposed novel graph pooling methods significantly reduce the number of training parameters. In the case of Neural Pooling Method 1, considering the previous example if $f ^ { \prime }$ is chosen to be 64, and $f$ is 160, then the total number of trainable parameters in the $2 ~ F C L s$ and a 1-layer fully-connected $c$ class classifier will be $( 1 6 0 \times 6 4 ) + 6 4 + 6 4 c = 1 0 , 3 0 4 + 6 4 c$ notably reducing the number of parameters as compared to 25, $6 0 0 c$ . In the case of Neural Pooling Method 2, if $f ^ { \prime \bar { \prime } }$ is chosen to be 64, $f ^ { \prime }$ as 32 and $f$ is 160, then the total number of trainable parameters in the $2 \ : F C L s$ and a 1-layer fully-connected $c$ class classifier will be $( 1 6 0 \times 6 4 ) + ( 6 4 \times 3 2 ) + 3 2 2 c = 1 2 , 2 8 8 + 1 0 2 4 c$ again reducing the number of parameters when compared to $2 5 , 6 0 0 c$ .
+
+# 7 CONCLUSION
+
+In this work, we propose to perform graph representation learning with Neural Pooling, by pointing out that Neural Pooling can naturally solve the challenges of graph pooling. Neural Pooling is more powerful than existing graph pooling methods, since it is capable of using all node information, collecting second-order statistics that encode feature correlations and topology information and leverage the ability of neural networks to learn from underlying data, making them more powerful. Our proposed methods solve the practical problems incurred by directly using second-order pooling with GNNs. To demonstrate the effectiveness and superiority of our methods, we perform experiments on graph classification tasks in the bio-informatics and social network domains to demonstrate the effectiveness and superiority of our proposed methods. Experimental results show that our methods improve the performance significantly and consistently. An interesting future work direction could be to extend our methods for hierarchical graph pooling, where the output is a is a pseudo graph with fewer nodes than the input graph. It is used to build hierarchical GNNs, where hierarchical graph pooling is used several times between GNN layers to gradually decrease the number of nodes.
+
+# REFERENCES
+
+KM Borgwardt, Stefan Schonauer, SVN Vishwanathan, Alexander Smola, and HP Kriegel. Protein ¨ function prediction via graph kernels. Bioinformatics, 21 Suppl 1:i47–56, 01 2005.
+
+Y-Lan Boureau, Jean Ponce, and Yann LeCun. A theoretical analysis of feature pooling in visual recognition. In Johannes Furnkranz and Thorsten Joachims (eds.), ¨ Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 111–118, Haifa, Israel, June 2010. Omnipress. URL http://www.icml2010.org/papers/638.pdf.
+
+Asim Kumar Debnath, Rosa L Lopez de Compadre, Gargi Debnath, Alan J Shusterman, and Corwin Hansch. Structure-activity relationship of mutagenic aromatic and heteroaromatic nitro compounds. correlation with molecular orbital energies and hydrophobicity. Journal of medicinal chemistry, 34(2):786–797, 1991.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In Daniel D. Lee, Masashi Sugiyama, Ulrike von Luxburg, Isabelle Guyon, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5- 10, 2016, Barcelona, Spain, pp. 3837–3845, 2016.
+
+David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 2224–2232. Curran Associates, Inc., 2015.
+
+Wenqi Fan, Yao Ma, Qing Li, Yuan He, Eric Zhao, Jiliang Tang, and Dawei Yin. Graph neural networks for social recommendation. In The World Wide Web Conference, WWW ’19, pp. 417–426, New York, NY, USA, 2019. Association for Computing Machinery. ISBN 9781450366748. doi: 10.1145/3308558.3313488. URL https://doi.org/10.1145/3308558.3313488.
+
+Hongchang Gao, Jian Pei, and Heng Huang. Conditional random field enhanced graph convolutional neural networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD ’19, pp. 276–284, New York, NY, USA, 2019. Association for Computing Machinery. ISBN 9781450362016. doi: 10.1145/3292500.3330888. URL https://doi.org/10.1145/3292500.3330888.
+
+Hongyang Gao and Shuiwang Ji. Graph u-nets. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9- 15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 2083–2092. PMLR, 2019. URL http://proceedings.mlr.press/v97/ gao19a.html.
+
+Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research, pp. 1263–1272. PMLR, 2017. URL http://proceedings.mlr.press/v70/gilmer17a.html.
+
+Rohit Girdhar and Deva Ramanan. Attentional pooling for action recognition. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, 4-9 December 2017, Long Beach, CA, USA, pp. 34–45, 2017. URL http://papers.nips.cc/paper/ 6609-attentional-pooling-for-action-recognition.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 1024–1034. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 6703-inductive-representation-learning-on-large-graphs.pdf.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Francis R. Bach and David M. Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, volume 37 of JMLR Workshop and Conference Proceedings, pp. 448–456. JMLR.org, 2015. URL http://proceedings.mlr.press/v37/ioffe15.html.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Yoshua Bengio and Yann LeCun (eds.), 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http: //arxiv.org/abs/1412.6980.
+
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017. URL https: //openreview.net/forum?id $=$ SJU4ayYgl.
+
+Junhyun Lee, Inyeop Lee, and Jaewoo Kang. Self-attention graph pooling. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 3734–3743. PMLR, 2019. URL http://proceedings. mlr.press/v97/lee19c.html.
+
+Jure Leskovec, Jon Kleinberg, and Christos Faloutsos. Graphs over time: densification laws, shrinking diameters and possible explanations. In Proceedings of the eleventh ACM SIGKDD international conference on Knowledge discovery in data mining, pp. 177–187, 2005.
+
+Jianxin Ma, Peng Cui, Kun Kuang, Xin Wang, and Wenwu Zhu. Disentangled graph convolutional networks. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 4212–4221. PMLR, 2019a. URL http://proceedings.mlr.press/v97/ma19a.html.
+
+Yao Ma, Suhang Wang, Charu C. Aggarwal, and Jiliang Tang. Graph convolutional networks with eigenpooling. KDD ’19, pp. 723–731, New York, NY, USA, 2019b. Association for Computing Machinery. ISBN 9781450362016. doi: 10.1145/3292500.3330982. URL https://doi. org/10.1145/3292500.3330982.
+
+Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural networks for graphs. In Maria-Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, volume 48 of JMLR Workshop and Conference Proceedings, pp. 2014–2023. JMLR.org, 2016. URL http://proceedings.mlr.press/v48/niepert16.html.
+
+Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15(1): 1929–1958, 2014. URL http://dl.acm.org/citation.cfm?id=2670313.
+
+Hannu Toivonen, Ashwin Srinivasan, Ross D. King, Stefan Kramer, and Christoph Helma. Statistical evaluation of the Predictive Toxicology Challenge 2000–2001. Bioinformatics, 19(10): 1183–1193, 07 2003. ISSN 1367-4803. doi: 10.1093/bioinformatics/btg130. URL https: //doi.org/10.1093/bioinformatics/btg130.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li ´ o, and Yoshua \` Bengio. Graph attention networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $=$ rJXMpikCZ.
+
+Nikil Wale, Ian A Watson, and George Karypis. Comparison of descriptor spaces for chemical compound retrieval and classification. Knowledge and Information Systems, 14(3):347–375, 2008.
+
+Qilong Wang, Jiangtao Xie, Wangmeng Zuo, Lei Zhang, and Peihua Li. Deep cnns meet global covariance pooling: Better representation and generalization. CoRR, abs/1904.06836, 2019a. URL http://arxiv.org/abs/1904.06836.
+
+Xiao Wang, Houye Ji, Chuan Shi, Bai Wang, Yanfang Ye, Peng Cui, and Philip S Yu. Heterogeneous graph attention network. In The World Wide Web Conference, WWW ’19, pp. 2022–2032, New York, NY, USA, 2019b. Association for Computing Machinery. ISBN 9781450366748. doi: 10.1145/3308558.3313562. URL https://doi.org/10.1145/3308558.3313562.
+
+Z. Wang and S. Ji. Second-order pooling for graph neural networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020.
+
+Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. In Jennifer G. Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on
+
+Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018 ¨ , volume 80 of Proceedings of Machine Learning Research, pp. 5449–5458. PMLR, 2018. URL http://proceedings.mlr.press/v80/xu18c.html.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $=$ ryGs6iA5Km.
+
+Pinar Yanardag and S.V.N. Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’15, pp. 1365–1374, New York, NY, USA, 2015. Association for Computing Machinery. ISBN 9781450336642. doi: 10.1145/2783258.2783417. URL https://doi.org/10.1145/ 2783258.2783417.
+
+Zhitao Ying, Jiaxuan You, Christopher Morris, Xiang Ren, William L. Hamilton, and Jure Leskovec. Hierarchical graph representation learning with differentiable pooling. In Samy Bengio, Hanna M. Wallach, Hugo Larochelle, Kristen Grauman, Nicolo Cesa-Bianchi, and Roman Garnett (eds.), \` Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, 3-8 December 2018, Montreal, Canada ´ , pp. 4805–4815, 2018.
+
+Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. AAAI, 2018.

parse/train/UEtNMTl6yN/UEtNMTl6yN_content_list.json

@@ -0,0 +1,1232 @@
+[
+    {
+        "type": "text",
+        "text": "NEURAL POOLING FOR GRAPH NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            803,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tasks such as graph classification, require graph pooling to learn graph-level representations from constituent node representations. In this work, we propose two novel methods using fully connected neural network layers for graph pooling, namely Neural Pooling Method 1 and 2. Our proposed methods have the ability to handle variable number of nodes in different graphs, and are also invariant to the isomorphic structures of graphs. In addition, compared to existing graph pooling methods, our proposed methods are able to capture information from all nodes, collect second-order statistics, and leverage the ability of neural networks to learn relationships among node representations, making them more powerful. We perform experiments on graph classification tasks in the bio-informatics and social network domains to determine the effectiveness of our proposed methods. Experimental results show that our methods lead to an absolute increase of upto $1 . 2 \\%$ in classification accuracy over previous works and a general decrease in standard deviation across multiple runs indicating greater reliability. Experimental results also indicate that this improvement in performance is consistent across several datasets. ",
+        "bbox": [
+            233,
+            244,
+            764,
+            465
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            334,
+            516
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Over the past several years, there is a growing number of applications where data is generated from non-Euclidean domains and is represented as graphs with complex relationships and interdependency between entities. Deep learning generalised from grid-like data to the graph domain has led to the development of the remarkably successful Graph Neural Networks (GNNs) (Fan et al., 2019; Gao et al., 2019; Ma et al., $2 0 1 9 \\mathrm { a }$ ; Wang et al., 2019b) and its numerous variants such the Graph Convolutional Network (GCN) (Kipf & Welling, 2017), GraphSAGE (Hamilton et al., 2017), graph attention network (GAT) (Velickovi ˇ c et al., 2018), jumping knowledge network (JK) (Xu et al., ´ 2018), and graph isomorphism networks (GINs) (Xu et al., 2019), etc. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            646
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pooling is a common operation in deep learning on grid-like data, such as images. Pooling layers provide an approach to down sampling feature maps by summarizing the presence of features in patches of the feature map. It reduces dimensionality and also provides local translational invariance. In the case of graph data, pooling is used to obtain a representation of a graph using its constituent node representations. However, it is challenging to develop graph pooling methods due to the some special properties of graph data such as the variable number of nodes in different graphs and the isomorphic structures of graphs. Firstly, the number of nodes varies in different graphs, while the graph representations are usually required to have the same fixed size to fit into other downstream machine learning models where they are used for tasks such as classification. Therefore, graph pooling should be capable of handling the variable number of node representations as inputs and producing fixed-sized graph representations. Secondly, unlike images and texts where we can order pixels and words according to the spatial structural information, there is no inherent ordering relationship among nodes in graphs. Therefore, isomorphic graphs should have the same graph representation, and hence, graph pooling should give the same output by taking node representations in any order as inputs. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions in this work are two novel graph pooling methods, Neural Pooling Method 1 and 2. These new pooling methods allow us to do the following,i) produce the same dimensional graph representation for graphs with variable number of nodes, ii) remain invariant to the isomorphic structures of graphs, iii) collect second- order statistics, iv) leverage trainable parameters in the form of fully connected neural networks to learn relationships between underlying node representations to generate high quality graph representations which are then used for graph classification tasks. ",
+        "bbox": [
+            176,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Experiments are performed on four benchmark bio-informatics datasets and five popular social network datasets to demonstrate the effectiveness and superiority of our proposed graph pooling methods. Experimental results show that our methods lead to an improvement in classification accuracy over existing methods and are also more reliable as compared to previous works. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            194
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            231,
+            344,
+            247
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 GRAPH NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            271,
+            415,
+            286
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A graph can be represented by its adjacency matrix and node features. Formally, for a graph $\\mathcal { G }$ consisting of $n$ nodes, its topology information can be represented by an adjacency matrix ${ \\pmb A } \\in$ $\\{ 0 , 1 \\} ^ { n \\times n }$ and the node features can be represented as $\\dot { \\boldsymbol { X } } \\in \\mathbb { R } ^ { n \\times d }$ , assuming each node has a d-dimensional feature vector. GNNs learn feature representations for different nodes using these matrices (Gilmer et al., 2017). Several approaches are proposed to investigate deep GNNs, and they generally follow a neighborhood information aggregation scheme (Gilmer et al., 2017; Xu et al., 2019; Kipf & Welling, 2017; Hamilton et al., 2017; Velickovi ˇ c et al., 2018). In each step, ´ the representation of a node is updated by aggregating the representations of its neighbors. Graph Convolutional Networks (GCNs) are popular variants of GNNs and inspired by the first order graph Laplacian methods (Kipf & Welling, 2017). Graph pooling is used to connect embedded graphs outputted by GNN layers with classifiers for graph classification. Given a graph, GNN layers produce node representations, where each node is embedded as a vector. Graph pooling is applied after GNN layers to process node representations into a single feature vector as the graph representation. A classifier takes the graph representation and performs graph classification. ",
+        "bbox": [
+            174,
+            304,
+            825,
+            498
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 GRAPH POOLING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            531,
+            334,
+            545
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Early studies employ simple methods such as averaging and summation as graph pooling (Xu et al., 2019; Duvenaud et al., 2015; Defferrard et al., 2016). However, averaging and summation do not capture the feature correlation information, curtailing the overall model performance (Zhang et al., 2018). Other studies have proposed advanced graph pooling methods, including DIFFPOOL (Ying et al., 2018), SORT-POOL (Zhang et al., 2018), TOPKPOOL (Gao & Ji, 2019), SAGPOOL (Lee et al., 2019), and EIGENPOOL (Ma et al., 2019b), and achieve great performance on multiple benchmark datasets. EIGENPOOL involves the computation of eigenvectors, which is slow and expensive. DIFFPOOL (Ying et al., 2018) treats the graph pooling as a node clustering problem. A cluster of nodes from the original graph are merged to form a new node in the new graph. DIFFPOOL (Ying et al., 2018) proposes to perform the graph convolution operation on node features to obtain node clustering assignment matrix. Intuitively, the class assignment of a given node should depend on the class assignments of other neighbouring nodes. However, DIFFPOOL does not explicitly consider high-order structural relationships, which we that are important for graph pooling. SORTPOOL (Zhang et al., 2018), TOPKPOOL (Gao & Ji, 2019), and SAGPOOL (Lee et al., 2019) learn to select important nodes from the original graph and use these nodes to build a new graph. They share the similar idea to learn a sorting vector based on node representations, which indicates the importance of different nodes. Then only the top $\\mathrm { k }$ important nodes are selected to form a new graph while the other nodes are ignored. However, the ignored nodes may contain important features and this information is lost during pooling. It is worth noting that all the graph pooling methods mentioned till now only collect first-order statistics (Boureau et al., 2010). A recent study has proposed second order graph pooling methods $S O P o o l _ { b i m a p }$ and $S O P o o l _ { a t t e n t i o n }$ (Wang & Ji, 2020). In this work, we propose two novel methods using fully connected neural network layers for graph pooling, namely Neural Pooling Method 1 and 2. Compared to existing graph pooling methods, our proposed methods are able to capture information from all nodes, collect second-order statistics, and leverage the ability of neural networks to learn relationships among node representations, making them more powerful. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            341,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROPERTIES OF GRAPH POOLING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            446,
+            148
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider a graph $\\mathcal { G } = ( A , X )$ represented by its adjacency matrix $\\pmb { A } \\in \\{ 0 , 1 \\} ^ { n \\times n }$ and node feature matrix $\\ b { X } \\in \\mathbb { R } ^ { n \\times d }$ , where $n$ is the number of nodes in $\\mathcal { G }$ and $d$ is the dimension of node features. The node features may come from node labels or node degrees. Graph neural networks are known to be powerful in learning good node representation matrix $\\pmb { H }$ from $\\pmb { A }$ and $\\boldsymbol { X }$ : ",
+        "bbox": [
+            173,
+            160,
+            825,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/038c8421976545f4c394f0bd38d2dbe4d50f6c75e97819249c5dfcc8210f641a.jpg",
+        "text": "$$\n\\pmb { H } = [ h _ { 1 } , h _ { 2 } , . . . . . . . . . , h _ { n } ] ^ { T } = \\mathbf { G } \\mathbf { N } \\mathbf { N } ( \\pmb { A } , \\pmb { X } ) \\in \\mathbb { R } ^ { n \\times \\textit { f } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            222,
+            679,
+            239
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where rows of $H , h _ { i } \\in \\mathbb { R } ^ { f } , i = 1 , 2 , . . . , n$ , are representations of $n$ nodes, and $f$ is the dimension of the node representation obtained from the GNN and depends on the architecture of the GNN. The task that we focus on in this work is to obtain a graph representation vector $_ { h _ { G } }$ from $\\pmb { H }$ , which is then fed into a classifier to perform graph classification: ",
+        "bbox": [
+            173,
+            244,
+            825,
+            301
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be98070400f4364e5125405225699dd7a32524da295cf637b39c2f853fbb0fdc.jpg",
+        "text": "$$\nh _ { G } = \\operatorname { g } ( [ A ] , H ) \\in \\mathbb { R } ^ { c }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            308,
+            578,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { g } ( \\cdot )$ is the graph pooling function and $c$ is the dimension of $_ { h _ { G } }$ . Here, $[ A ]$ means that the information from $\\pmb { A }$ can be optionally used in graph pooling. For simplicity, we omit it in the following discussion. ",
+        "bbox": [
+            176,
+            329,
+            825,
+            372
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that the function $\\mathrm { g } ( \\cdot )$ must satisfy two requirements to serve as graph pooling. First, $\\mathrm { g } ( \\cdot )$ should be able to take $\\pmb { H }$ with variable number of rows as the inputs and produce fixed-sized outputs. Specifically, different graphs may have different number of nodes, which means that $n$ is a variable. On the other hand, $c$ , which is the dimension of the graph representation $_ { h _ { G } }$ is supposed to be fixed to fit into the classifier. Second, $\\mathrm { g } ( \\cdot )$ should output the same $_ { h _ { G } }$ when the order of rows of $\\pmb { H }$ changes. This permutation invariance property is necessary to handle isomorphic graphs. To be concrete, if two graph $\\mathcal { G } _ { 1 } = ( A _ { 1 } , X _ { 1 } )$ and $\\mathcal { G } _ { 2 } = ( A _ { 2 } , X _ { 2 } )$ are isomorphic, GNNs will output the same multi set of node representations. That is, there exists a permutation matrix $P \\in \\{ 0 , \\bar { 1 } \\bar  \\} ^ { n \\times n }$ such that $H _ { 1 } = P H _ { 2 }$ , for $\\pmb { H } _ { 1 } = \\mathbf { G } \\mathbf { N } \\mathbf { N } ( \\pmb { A } _ { 1 } , \\pmb { X } _ { 1 } )$ and $H _ { 2 } = \\mathrm { G N N } ( A _ { 2 } , X _ { 2 } )$ . However, the graph representation computed by $\\mathrm { g } ( \\cdot )$ should be the same, i.e., $\\begin{array} { r } { \\mathrm { g } ( \\pmb { H } _ { 1 } ) = \\mathrm { g } ( \\pmb { H } _ { 2 } ) } \\end{array}$ if ${ \\cal H } _ { 1 } = { \\cal P } { \\cal H } _ { 2 }$ . ",
+        "bbox": [
+            173,
+            378,
+            825,
+            518
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 NEURAL POOLING METHOD 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            421,
+            550
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our first proposed method is called Neural Pooling Method 1. Consider a node representation matrix $\\pmb { H }$ obtained following Equation 1 in Section 3.1. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a464ce1dec9d058abdf8c5f8e85f74243f223cbe400ccb32842325b50311b2a.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of our proposed Neural Pooling Method 1. This is an example for a graph $\\mathcal { G }$ with 8 nodes. GNNs can learn representations for each node and graph pooling processes node representations into a graph representation vector. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            606,
+            821,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\pmb { H }$ is passed through a Fully Connected Neural Network Layer $( F C L ^ { 1 } )$ to obtain $H ^ { \\prime }$ as: ",
+        "bbox": [
+            173,
+            849,
+            754,
+            866
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/afb9bc776dc6d353d908d7aa49441af8c96086e0f5d11dc6577ff3ec97d449c1.jpg",
+        "text": "$$\n\\pmb { H } ^ { \\prime } = F C L ^ { 1 } ( \\pmb { H } ) \\in \\mathbb { R } ^ { n \\times \\textit { f } ^ { \\prime } } \\mathrm { \\bf ~ w h e r e ~ } f ^ { \\prime } < f\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            871,
+            638,
+            890
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After this $H ^ { \\prime }$ is again passed through a second Fully Connected Neural Network Layer $( F C L ^ { 2 } )$ to obtain $Q$ as: ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db9a17d042786f0794253023f537953d0679c744769e7e7a0bf295516cb76858.jpg",
+        "text": "$$\nQ = F C L ^ { 2 } ( H ^ { \\prime } ) \\in \\mathbb { R } ^ { n \\times 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            102,
+            581,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally the graph representation $h _ { G }$ is obtained as: ",
+        "bbox": [
+            173,
+            125,
+            508,
+            140
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f027a5ab7d3356ee216a469dcb56f4346b6bc75e4a99975596751ecb5c2cd97c.jpg",
+        "text": "$$\n\\pmb { h } _ { G } = \\pmb { H } ^ { \\prime T } \\pmb { Q } \\in \\mathbb { R } ^ { f ^ { \\prime } \\times 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            145,
+            584,
+            164
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $H ^ { \\prime T }$ denotes the transpose of $H ^ { \\prime }$ . ",
+        "bbox": [
+            176,
+            169,
+            442,
+            184
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Neural Pooling Method 1 always outputs an $f ^ { \\prime }$ -dimensional graph representation for $\\ b { H } \\in \\mathbb { R } ^ { n \\times f }$ , regardless of the value of $\\mathbf { n }$ . It is also invariant to permutation so that it outputs the same graph representation, even when the order of rows of $\\pmb { H }$ changes. ",
+        "bbox": [
+            174,
+            190,
+            825,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuition: The $F C L ^ { 1 }$ performs the role of reducing the dimensionality of the input node representations. The trainable parameters of this $F C L ^ { 1 }$ can be thought of as learning a mapping from the $f$ to the $f ^ { \\prime }$ -dimensional space. The $F C L ^ { 2 }$ reduces the $f ^ { \\prime }$ -dimensional node representations to a 1 dimensional representation, $Q$ . $\\pmb { H } ^ { \\prime } \\in \\mathbb { R } ^ { n \\times \\ f ^ { \\prime } }$ can be viewed as $H ^ { \\prime } = [ l _ { 1 } , l _ { 2 } , \\ldots \\ldots , l _ { f ^ { \\prime } } ] .$ , where $l _ { j }$ $\\in \\mathbb { R } ^ { n }$ , $j { = } 1 , 2 , . . . , f ^ { \\prime }$ . The vector $l _ { j }$ encodes the spatial distribution of the $j$ -th feature in the graph. Based on this view, $H ^ { \\prime T } \\pmb { Q }$ is able to capture the topology information and $Q$ can be thought of as roughly encoding the position of nodes by learning the weights according to which the $j$ -th feature is aggregated across the nodes. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Neural Pooling Method 1 hence, leverages the ability of neural networks to learn the topological structure as well as correlation among the node representations in $\\pmb { H }$ . It captures the essential features and connections between underlying data. It also reduces the dimensionality of $\\pmb { H }$ , and results in an accurate representation of the input graph. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 NEURAL POOLING METHOD 2 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            444,
+            423,
+            458
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our second proposed method is called Neural Pooling Method 2. Consider a node representation matrix $\\pmb { H }$ obtained following Equation 1 in Section 3.1. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/550267784e0cc753e84314e02422fdc4a7e97d7ea04f2d5dfefc8ec628a99301.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of our proposed Neural Pooling Method 2. This is an example for a graph $\\mathcal { G }$ with 8 nodes. GNNs can learn representations for each node and graph pooling processes node representations into a graph representation vector. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            526,
+            825,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\pmb { H }$ is passed through a Fully Connected Neural Network Layer $( F C L ^ { 1 } )$ to obtain $H ^ { \\prime \\prime }$ as: ",
+        "bbox": [
+            171,
+            761,
+            758,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0c5d4dcc44d8a28a77aff2516cf9d0ad2cf7dca647215c04576008863aaaf5ff.jpg",
+        "text": "$$\n\\pmb { H } ^ { \\prime \\prime } = F C L ^ { 1 } ( \\pmb { H } ) \\in \\mathbb { R } ^ { n \\times \\textit { f } ^ { \\prime \\prime } } \\mathrm { \\bf ~ w h e r e ~ } f ^ { \\prime \\prime } < f\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            782,
+            648,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After this $H ^ { \\prime \\prime }$ is again passed through a second Fully Connected Neural Network Layer $( F C L ^ { 2 } )$ to obtain $H ^ { \\prime }$ as: ",
+        "bbox": [
+            173,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/352336bc9f1aed75e05b0dcc419cb7ff2725bff68a01a174f7f98431cf21dd54.jpg",
+        "text": "$$\n\\pmb { H } ^ { \\prime } = F C L ^ { 2 } ( \\pmb { H } ^ { \\prime \\prime } ) \\in \\mathbb { R } ^ { n \\times \\textit { f } ^ { \\prime } } \\mathrm { w h e r e } \\ f ^ { \\prime } < f ^ { \\prime \\prime }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            838,
+            655,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally the graph representation $h _ { G }$ is obtained as: ",
+        "bbox": [
+            173,
+            863,
+            508,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec05fbc2b7a0fdddb912f8a255b58678bb87265c539590b3db744c38987d5c5a.jpg",
+        "text": "$$\n\\pmb { h } _ { G } = \\mathrm { F l a t t e n } ( \\pmb { H } ^ { \\prime T } \\pmb { H } ^ { \\prime } ) \\in \\mathbb { R } ^ { f ^ { 2 } \\times 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            883,
+            630,
+            904
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $H ^ { \\prime T }$ denotes the transpose of $H ^ { \\prime }$ . ",
+        "bbox": [
+            176,
+            909,
+            442,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuition: The $F C L ^ { 1 }$ performs the role of reducing the dimensionality of the input node representations. The trainable parameters of this $F C L ^ { 1 }$ can be thought of as learning a mapping from the $f$ to the $f ^ { \\prime \\prime }$ -dimensional space. The $F C L ^ { 2 }$ further reduces the $f ^ { \\prime \\prime }$ -dimensional node representations to a $f ^ { \\prime }$ dimensional representation. $\\pmb { H } ^ { \\prime } \\in \\mathbb { R } ^ { n \\times \\textit { f } ^ { \\prime } }$ can be viewed as $H ^ { \\prime } = [ l _ { 1 } , l _ { 2 } , \\dots \\dots , l _ { f ^ { \\prime } } ]$ , where $\\boldsymbol { l } _ { j } \\in \\mathbb { R } ^ { n }$ , $j { = } 1 , 2 , . . . , f ^ { \\prime }$ . The vector $l _ { j }$ encodes the spatial distribution of the $j$ -th feature in the graph. Based on this view, ${ \\pmb { H } } ^ { \\prime T } { \\pmb { H } } ^ { \\prime }$ is able to capture the topology information. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar to the previous method, Neural Pooling Method 2 satisfies both the conditions of graph pooling which is that it always outputs an $f ^ { \\prime 2 }$ -dimensional graph representation for $H \\in \\mathbb { R } ^ { \\breve { n } \\times ^ { \\bullet } } $ , regardless of the value of $n$ . It is also invariant to permutation so that it outputs the same graph representation when the order of rows of $\\pmb { H }$ changes. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            253
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            275,
+            398,
+            291
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We perform experiments on graph classification tasks in the bio-informatics and social network domains to demonstrate the effectiveness and superiority of our proposed methods, namely Neural Pooling Methods 1 and 2. Details of datasets and parameter settings are described below. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            368,
+            287,
+            382
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use nine graph classification datasets from (Yanardag & Vishwanathan, 2015), including four bioinformatics datasets and five social network datasets. Only bioinformatics datasets come with node labels. For the social network datasets, we use one-hot encoding of node degrees as features. The details of the datasets are summarized in Table 1 and Table 2. ",
+        "bbox": [
+            176,
+            395,
+            825,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• MUTAG (Debnath et al., 1991) is a bioinformatics dataset of 188 graphs representing nitro compounds. The task is to classify each graph by determining whether the compound is mutagenic aromatic or heteroaromatic.   \n• PTC (Toivonen et al., 2003) is a bioinformatics dataset of 344 graphs representing chemical compounds. Each node comes with one of 19 discrete node labels. The task is to predict the rodent carcinogenicity for each graph.   \nPROTEINS (Borgwardt et al., 2005) is a bioinformatics dataset of 1,113 graph structures of proteins. Nodes in the graphs refer to secondary structure elements (SSEs) and have discrete node labels indicating whether they represent a helix, sheet or turn. And edges mean that two nodes are neighbors along the amino-acid sequence or in space. The task is to predict the protein function for each graph.   \nNCI1 (Wale et al., 2008) is a bioinformatics dataset of 4,110 graphs representing chemical compounds. The graph classification label is decided by anti-cancer screens for ability to suppress or inhibit the growth of a panel of human tumor cell lines.   \n• COLLAB is a scientific collaboration dataset of 5,000 graphs corresponding to egonetworks.The dataset is derived from 3 public collaboration datasets (Leskovec et al., 2005). Each ego-network contains different researchers from each field and is labeled by the corresponding field. The three fields are High Energy Physics, Condensed Matter Physics, and Astro Physics.   \nIMDB-BINARY is a movie collaboration dataset of 1,000 graphs representing egonetworks for actors/actresses. The dataset is derived from collaboration graphs on Action and Romance genres. In each graph, nodes represent actors/actresses and edges simply mean they collaborate the same movie. The graphs are labeled by the corresponding genre and the task is to identify the genre for each graph.   \nIMDB-MULTI is multi-class version of IMDB-BINARY. It contains 1,500 ego-networks and has three extra genres, namely, Comedy, Romance and Sci-Fi.   \n• REDDIT-BINARY is a dataset of 2,000 graphs where each graph represents an online discussion thread. Nodes in a graph correspond to users appearing in the corresponding discussion thread and an edge means that one user responded to another. TrollXChromosomes and atheism are discussion-based subreddits, forming two classes to be classified. ",
+        "bbox": [
+            217,
+            460,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/0629ea85045624b2b28500cbe470ebe80895a908e72b07a1f654377d2a75326a.jpg",
+        "table_caption": [
+            "Table 1: Details of bioinformatics datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name</td><td>MUTAG</td><td>PTC PROTEINS</td><td>NCI1</td></tr><tr><td># graphs</td><td>188 344</td><td>1113</td><td>4110</td></tr><tr><td># classes</td><td>2 2</td><td>2</td><td>2</td></tr><tr><td># nodes(max)</td><td>28 109</td><td>620</td><td>111</td></tr><tr><td># nodes(avg.)</td><td>18.0 25.6</td><td>39.1</td><td>29.9</td></tr></table>",
+        "bbox": [
+            312,
+            130,
+            686,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/61dc99362960f87758fd74892c25bd8b01c26b592b970ad2065b1803db15b94f.jpg",
+        "table_caption": [
+            "Table 2: Details of social network datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name</td><td>COLLAB IMDB-B</td><td>IMDB-M</td><td>RDT-B</td><td>RDT-M5K</td></tr><tr><td># graphs</td><td>5000 1000</td><td>1500</td><td>2000</td><td>5000</td></tr><tr><td># classes</td><td>3 2</td><td>3</td><td>2</td><td>5</td></tr><tr><td># nodes(max)</td><td>492 136</td><td>89</td><td>3783</td><td>3783</td></tr><tr><td># nodes(avg.)</td><td>74.5 19.8</td><td>13.0</td><td>429.6</td><td>508.5</td></tr></table>",
+        "bbox": [
+            251,
+            286,
+            746,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• REDDIT-MULTI5K is a similar dataset as REDDIT- BINARY, which contains 5,000 graphs. The difference lies in that REDDIT-MULTI5K crawled data from five different subreddits, namely, worldnews, videos, AdviceAnimals, aww and mildlyinteresting. And the task is to identify the subreddit of each graph instead of determining the type of subreddits. ",
+        "bbox": [
+            218,
+            428,
+            825,
+            498
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 TRAINING AND EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            415,
+            537
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Following (Yanardag & Vishwanathan, 2015; Niepert et al., 2016), model performance is evaluated using 10-fold cross-validation and reported as the average and standard deviation of validation accuracies across the 10 folds. For GNNs, we follow the same training process in (Xu et al., 2019). The GNN has 5 layers. Each multi-layer perceptron (MLP) has 2 layers with batch normalization (Ioffe & Szegedy, 2015). Dropout (Srivastava et al., 2014) is applied in the classifiers. The Adam (Kingma & Ba, 2015) optimizer is used with the learning rate initialized as 0.01 and decayed by 0.5 every 50 epochs. The number of total epochs is selected according to the best cross-validation accuracy. We tune the number of hidden units (16, 32, 64) and the batch size (32, 128) using grid search. ",
+        "bbox": [
+            173,
+            547,
+            825,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            690,
+            294,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare our methods with various other graph pooling methods on the graph classification task, including DIFFPOOL (Ying et al., 2018), SORT-POOL (Zhang et al., 2018), TOPKPOOL (Gao & Ji, 2019), SAGPOOL (Lee et al., 2019), and EIGEN-POOL (Ma et al., 2019b). DIFFPOOL maps nodes to a pre-defined number of clusters but is hard to train. EIGENPOOL involves the computation of eigenvectors, which is slow and expensive. SORTPOOL, SAGPOOL and TOPKPOOL rely on the top-K sorting to select a fixed number (K) of nodes and order them, during which the information from unselected nodes is discarded. We also compare with some recent methods including COVPOOL (Wang et al., 2019a), ATTNPOOL (Girdhar & Ramanan, 2017) as well as second order pooling methods $\\mathbf { S O P o o l } _ { b i m a p }$ and SOPoolattention (Wang & Ji, 2020). ",
+        "bbox": [
+            173,
+            717,
+            825,
+            843
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS & DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            863,
+            411,
+            880
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results of our experiments are summarized in Table 3 and Table 4 .From the results we can see that our methods lead to an improvement in classification accuracy over existing methods and are also more reliable as compared previous works as observed from the lower values of standard deviation.This enhancement in performance is consistent across all the datasets. The results may be attributed to the fact that compared to existing graph pooling methods, our pooling methods are able to use information from all nodes, collect second-order statistics, and leverage the ability of neural networks to learn from underlying data, making them more powerful. The Neural Pooling methods utilize the ability of neural networks to learn the topological structure as well as correlation among the node representations in, capturing essential features and connections between underlying data. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/38566588002cdcca225cf0ae785694088391e0c9bf5a8ea7a370ced3ae3e83fa.jpg",
+        "table_caption": [
+            "Table 3: Comparison results of our proposed methods with other graph pooling methods on bioinformatics datasets. Results shown are the average classification accuracy and standard deviation across 10-fold cross-validation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>PTC</td><td rowspan=1 colspan=1>PROTEINS</td><td rowspan=1 colspan=1>MUTAG</td><td rowspan=1 colspan=1>NCI1</td></tr><tr><td rowspan=1 colspan=1>SUM/AVG(Xu et al., 2019)</td><td rowspan=1 colspan=1>64.6 ± 7.0</td><td rowspan=1 colspan=1>76.2 ± 2.8</td><td rowspan=1 colspan=1>89.4 ±5.6</td><td rowspan=1 colspan=1>82.7 ± 1.7</td></tr><tr><td rowspan=1 colspan=1>DIFFPOOL(Ying et al., 2018)</td><td rowspan=1 colspan=1>66.1 ± 7.7</td><td rowspan=1 colspan=1>78.8± 3.1</td><td rowspan=1 colspan=1>94.8± 4.8</td><td rowspan=1 colspan=1>76.6 ± 1.3</td></tr><tr><td rowspan=1 colspan=1>SORTPOOL(Zhang et al., 2018)</td><td rowspan=1 colspan=1>69.5± 6.3</td><td rowspan=1 colspan=1>79.2 ± 3.0</td><td rowspan=1 colspan=1>95.2 ± 3.9</td><td rowspan=1 colspan=1>78.9 ± 2.7</td></tr><tr><td rowspan=1 colspan=1>TOPKPOOL(Gao &amp; Ji, 2019)</td><td rowspan=1 colspan=1>68.4 ± 6.4</td><td rowspan=1 colspan=1>79.1 ± 2.2</td><td rowspan=1 colspan=1>94.7± 3.5</td><td rowspan=1 colspan=1>79.6 ± 1.7</td></tr><tr><td rowspan=1 colspan=1>SAGPOOL(Lee et al., 2019)</td><td rowspan=1 colspan=1>69.0 ± 6.6</td><td rowspan=1 colspan=1>78.4± 3.1</td><td rowspan=1 colspan=1>93.9 ± 3.3</td><td rowspan=1 colspan=1>79.0 ± 2.8</td></tr><tr><td rowspan=1 colspan=1>ATTNPOOL(Girdhar &amp; Ramanan, 2017)</td><td rowspan=1 colspan=1>71.2± 8.0</td><td rowspan=1 colspan=1>77.5± 3.3</td><td rowspan=1 colspan=1>93.2± 5.8</td><td rowspan=1 colspan=1>80.6± 2.1</td></tr><tr><td rowspan=1 colspan=1>EIGENPOOL(Ma et al.,2019b)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>76.6± 2.3</td><td rowspan=1 colspan=1>80.6± 4.3</td><td rowspan=1 colspan=1>77.0 ± 2.3</td></tr><tr><td rowspan=1 colspan=1>COVPOOL(Wang et al.,2019a)</td><td rowspan=1 colspan=1>73.3 ± 5.1</td><td rowspan=1 colspan=1>80.1 ± 2.2</td><td rowspan=1 colspan=1>95.3 ± 3.7</td><td rowspan=1 colspan=1>83.5 ± 1.9</td></tr><tr><td rowspan=1 colspan=1>SOPOOLattn(Wang &amp; Ji, 2020)</td><td rowspan=1 colspan=1>72.9 ± 6.2</td><td rowspan=1 colspan=1>79.4 ± 3.2</td><td rowspan=1 colspan=1>93.6 ± 4.1</td><td rowspan=1 colspan=1>82.8± 1.4</td></tr><tr><td rowspan=1 colspan=1> SOPOOLbimap(Wang &amp; Ji, 2020)</td><td rowspan=1 colspan=1>75.0 ± 4.3</td><td rowspan=1 colspan=1>80.1 ± 2.7</td><td rowspan=1 colspan=1>95.3 ± 4.4</td><td rowspan=1 colspan=1>83.6 ± 1.4</td></tr><tr><td rowspan=1 colspan=1>Neural Pooling 1(ours)</td><td rowspan=1 colspan=1>74.5 ± 3.7</td><td rowspan=1 colspan=1>80.6 ± 2.7</td><td rowspan=1 colspan=1>94.0 ± 2.3</td><td rowspan=1 colspan=1>83.1 ± 1.2</td></tr><tr><td rowspan=1 colspan=1>Neural Pooling 2(ours)</td><td rowspan=1 colspan=1>76.2 ± 4.2</td><td rowspan=1 colspan=1>79.6± 3.0</td><td rowspan=1 colspan=1>95.5 ± 2.4</td><td rowspan=1 colspan=1>83.4 ± 1.9</td></tr></table>",
+        "bbox": [
+            173,
+            170,
+            828,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f7722e0e1e59d95930c686b0361cb0094f3ce68cef19da9cc88b9feb65dc0616.jpg",
+        "table_caption": [
+            "Table 4: Comparison results of our proposed methods with other graph pooling methods on social network datsets. Results shown are the average classification accuracy and standard deviation across 10-fold cross-validation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>COLLAB</td><td rowspan=1 colspan=1>RDT-B</td><td rowspan=1 colspan=1>IMDB-B</td><td rowspan=1 colspan=1>IMDB-M</td><td rowspan=1 colspan=1>RDT-M5K</td></tr><tr><td rowspan=1 colspan=1> SUM/AVG</td><td rowspan=1 colspan=1>80.2 ± 1.9</td><td rowspan=1 colspan=1>92.4 ± 2.5</td><td rowspan=1 colspan=1>75.1 ± 5.1</td><td rowspan=1 colspan=1>52.3 ± 2.8</td><td rowspan=1 colspan=1>57.5 ± 1.5</td></tr><tr><td rowspan=1 colspan=1>DIFFPOOL</td><td rowspan=1 colspan=1>75.3 ± 2.2</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>74.4 ± 4.0</td><td rowspan=1 colspan=1>50.1 ± 3.2</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>SORTPOOL</td><td rowspan=1 colspan=1>78.2 ± 1.6</td><td rowspan=1 colspan=1>81.6 ± 4.6</td><td rowspan=1 colspan=1>77.5± 2.7</td><td rowspan=1 colspan=1>53.1 ± 2.9</td><td rowspan=1 colspan=1>48.4± 4.8</td></tr><tr><td rowspan=1 colspan=1>TOPKPOOL</td><td rowspan=1 colspan=1>79.6 ± 2.1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>77.8 ± 5.1</td><td rowspan=1 colspan=1>53.7 ± 2.8</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>SAGPOOL</td><td rowspan=1 colspan=1>78.9 ± 1.7</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>77.8 ± 2.9</td><td rowspan=1 colspan=1>53.1 ± 2.8</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>ATTNPOOL</td><td rowspan=1 colspan=1>81.8± 2.2</td><td rowspan=1 colspan=1>92.5± 2.3</td><td rowspan=1 colspan=1>77.1 ± 4.4</td><td rowspan=1 colspan=1>53.8 ± 2.5</td><td rowspan=1 colspan=1>57.9 ± 1.7</td></tr><tr><td rowspan=1 colspan=1>COVPOOL</td><td rowspan=1 colspan=1>79.3 ± 1.8</td><td rowspan=1 colspan=1>90.3± 3.6</td><td rowspan=1 colspan=1>72.1± 5.1</td><td rowspan=1 colspan=1>47.8 ± 2.7</td><td rowspan=1 colspan=1>58.4±1.7</td></tr><tr><td rowspan=1 colspan=1>SOPOOLattn</td><td rowspan=1 colspan=1>81.1 ± 1.8</td><td rowspan=1 colspan=1>91.7 ± 2.7</td><td rowspan=1 colspan=1>78.1 ± 4.0</td><td rowspan=1 colspan=1>54.3± 2.6</td><td rowspan=1 colspan=1>58.3 ± 1.4</td></tr><tr><td rowspan=1 colspan=1>SOPOOLbimap</td><td rowspan=1 colspan=1>79.9 ± 1.9</td><td rowspan=1 colspan=1>89.6±3.3</td><td rowspan=1 colspan=1>78.4± 4.7</td><td rowspan=1 colspan=1>54.6± 3.6</td><td rowspan=1 colspan=1>58.4 ± 1.6</td></tr><tr><td rowspan=1 colspan=1>Neural Pooling 1(ours)</td><td rowspan=1 colspan=1>80.5± 1.5</td><td rowspan=1 colspan=1>90.6± 2.3</td><td rowspan=1 colspan=1>79.0 ± 2.3</td><td rowspan=1 colspan=1>55.1± 2.2</td><td rowspan=1 colspan=1>58.5 ± 1.8</td></tr><tr><td rowspan=1 colspan=1>Neural Pooling 2(ours)</td><td rowspan=1 colspan=1>81.0 ± 1.7</td><td rowspan=1 colspan=1>91.5 ± 3.0</td><td rowspan=1 colspan=1>78.5 ± 2.4</td><td rowspan=1 colspan=1>54.4 ± 1.9</td><td rowspan=1 colspan=1>59.1 ± 1.4</td></tr></table>",
+        "bbox": [
+            187,
+            531,
+            810,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 COMPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Consider a graph $\\mathcal { G } = ( A , X )$ represented by its adjacency matrix $\\pmb { A } \\in \\{ 0 , 1 \\} ^ { n \\times n }$ and node feature matrix $\\ b { X } \\in \\ b { \\mathbb { R } ^ { n } } \\times \\ b { d }$ , where $n$ is the number of nodes in $\\mathcal { G }$ and $d$ is the dimension of node features. Consider, $H = [ h _ { 1 } , h _ { 2 }$ , ........., $\\pmb { h } _ { n } ] ^ { T } = \\mathbf { G } \\mathbf { N } \\mathbf { N } ( \\pmb { A } , \\pmb { X } ) \\in \\mathbb { R } ^ { n \\times \\pmb { f } }$ where rows of $\\pmb { H }$ , $\\boldsymbol { h } _ { i } \\in \\mathbb { R } ^ { f }$ , $i$ $= 1 , 2 , . . . , n$ , are representations of $n$ nodes. Consider a direct application of second-order graph pooling to obtain the graph representation $h _ { G }$ as: ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2afe3ed0441771cba0c087de5c28d916cb44ab4188718a1b75e950ce2c058ee.jpg",
+        "text": "$$\n\\pmb { h } _ { G } = \\mathrm { F l a t t e n } ( \\pmb { H } ^ { T } \\pmb { H } ) \\in \\mathbb { R } ^ { f ^ { 2 } \\times 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            209,
+            619,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $H ^ { T }$ denotes the transpose of $\\pmb { H }$ ",
+        "bbox": [
+            176,
+            234,
+            433,
+            250
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "However, it causes an explosion in the number of training parameters in the following classifier when $f$ is large, making the learning process harder to converge and easier to overfit. While each layer in a GNN usually has outputs with a small number of hidden units (e.g. 16, 32, 64), it has been pointed out that graph representation learning benefits from using information from outputs of all layers, obtaining better performance and generalization ability. It is usually achieved by concatenating outputs across all layers in a GNN. In this case, $\\pmb { H }$ has a large final $f$ , making direct use of secondorder pooling infeasible. For example, if a GNN has 5 layers and each layer’s outputs have 32 hidden units, $f$ becomes $3 2 \\times 5 = 1 6 0$ . Suppose $h _ { G }$ is sent into a 1-layer fully-connected classifier for $c$ graph categories in a graph classification task. It results in $1 6 0 ^ { \\dot { 2 } } c = 2 \\dot { 5 } , 6 0 0 c$ training parameters, which is excessive. We omit the bias term for simplicity. On the other hand, both of our proposed novel graph pooling methods significantly reduce the number of training parameters. In the case of Neural Pooling Method 1, considering the previous example if $f ^ { \\prime }$ is chosen to be 64, and $f$ is 160, then the total number of trainable parameters in the $2 ~ F C L s$ and a 1-layer fully-connected $c$ class classifier will be $( 1 6 0 \\times 6 4 ) + 6 4 + 6 4 c = 1 0 , 3 0 4 + 6 4 c$ notably reducing the number of parameters as compared to 25, $6 0 0 c$ . In the case of Neural Pooling Method 2, if $f ^ { \\prime \\bar { \\prime } }$ is chosen to be 64, $f ^ { \\prime }$ as 32 and $f$ is 160, then the total number of trainable parameters in the $2 \\ : F C L s$ and a 1-layer fully-connected $c$ class classifier will be $( 1 6 0 \\times 6 4 ) + ( 6 4 \\times 3 2 ) + 3 2 2 c = 1 2 , 2 8 8 + 1 0 2 4 c$ again reducing the number of parameters when compared to $2 5 , 6 0 0 c$ . ",
+        "bbox": [
+            173,
+            257,
+            825,
+            506
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            318,
+            544
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose to perform graph representation learning with Neural Pooling, by pointing out that Neural Pooling can naturally solve the challenges of graph pooling. Neural Pooling is more powerful than existing graph pooling methods, since it is capable of using all node information, collecting second-order statistics that encode feature correlations and topology information and leverage the ability of neural networks to learn from underlying data, making them more powerful. Our proposed methods solve the practical problems incurred by directly using second-order pooling with GNNs. To demonstrate the effectiveness and superiority of our methods, we perform experiments on graph classification tasks in the bio-informatics and social network domains to demonstrate the effectiveness and superiority of our proposed methods. Experimental results show that our methods improve the performance significantly and consistently. An interesting future work direction could be to extend our methods for hierarchical graph pooling, where the output is a is a pseudo graph with fewer nodes than the input graph. It is used to build hierarchical GNNs, where hierarchical graph pooling is used several times between GNN layers to gradually decrease the number of nodes. ",
+        "bbox": [
+            173,
+            560,
+            825,
+            741
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            285,
+            779
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "KM Borgwardt, Stefan Schonauer, SVN Vishwanathan, Alexander Smola, and HP Kriegel. Protein ¨ function prediction via graph kernels. Bioinformatics, 21 Suppl 1:i47–56, 01 2005. ",
+        "bbox": [
+            174,
+            787,
+            823,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Y-Lan Boureau, Jean Ponce, and Yann LeCun. A theoretical analysis of feature pooling in visual recognition. In Johannes Furnkranz and Thorsten Joachims (eds.), ¨ Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 111–118, Haifa, Israel, June 2010. Omnipress. URL http://www.icml2010.org/papers/638.pdf. ",
+        "bbox": [
+            176,
+            828,
+            825,
+            883
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Asim Kumar Debnath, Rosa L Lopez de Compadre, Gargi Debnath, Alan J Shusterman, and Corwin Hansch. Structure-activity relationship of mutagenic aromatic and heteroaromatic nitro compounds. correlation with molecular orbital energies and hydrophobicity. Journal of medicinal chemistry, 34(2):786–797, 1991. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            181,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In Daniel D. Lee, Masashi Sugiyama, Ulrike von Luxburg, Isabelle Guyon, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5- 10, 2016, Barcelona, Spain, pp. 3837–3845, 2016. ",
+        "bbox": [
+            174,
+            142,
+            825,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 2224–2232. Curran Associates, Inc., 2015. ",
+        "bbox": [
+            173,
+            223,
+            825,
+            292
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wenqi Fan, Yao Ma, Qing Li, Yuan He, Eric Zhao, Jiliang Tang, and Dawei Yin. Graph neural networks for social recommendation. In The World Wide Web Conference, WWW ’19, pp. 417–426, New York, NY, USA, 2019. Association for Computing Machinery. ISBN 9781450366748. doi: 10.1145/3308558.3313488. URL https://doi.org/10.1145/3308558.3313488. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            361
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hongchang Gao, Jian Pei, and Heng Huang. Conditional random field enhanced graph convolutional neural networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD ’19, pp. 276–284, New York, NY, USA, 2019. Association for Computing Machinery. ISBN 9781450362016. doi: 10.1145/3292500.3330888. URL https://doi.org/10.1145/3292500.3330888. ",
+        "bbox": [
+            173,
+            369,
+            825,
+            440
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hongyang Gao and Shuiwang Ji. Graph u-nets. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9- 15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 2083–2092. PMLR, 2019. URL http://proceedings.mlr.press/v97/ gao19a.html. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            521
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research, pp. 1263–1272. PMLR, 2017. URL http://proceedings.mlr.press/v70/gilmer17a.html. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            602
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rohit Girdhar and Deva Ramanan. Attentional pooling for action recognition. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, 4-9 December 2017, Long Beach, CA, USA, pp. 34–45, 2017. URL http://papers.nips.cc/paper/ 6609-attentional-pooling-for-action-recognition. ",
+        "bbox": [
+            173,
+            612,
+            825,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 1024–1034. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 6703-inductive-representation-learning-on-large-graphs.pdf. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Francis R. Bach and David M. Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, volume 37 of JMLR Workshop and Conference Proceedings, pp. 448–456. JMLR.org, 2015. URL http://proceedings.mlr.press/v37/ioffe15.html. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            858
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Yoshua Bengio and Yann LeCun (eds.), 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http: //arxiv.org/abs/1412.6980. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017. URL https: //openreview.net/forum?id $=$ SJU4ayYgl. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junhyun Lee, Inyeop Lee, and Jaewoo Kang. Self-attention graph pooling. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 3734–3743. PMLR, 2019. URL http://proceedings. mlr.press/v97/lee19c.html. ",
+        "bbox": [
+            173,
+            167,
+            825,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jure Leskovec, Jon Kleinberg, and Christos Faloutsos. Graphs over time: densification laws, shrinking diameters and possible explanations. In Proceedings of the eleventh ACM SIGKDD international conference on Knowledge discovery in data mining, pp. 177–187, 2005. ",
+        "bbox": [
+            173,
+            247,
+            825,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianxin Ma, Peng Cui, Kun Kuang, Xin Wang, and Wenwu Zhu. Disentangled graph convolutional networks. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 4212–4221. PMLR, 2019a. URL http://proceedings.mlr.press/v97/ma19a.html. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            369
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yao Ma, Suhang Wang, Charu C. Aggarwal, and Jiliang Tang. Graph convolutional networks with eigenpooling. KDD ’19, pp. 723–731, New York, NY, USA, 2019b. Association for Computing Machinery. ISBN 9781450362016. doi: 10.1145/3292500.3330982. URL https://doi. org/10.1145/3292500.3330982. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            434
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural networks for graphs. In Maria-Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, volume 48 of JMLR Workshop and Conference Proceedings, pp. 2014–2023. JMLR.org, 2016. URL http://proceedings.mlr.press/v48/niepert16.html. ",
+        "bbox": [
+            173,
+            443,
+            826,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15(1): 1929–1958, 2014. URL http://dl.acm.org/citation.cfm?id=2670313. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            565
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hannu Toivonen, Ashwin Srinivasan, Ross D. King, Stefan Kramer, and Christoph Helma. Statistical evaluation of the Predictive Toxicology Challenge 2000–2001. Bioinformatics, 19(10): 1183–1193, 07 2003. ISSN 1367-4803. doi: 10.1093/bioinformatics/btg130. URL https: //doi.org/10.1093/bioinformatics/btg130. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li ´ o, and Yoshua \\` Bengio. Graph attention networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $=$ rJXMpikCZ. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            681
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nikil Wale, Ian A Watson, and George Karypis. Comparison of descriptor spaces for chemical compound retrieval and classification. Knowledge and Information Systems, 14(3):347–375, 2008. ",
+        "bbox": [
+            169,
+            689,
+            821,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Qilong Wang, Jiangtao Xie, Wangmeng Zuo, Lei Zhang, and Peihua Li. Deep cnns meet global covariance pooling: Better representation and generalization. CoRR, abs/1904.06836, 2019a. URL http://arxiv.org/abs/1904.06836. ",
+        "bbox": [
+            174,
+            727,
+            823,
+            770
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiao Wang, Houye Ji, Chuan Shi, Bai Wang, Yanfang Ye, Peng Cui, and Philip S Yu. Heterogeneous graph attention network. In The World Wide Web Conference, WWW ’19, pp. 2022–2032, New York, NY, USA, 2019b. Association for Computing Machinery. ISBN 9781450366748. doi: 10.1145/3308558.3313562. URL https://doi.org/10.1145/3308558.3313562. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Z. Wang and S. Ji. Second-order pooling for graph neural networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020. ",
+        "bbox": [
+            171,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. In Jennifer G. Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018 ¨ , volume 80 of Proceedings of Machine Learning Research, pp. 5449–5458. PMLR, 2018. URL http://proceedings.mlr.press/v80/xu18c.html. ",
+        "bbox": [
+            186,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $=$ ryGs6iA5Km. ",
+        "bbox": [
+            178,
+            155,
+            820,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pinar Yanardag and S.V.N. Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’15, pp. 1365–1374, New York, NY, USA, 2015. Association for Computing Machinery. ISBN 9781450336642. doi: 10.1145/2783258.2783417. URL https://doi.org/10.1145/ 2783258.2783417. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhitao Ying, Jiaxuan You, Christopher Morris, Xiang Ren, William L. Hamilton, and Jure Leskovec. Hierarchical graph representation learning with differentiable pooling. In Samy Bengio, Hanna M. Wallach, Hugo Larochelle, Kristen Grauman, Nicolo Cesa-Bianchi, and Roman Garnett (eds.), \\` Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, 3-8 December 2018, Montreal, Canada ´ , pp. 4805–4815, 2018. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            369
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. AAAI, 2018. ",
+        "bbox": [
+            171,
+            378,
+            823,
+            409
+        ],
+        "page_idx": 10
+    }
+]

parse/train/Z2vksUFuVst/Z2vksUFuVst_content_list.json

@@ -0,0 +1,1561 @@
+[
+    {
+        "type": "text",
+        "text": "Conservative Offline Distributional Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            285,
+            122,
+            710,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yecheng Jason Ma, Dinesh Jayaraman, Osbert Bastani University of Pennsylvania {jasonyma, dineshj, obastani}@seas.upenn.edu ",
+        "bbox": [
+            307,
+            226,
+            687,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            303,
+            535,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many reinforcement learning (RL) problems in practice are offline, learning purely from observational data. A key challenge is how to ensure the learned policy is safe, which requires quantifying the risk associated with different actions. In the online setting, distributional RL algorithms do so by learning the distribution over returns (i.e., cumulative rewards) instead of the expected return; beyond quantifying risk, they have also been shown to learn better representations for planning. We propose Conservative Offline Distributional Actor Critic (CODAC), an offline RL algorithm suitable for both risk-neutral and risk-averse domains. CODAC adapts distributional RL to the offline setting by penalizing the predicted quantiles of the return for out-of-distribution actions. We prove that CODAC learns a conservative return distribution—in particular, for finite MDPs, CODAC converges to an uniform lower bound on the quantiles of the return distribution; our proof relies on a novel analysis of the distributional Bellman operator. In our experiments, on two challenging robot navigation tasks, CODAC successfully learns risk-averse policies using offline data collected purely from risk-neutral agents. Furthermore, CODAC is state-of-the-art on the D4RL MuJoCo benchmark in terms of both expected and risk-sensitive performance. Code is available at: https://github.com/JasonMa2016/CODAC ",
+        "bbox": [
+            232,
+            334,
+            766,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            608,
+            310,
+            626
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In many applications of reinforcement learning, actively gathering data through interactions with the environment can be risky and unsafe. Offline (or batch) reinforcement learning (RL) avoids this problem by learning a policy solely from historical data (called observational data) [9, 22, 23]. ",
+        "bbox": [
+            176,
+            638,
+            823,
+            681
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A shortcoming of most existing approaches to offline RL [11, 46, 20, 21, 48, 18] is that they are designed to maximize the expected value of the cumulative reward (which we call the return) of the policy. As a consequence, they are unable to quantify risk and ensure that the learned policy acts in a safe way. In the online setting, there has been recent work on distributional RL algorithms [7, 6, 27, 38, 17], which instead learn the full distribution over future returns. They can use this distribution to plan in a way that avoids taking risky, unsafe actions. Furthermore, when coupled with deep neural network function approximation, they can learn better state representations due to the richer distributional learning signal $\\lVert \\rVert 2 6 \\rVert$ , enabling them to outperform traditional RL algorithms even on the risk-neutral, expected return objective [4, 7, 6, 47, 14]. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            813
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose Conservative Offline Distributional Actor-Critic (CODAC), which adapts distributional RL to the offline setting. A key challenge in offline RL is accounting for high uncertainty on out-of-distribution (OOD) state-action pairs for which observational data is limited $\\pm \\sqrt { 2 3 } \\sqrt { 2 0 } ]$ ; the value estimates for these state-action pairs are intrinsically high variance, and may be exploited by the policy without correction due to the lack of online data gathering and feedback. We build on conservative $Q$ -learning $\\pmb { \\left. 2 1 \\right. }$ , which penalizes $Q$ values for OOD state-action pairs to ensure that the learned $Q$ -function lower bounds the true $Q$ -function. Analogously, CODAC uses a penalty to ensure that the quantiles of the learned return distribution lower bound those of the true return distribution. Crucially, the lower bound is data-driven and selectively penalizes the quantile estimates of state-actions that are less frequent in the offline dataset; see Figure 1. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We prove that for finite MDPs, CODAC converges to an estimate of the return distribution whose quantiles uniformly lower bound the quantiles of the true return distribution; in addition, this data-driven lower bound is tight up to the approximation error in estimating the quantiles using finite data. Thus, CODAC obtains a uniform lower bound on all integrations of the quantiles, including the standard RL objective of expected return, the risk-sensitive conditional-value-at-risk (CVaR) objective $\\pmb { \\Vert 3 5 \\Vert }$ , as well as many other risk-sensitive objectives. We additionally prove that CODAC expands the gap in quantile estimates between in-distribution and OOD actions, thus avoiding overconfidence when extrapolating to OOD actions $\\pmb { \\mathbb { D } }$ . ",
+        "bbox": [
+            174,
+            154,
+            549,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our theoretical guarantees rely on novel techniques for analyzing the distributional Bellman operator, which is challenging since it acts on the infinite-dimensional function space of return distributions (whereas the traditional ",
+        "bbox": [
+            174,
+            339,
+            549,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/76192742e57ca7417188924db6dc1141f1cc9a9de88268ae200008b9ef91309e.jpg",
+        "image_caption": [
+            "Figure 1: CODAC obtains conservative estimates of the true return quantiles (black); it penalizes out-of-distribution actions, $\\mu ( a \\mid s )$ , more heavily than indistribution actions, $\\pi _ { \\hat { \\beta } } ( a \\mid s )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            566,
+            157,
+            820,
+            304
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Bellman operator acts on a finite-dimensional vector space). We provide several novel results that may be of independent interest; for instance, our techniques can be used to bound the error of the fixed-point of the empirical distributional Bellman operator; see Appendix A.6. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            436
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, to obtain a practical algorithm, CODAC builds on existing distributional RL algorithms by integrating conservative return distribution estimation into a quantile-based actor-critic framework. ",
+        "bbox": [
+            176,
+            443,
+            823,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we demonstrate the effectiveness of CODAC on both risk-sensitive and riskneutral RL. First, on two novel risk-sensitive robot navigation tasks, we show that CODAC successfully learns risk-averse policies using offline datasets collected purely from a risk-neutral agent, a challenging task that all our baselines fail to solve. Next, on the D4RL Mujoco suite $\\tilde { \\left[ 1 0 \\right] }$ , a popular offline RL benchmark, we show that CODAC achieves state-of-art results on both the original risk-neutral version as well a modified risk-sensitive version $\\boxed { 4 3 }$ . Finally, we empirically show that CODAC computes quantile lower-bounds and gap-expanded quantiles even on high-dimensional continuous-control problems, validating our key theoretical insights into the effectiveness of CODAC. ",
+        "bbox": [
+            174,
+            477,
+            826,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Related work. There has been growing interest in offline (or batch) RL [22, 23]. The key challenge in offline RL is to avoid overestimating the value of out-of-distribution (OOD) actions rarely taken in the observational dataset $\\overline { { 1 4 0 } } , \\overline { { 4 4 } } , \\overline { { 2 0 } } ]$ . The problem is that policy learning optimizes against the value estimates; thus, even if the estimation error is i.i.d., policy optimization biases towards taking actions with high variance value estimates, since some of these values will be large by random chance. In risk-sensitive or safety-critical settings, these actions are exactly the ones that should be avoided. ",
+        "bbox": [
+            173,
+            593,
+            825,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One solution is to constrain the learned policy to take actions similar to the ones in the dataset (similar to imitation learning)—e.g., by performing support matching $\\lVert \\overline { { 4 6 } } \\rVert$ or distributional matching [20, 12]. However, these approaches tend to perform poorly when data is gathered from suboptimal policies. An alternative is to regularize the $Q$ -function estimates to be conservative at OOD actions [21, 48, 18]. CODAC builds on these approaches, but obtains conservative estimates of all quantile values of the return distribution rather than just the expected return. Traditionally, the literature on off-policy evaluation (OPE) $\\left\\| 3 2 \\right\\| \\left. 1 6 \\right. , \\left\\| 3 9 \\right\\| \\left. 2 5 \\right. \\left. 3 7 \\right\\|$ aims to estimate the expected return of a policy using precollected offline data; CODAC proposes an OPE procedure amenable to all objectives that can be expressed as integrals of the return quantiles. Consequently, our fine-grained approach not only enables risk-sensitive policy learning, but also improves performance on risk-neutral domains. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In particular, CODAC builds on recent works on distributional RL [4, 7, 6, 47], which parameterize and estimate the entire return distribution instead of just a point estimate of the expected return (i.e., the $Q$ -function) $ { \\mathbb { I } } 2 9 .  { \\left| 2 8 \\right| }$ . Distributional RL algorithms have been shown to achieve state-of-art performance on Atari and continuous control domains [14, 3]; intuitively, they provide richer training signals that stabilize value network training $\\boxed { \\boxed { 4 } }$ . Existing distributional RL algorithms parameterize the policy return distribution in many different ways, including canonical return atoms $\\pmb { \\mathbb { H } }$ , the expectiles $\\pmb { \\mathbb { B } } 6 \\mathbf { I }$ , the moments $\\pmb { \\triangleright }$ , and the quantiles [7, 6, 47]. CODAC builds on the quantile approach due to its suitability for risk-sensitive policy optimization. The quantile representation provides an unified framework for optimizing different objectives of interest $\\textcircled { 7 }$ , such as the riskneutral expected return, and a family of risk-sensitive objectives representable by the quantiles; this family includes, for example, the conditional-value-at-risk (CVaR) return [35, 5, 38, 17], the Wang measure $\\boxed { \\boxplus 5 } \\boxed { }$ , and the cumulative probability weighting (CPW) metric $\\pmb { \\left. 4 2 \\right. }$ . Recent work has provided theoretical guarantees on learning CVaR policies $\\overline { { \\| 1 7 \\| } }$ ; however, their approach cannot provide bounds on the quantiles of the estimated return distribution, which is significantly more challenging since there is no closed-form expression for the Bellman update on the return quantiles. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, there has been some recent work adapting distributional RL to the offline setting [1, 43]. First, REM $\\pmb { \\mathbb { \\left[ 1 \\right] } }$ builds on QR-DQN $\\textcircled { 7 }$ , an online distributional RL algorithm; however, REM can be applied to regular DQN $\\sqrt { 2 9 }$ and does not directly utilize the distributional aspect of QR-DQN. The closest work to ours is ORAAC $\\textcircled { 1 4 3 }$ , which uses distributional RL to learn a CVaR policy in the offline setting. ORAAC uses imitation learning to avoid OOD actions and stay close to the data distribution. As discussed above, imitation learning strategies can perform poorly unless the dataset comes from an optimal policy; in our experiments, we find that CODAC significantly outperforms ORAAC. Furthermore, unlike ORAAC, we provide theoretical guarantees on our approach. ",
+        "bbox": [
+            173,
+            236,
+            826,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            366,
+            308,
+            383
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Offline RL. Consider a Markov Decision Process (MDP) $\\lVert 3 3 \\rVert$ $( S , { \\mathcal { A } } , P , R , \\gamma )$ , where $s$ is the state space, $\\mathcal { A }$ is the action space, $P ( s ^ { \\prime } \\mid s , a )$ is the transition distribution, $\\ \\cdot$ is the reward distribution, and $\\gamma \\in ( 0 , 1 )$ is the discount factor, and consider a stochastic policy $\\pi ( a \\mid$ $s ) : \\mathcal { S }  \\Delta ( \\mathcal { A } )$ . A rollout using $\\pi$ from state $s$ using initial action $a$ is the random sequence $\\xi = ( ( s _ { 0 } , a _ { 0 } , r _ { 0 } ) , ( s _ { 1 } , a _ { 1 } , r _ { 1 } ) , \\ldots )$ such that $s _ { 0 } ~ = ~ s$ , $a _ { 0 } ~ = ~ a$ , $a _ { t } \\sim \\pi ( \\cdot \\mid s _ { t } )$ (for $t > 0$ ), $r _ { t } ~ \\sim$ $R ( \\cdot \\mid s _ { t } , a _ { t } )$ , and $s _ { t + 1 } \\sim P ( \\cdot \\mid s _ { t } , a _ { t } )$ ; we denote the distribution over rollouts by $D ^ { \\pi } ( \\xi \\mid s , a )$ . The $Q$ -function $Q ^ { \\pi } : S \\times \\mathcal { A }  \\mathbb { R }$ of $\\pi$ is its expected discounted cumulative return $Q ^ { \\pi } ( s , a ) =$ $\\begin{array} { r l } { } & { { } \\underset { - } { \\mathbb { E } } _ { D ^ { \\pi } ( \\xi | s , a ) } [ \\sum _ { t = 0 } ^ { \\infty } \\overset { \\cdot } { \\gamma } { } ^ { t } r _ { t } ] } \\end{array}$ . Assuming the rewards satisfy $r _ { t } \\in [ R _ { \\operatorname* { m i n } } , R _ { \\operatorname* { m a x } } ]$ , then we have $Q ^ { \\pi } ( s , a ) \\in$ $[ V _ { \\operatorname* { m i n } } , V _ { \\operatorname* { m a x } } ] \\subseteq [ \\dot { R } _ { \\operatorname* { m i n } } / ( 1 - \\gamma ) , R _ { \\operatorname* { m a x } } / ( 1 - \\gamma ) ]$ . ",
+        "bbox": [
+            173,
+            397,
+            826,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A standard goal of reinforcement learning (RL), which we call risk-neutral RL, is to learn the optimal policy $\\pi ^ { * }$ such that $Q ^ { \\pi ^ { * } } ( s , a ) \\geq Q ^ { \\pi } ( s , a )$ for all $s \\in S , a \\in A$ and all $\\pi$ . ",
+        "bbox": [
+            174,
+            530,
+            821,
+            561
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In offline RL, the learning algorithm only has access to a fixed dataset $\\mathcal { D } : = \\{ ( s , a , r , s ^ { \\prime } ) \\}$ , where $r \\sim R ( \\cdot \\mid s , a )$ and $s ^ { \\prime } \\sim \\bar { P } ( \\cdot \\mid s , a )$ . The goal is to learn the optimal policy without any interaction with the environment. Though we do not assume that $\\mathcal { D }$ necessarily comes from a single behavior policy, we define the empirical behavior policy to be $\\begin{array} { r } { \\hat { \\pi } _ { \\beta } ( a \\mid s ) : = \\frac { \\dot { \\sum _ { s ^ { \\prime } , a ^ { \\prime } \\in \\mathcal { D } } } \\mathbb { 1 } ( s ^ { \\prime } = s , a ^ { \\prime } = a ) } { \\sum _ { s ^ { \\prime } \\in \\mathcal { D } } \\mathbb { 1 } ( s ^ { \\prime } = s ) } } \\end{array}$ . With slight abuse of notation, we write $( s , a , r , s ^ { \\prime } ) \\sim \\mathcal { D }$ to denote a uniformly random sample from the dataset. Also, in this paper, we broadly refer to actions not drawn from ${ \\hat { \\pi } } _ { \\beta } ( \\cdot \\mid s )$ (i.e., low probability density) as out-of-distribution (OOD). ",
+        "bbox": [
+            173,
+            565,
+            826,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fitted $Q$ -evaluation (FQE) [9, 34] uses $Q$ -learning for offline RL, which leverages the fact that $Q ^ { \\pi } = \\tau ^ { \\pi } Q ^ { \\pi }$ is the unique fixed point of the Bellman operator $\\mathcal { T } ^ { \\pi } : \\mathbb { R } ^ { | \\mathcal { S } | | \\mathcal { A } | }  \\mathbb { R } ^ { | \\bar { \\mathcal { S } } | | \\mathcal { A } | }$ defined by ",
+        "bbox": [
+            171,
+            679,
+            823,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0bc47bbe3b2983fa49883143733a4c18c68b6251747baa596bf36db0927dcc74.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { T } ^ { \\pi } Q ( s , a ) = \\mathbb { E } _ { R ( r \\mid s , a ) } [ r ] + \\gamma \\cdot \\mathbb { E } _ { P ^ { \\pi } ( s ^ { \\prime } , a ^ { \\prime } \\mid s , a ) } [ Q ( s ^ { \\prime } , a ^ { \\prime } ) ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            717,
+            683,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $P ^ { \\pi } ( s ^ { \\prime } , a ^ { \\prime } | s , a ) = P ( s ^ { \\prime } \\mid s , a ) \\pi ( a ^ { \\prime } \\mid s ^ { \\prime } )$ . In the offline setting, we do not have access to $\\tau ^ { \\pi }$ ; instead, FQE uses an approximation ${ \\hat { \\mathcal { T } } } ^ { \\pi }$ obtained by replacing $R$ and $P$ in $\\mathcal { T } ^ { \\pi }$ with estimates $\\hat { R }$ and $\\hat { P }$ based on $\\mathcal { D }$ . Then, we can estimate $Q ^ { \\pi }$ by starting from an arbitrary $\\hat { Q } ^ { 0 }$ and iteratively computing ",
+        "bbox": [
+            174,
+            741,
+            826,
+            790
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc72f87f00b88904b5d5f81f12d5d256abeb8dc1713fdeb5612ed5bb0d161ab1.jpg",
+        "text": "$$\n\\hat { Q } ^ { k + 1 } : = \\underset { Q } { \\arg \\operatorname* { m i n } } \\mathcal { L } ( \\hat { Q } , \\hat { T } ^ { \\pi } \\hat { Q } ^ { k } ) \\quad \\mathrm { w h e r e } \\quad \\mathcal { L } ( Q , Q ^ { \\prime } ) = \\mathbb { E } _ { \\mathcal { D } ( s , a ) } \\left[ ( Q ( s , a ) - Q ^ { \\prime } ( s , a ) ) ^ { 2 } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            209,
+            796,
+            787,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Assuming we search over the space of all possible $Q$ (i.e., do not use function approximation), then the minimizer is $\\hat { Q } ^ { k + 1 } = \\hat { T } ^ { \\pi } \\hat { Q } ^ { k }$ , so $\\hat { Q } ^ { k } = ( \\hat { T } ^ { \\pi } ) ^ { k } Q ^ { 0 }$ . If $\\hat { \\mathcal { T } } ^ { \\pi } = \\mathcal { T } ^ { \\pi }$ , then $\\textstyle \\operatorname* { l i m } _ { k \\to \\infty } { \\hat { Q } } ^ { k } = Q ^ { \\pi }$ . ",
+        "bbox": [
+            174,
+            832,
+            823,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Distributional RL. In distributional RL, the goal is to learn the distribution of the discounted cumulative rewards (i.e., returns) $\\boxed { 4 }$ . Given a policy $\\pi$ , we denote its return distribution as the random variable $\\begin{array} { r } { Z ^ { \\pi } ( s , a ) = \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r _ { t } } \\end{array}$ , which is a function of a random rollout $\\xi \\sim D ^ { \\pi } ( \\cdot \\mid s , a )$ ",
+        "bbox": [
+            173,
+            868,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "note that $Z ^ { \\pi }$ includes three sources of randomness: (1) the reward $R ( \\cdot \\mid s , a )$ , (2) the transition $\\textstyle P ( \\cdot \\mid s , a )$ , and (3) the policy $\\pi ( \\cdot \\mid s )$ . Also, note that $Q ^ { \\pi } ( s , a ) = \\mathbb { E } _ { D ^ { \\pi } ( \\xi \\mid s , a ) } [ Z ^ { \\pi } ( s , a ) ]$ . Analogous to $Q$ -function Bellman operator, the distributional Bellman operator for $\\pi$ is ",
+        "bbox": [
+            171,
+            90,
+            826,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18f97c0e14f8c3eca4570dc17a17441b4e5b4cf5c9c0f18cc7656f2e63352242.jpg",
+        "text": "$$\n\\begin{array} { r } { { \\mathcal T } ^ { \\pi } Z ( s , a ) : = r + \\gamma Z ( s ^ { \\prime } , a ^ { \\prime } ) \\quad \\mathrm { w h e r e } \\quad r \\sim R ( \\cdot \\mid s , a ) , s ^ { \\prime } \\sim P ( \\cdot \\mid s , a ) , a ^ { \\prime } \\sim \\pi ( \\cdot \\mid s ^ { \\prime } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            140,
+            771,
+            162
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\underline { { \\underline { { D } } } }$ indicates equality in distribution. As with $Q ^ { \\pi } , Z ^ { \\pi }$ is the unique fixed point of $\\mathcal { T } ^ { \\pi }$ in Eq. 1. Next, let $F _ { Z ( s , a ) } ( x ) : [ V _ { \\mathrm { m i n } } , V _ { \\mathrm { m a x } } ] \\to [ 0 , 1 ]$ be the cumulative density function (CDF) for return distribution $Z ( s , a )$ , and $F _ { R ( s , a ) }$ be the CDF of $R ( \\cdot \\mid s , a )$ Then, we have the following equality, which captures how the distributional Bellman operator $\\tau ^ { \\pi }$ operates on the CDF $F _ { Z ( s , a ) }$ [17]: ",
+        "bbox": [
+            173,
+            171,
+            828,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d647799d14f43112a9ebf1f81d5fa0e872c8b945b6a05f5abdabeb609050ff9.jpg",
+        "text": "$$\nF _ { \\mathcal { T } ^ { \\pi } Z ( s , a ) } ( x ) = \\sum _ { s ^ { \\prime } , a ^ { \\prime } } P ^ { \\pi } ( s ^ { \\prime } , a ^ { \\prime } \\mid s , a ) \\int F _ { Z ( s ^ { \\prime } , a ^ { \\prime } ) } \\left( \\frac { x - r } { \\gamma } \\right) d F _ { R ( s , a ) } ( r ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            246,
+            738,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $X$ and $Y$ be two random variables. Then, the quantile function (i.e., inverse CDF) $F _ { X } ^ { - 1 }$ of $X$ is $F _ { X } ^ { - 1 } ( \\tau ) : = \\operatorname* { i n f } \\{ x \\in \\mathbb { R } \\mid \\tau \\leq F _ { X } ( x ) \\} .$ , and the $p$ -Wasserstein distance between $X$ and $Y$ is $\\begin{array} { r } { W _ { p } ( X , Y ) = ( \\int _ { 0 } ^ { 1 } \\lvert F _ { Y } ^ { - 1 } ( \\tau ) - F _ { X } ^ { - 1 } ( \\tau ) \\rvert ^ { p } d \\tau ) ^ { 1 / p } } \\end{array}$ . Then, the distributional Bellman operator $\\mathcal { T } ^ { \\pi }$ is a $\\gamma$ -contraction in the $W _ { p }$ [4]—i.e., letting $\\begin{array} { r } { \\bar { d } _ { p } ( Z _ { 1 } , Z _ { 2 } ) : = \\operatorname* { s u p } _ { s , a } W _ { p } ( Z _ { 1 } ( s , a ) , Z _ { 2 } ( s , a ) ) } \\end{array}$ be the largest Wasserstein distance over $( s , a )$ , and $\\mathcal { Z } = \\{ Z : \\mathcal { S } \\times \\mathcal { A } \\to \\mathcal { P } ( \\mathbb { R } ) \\ | \\ \\forall ( s , a ) \\ . \\mathbb { E } [ | Z ( s , a ) | ^ { p } ] < \\infty \\}$ be the space of distributions over $\\mathbb { R }$ with bounded $p$ -th moment, then ",
+        "bbox": [
+            173,
+            300,
+            826,
+            396
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/316e280c0fd7787270c2e243ccbde74a3bf0e384b38e84a42e972b18a5726755.jpg",
+        "text": "$$\n\\bar { d } _ { p } ( \\mathcal { T } ^ { \\pi } Z _ { 1 } , \\mathcal { T } ^ { \\pi } Z _ { 2 } ) \\leq \\gamma \\bar { d } _ { p } ( Z _ { 1 } , Z _ { 2 } ) \\qquad ( \\forall Z _ { 1 } , Z _ { 2 } \\in \\mathcal { Z } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            400,
+            679,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As a result, $Z ^ { \\pi }$ may be obtained by iteratively applying $\\tau ^ { \\pi }$ to an initial distribution $Z$ . ",
+        "bbox": [
+            171,
+            422,
+            741,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As before, in the offline setting, we can approximate $\\tau ^ { \\pi }$ by ${ \\hat { \\tau } } ^ { \\pi }$ using $\\mathcal { D }$ . Then, we can compute $Z ^ { \\pi }$ (represented as $F _ { Z ( s , a ) } ^ { - 1 }$ ; see below) by starting from an arbitrary ${ \\hat { Z } } ^ { 0 }$ , and iteratively computing ",
+        "bbox": [
+            174,
+            445,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/56beaebb803b27054bb9c8927bc28b27943a9f31f8dbb80224f09b349580ba82.jpg",
+        "text": "$$\n\\hat { Z } ^ { k + 1 } = \\underset { Z } { \\arg \\operatorname* { m i n } } \\mathcal { L } _ { p } ( Z , \\hat { T } ^ { \\pi } \\hat { Z } ^ { k } ) \\quad \\mathrm { w h e r e } \\quad \\mathcal { L } _ { p } ( Z , Z ^ { \\prime } ) = \\mathbb { E } _ { \\mathcal { D } ( s , a ) } \\left[ W _ { p } ( Z ( s , a ) , Z ^ { \\prime } ( s , a ) ) ^ { p } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            487,
+            784,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We call this procedure fitted distributional evaluation $( F D E )$ . ",
+        "bbox": [
+            173,
+            520,
+            575,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One distributional RL algorithmic framework is quantile-based distributional RL [7, 6, 47, 27, 38, 43], where the return distribution $Z$ is represented by its quantile function $F _ { Z ( s , a ) } ^ { - 1 } ( \\tau ) : [ 0 , 1 ] \\to \\mathbb { R }$ . Given a distribution $g ( \\tau )$ over $[ 0 , 1 ]$ , the distorted expectation of $Z$ is $\\begin{array} { r } { \\Phi _ { g } ( Z ( s , a ) ) = \\int _ { 0 } ^ { 1 } F _ { Z ( s , a ) } ^ { - 1 } ( \\tau ) g ( \\tau ) d \\tau } \\end{array}$ , and the corresponding policy is $\\begin{array} { r } { \\pi _ { g } ( s ) : = \\arg \\operatorname* { m a x } _ { a } \\Phi _ { g } ( Z ( s , a ) ) } \\end{array}$ [7]. If $g = \\mathrm { U n i f o r m } ( [ 0 , 1 ] )$ , then $Q ^ { \\pi } ( s , a ) = \\bar { \\Phi _ { g } } ( Z ( s , \\bar { a } ) )$ ; alternatively, $g = \\operatorname { U n i f o r m } ( [ 0 , \\xi ] )$ corresponds to the CVaR [35, 5, 6] objective, where only the bottom $\\xi$ -percentile of the return is considered. Additional risk-sensitive objectives are also compatible. For example, CPW $\\pmb { \\mathbb { \\mathbb { \\mathbb { \\mathbb { \\mathbb { \\Psi } } } } } }$ amounts to $g ( \\tau ) = \\tau ^ { \\beta } / ( \\tau ^ { \\beta } + ( 1 - \\tau ) ^ { \\beta } ) ^ { \\frac { 1 } { \\beta } }$ , and Wang $\\boxed { 4 5 }$ has $g ( \\tau ) = F _ { \\cal N } ( F _ { \\cal N } ^ { - 1 } ( \\tau ) + \\beta )$ , where $F _ { \\mathcal { N } }$ is the standard Gaussian CDF. ",
+        "bbox": [
+            173,
+            540,
+            826,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A drawback of FDE is that it does not account for estimation error, especially for pairs $( s , a )$ that rarely appear in the given dataset $\\mathcal { D }$ ; thus, $\\hat { Z } ^ { k } ( s , a )$ may be an overestimate of $Z ^ { k } ( s , a )$ [12, 20, 21], even in distributional RL (since the learned distribution does not include randomness in the dataset) $\\boxed { 1 4 } \\boxed { 3 }$ . Importantly, since we act by optimizing with respect to $\\hat { Z } ^ { k } ( s , a )$ , the optimization algorithm will exploit these errors, biasing towards actions with higher uncertainty, which is the opposite of what is desired. In Section $\\textcircled { 3 }$ we propose and analyze a penalty designed to avoid this issue. ",
+        "bbox": [
+            173,
+            674,
+            826,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Conservative offline distributional policy evaluation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            780,
+            637,
+            799
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We describe our algorithm for computing a conservative estimate of $Z ^ { \\pi } ( s , a )$ , and provide theoretical guarantees for finite MDPs. In particular, we modify Eq. 4 to include a penalty term: ",
+        "bbox": [
+            173,
+            811,
+            826,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/acbd3f8d5867dbd7b8bda8afc2a516ad8dd0dc6e96af1d67436dc5f52a0f001b.jpg",
+        "text": "$$\n\\tilde { Z } ^ { k + 1 } = \\underset { Z } { \\arg \\operatorname* { m i n } } \\alpha \\cdot \\mathbb { E } _ { U ( \\tau ) , \\mathcal { D } ( s , a ) } \\left[ c _ { 0 } ( s , a ) \\cdot F _ { Z ( s , a ) } ^ { - 1 } ( \\tau ) \\right] + \\mathcal { L } _ { p } ( Z , \\hat { T } ^ { \\pi } \\tilde { Z } ^ { k } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            847,
+            740,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for some state-action dependent scale factor $c _ { 0 }$ ; here, $U = \\mathrm { U n i f o r m } ( [ 0 , 1 ] )$ . This objective adapts the conservative penalty in prior work $\\left[ 2 1 \\right]$ to the distributional RL setting; in particular, the first term in the objective is a penalty that aims to shrink the quantile values for out-of-distribution (OOD) actions compared to those of in-distribution actions; intuitively, $c _ { 0 } ( s , a )$ should be larger for OOD actions. For now, we let $c _ { 0 }$ be arbitrary; we describe our choice in Section 4. $\\alpha \\in \\mathbb { R } _ { > 0 }$ is a hyperparameter controlling the magnitude of the penalty term with respect to the usual FDE objective. We call this iterative algorithm conservative distribution evaluation $( C D E )$ . ",
+        "bbox": [
+            173,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/818c7e37b648f95f76603f525bd2bbdf997d895493501e11bf9b97c1ce6624f1.jpg",
+        "image_caption": [
+            "Figure 2: Overview of our theoretical results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            823,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            242,
+            826,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, we analyze theoretical properties of CDE in the setting of finite MDPs; Figure 2 overviews these results. First, we prove that CDE iteratively obtains conservative quantile estimates (Lemma 3.4) and defines a contraction operator on return distributions (Lemma $\\textcircled { 3 . 5 }$ Then, our main result (Theorem $\\boxed { 3 . 6 }$ is that CDE converges to a fixed point $\\tilde { Z } ^ { \\pi }$ whose quantile function lower bounds that of the true returns $Z ^ { \\pi }$ . We also prove that CDE is gap-expanding (Theorem $3 . 8 )$ —i.e., it is more conservative for actions that are rare in $\\mathcal { D }$ . These results translate to RL objectives computed by integrating the return quantiles, including expected and CVaR returns (Corollaries 3.7 & 3.9). ",
+        "bbox": [
+            173,
+            318,
+            825,
+            419
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We begin by describing our assumptions on the MDP and dataset. First, we assume that our dataset $\\mathcal { D }$ has nonzero coverage of all actions for states in the dataset $[ \\sqrt { 2 3 } , \\sqrt { 2 1 } ]$ . ",
+        "bbox": [
+            173,
+            424,
+            823,
+            453
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3.1. For all $s \\in \\mathcal { D }$ and $a \\in { \\mathcal { A } }$ , we have ${ \\hat { \\pi } } _ { \\beta } ( a \\mid s ) > 0$ ",
+        "bbox": [
+            174,
+            457,
+            616,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This assumption is only needed by our theoretical analysis to avoid division-by-zero and ensure that all estimates are well-defined; alternatively, we could assign a very low value ${ \\hat { \\pi } } _ { \\beta } ( a \\mid s ) : = \\epsilon$ for all actions not visited at state $s$ in the offline dataset and renormalize ${ \\hat { \\pi } } _ { \\beta } ( a \\mid s )$ accordingly. Next, we impose regularity conditions on the fixed point $Z ^ { \\pi }$ of the distributional Bellman operator $\\mathcal { T } ^ { \\pi }$ . ",
+        "bbox": [
+            174,
+            482,
+            826,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3.2. For all $s \\in S$ and $a \\in { \\mathcal { A } }$ , $F _ { Z ^ { \\pi } \\left( s , a \\right) }$ is smooth. Furthermore, there exists $\\zeta \\in \\mathbb { R } _ { > 0 }$ such that for all $s \\in S$ and $a \\in { \\mathcal { A } }$ , $F _ { Z ^ { \\pi } \\left( s , a \\right) }$ is $\\zeta$ -strongly monotone—i.e., we have $F _ { Z ^ { \\pi } ( s , a ) } ^ { \\prime } ( x ) \\geq \\zeta$ ",
+        "bbox": [
+            174,
+            541,
+            825,
+            574
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The smoothness assumption ensures that the $p$ th moments of $Z ^ { \\pi } ( s , a )$ are bounded (since $Z ^ { \\pi } \\in \\mathbf { \\pi }$ $[ V _ { \\operatorname* { m i n } } , V _ { \\operatorname* { m a x } } ]$ is also bounded), whnsure convergence of n ensures that . Next, we assu $Z ^ { \\pi } \\in { \\mathcal { Z } }$ . The monotonicitthe search space in sumption is includes all $F _ { Z ^ { \\pi } \\left( s , a \\right) } ^ { - 1 } .$ $( 5 )$ possible functions (i.e., no function approximation). ",
+        "bbox": [
+            173,
+            585,
+            826,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3.3. The search space of the minimum over $Z$ in $( 5 )$ is over all smooth functions $F _ { Z ( s , a ) }$ (for all $s \\in S$ and $a \\in { \\mathcal { A } }$ ) with support on $[ V _ { \\operatorname* { m i n } } , V _ { \\operatorname* { m a x } } ]$ . ",
+        "bbox": [
+            173,
+            650,
+            821,
+            681
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This assumption is required for us to analytically characterize the solution $\\tilde { Z } ^ { k + 1 }$ of the CDE objective.   \nFinally, we also assume $p > 1$ (i.e., we use the $p$ -Wasserstein distance for some $p > 1$ ). ",
+        "bbox": [
+            173,
+            691,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now, we describe our key results. Our first result characterizes the CDE iterates $\\tilde { Z } ^ { k + 1 }$ ; importantly, if $c _ { 0 } ( s , a ) > 0$ , then these iterates encode successively more conservative quantile estimates. ",
+        "bbox": [
+            171,
+            728,
+            825,
+            758
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3.4. For all $s \\in \\mathcal { D }$ , $a \\in \\mathcal { A } , k \\in \\mathbb { N } .$ , and $\\tau \\in [ 0 , 1 ]$ , we have ",
+        "bbox": [
+            173,
+            761,
+            614,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/971446d5088bef7d1f050f22b611395852996a6620cef5024b31695d1a9ad52d.jpg",
+        "text": "$$\nF _ { \\tilde { Z } ^ { k + 1 } ( s , a ) } ^ { - 1 } ( \\tau ) = F _ { \\tilde { T } ^ { \\pi } \\tilde { Z } ^ { k } ( s , a ) } ^ { - 1 } ( \\tau ) - c ( s , a ) \\ w h e r e \\ c ( s , a ) = | \\alpha p ^ { - 1 } c _ { 0 } ( s , a ) | ^ { 1 / ( p - 1 ) } \\cdot \\mathrm { s i g n } ( c _ { 0 } ( s , a ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            784,
+            816,
+            809
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We give a proof in Appendix $\\mathbf { A . l } ;$ roughly speaking, it follows by setting the gradient of $\\textcircled{5}$ equal to zero, relying on results from the calculus of variations to handle the fact that $\\stackrel { - } { F } _ { Z \\left( s , a \\right) } ^ { - 1 }$ is a function. ",
+        "bbox": [
+            173,
+            819,
+            823,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, we define the CDE operator $\\tilde { \\mathcal { T } } ^ { \\pi } = \\mathcal { O } _ { c } \\hat { \\mathcal { T } } ^ { \\pi }$ to be the composition of ${ \\hat { \\mathcal { T } } } ^ { \\pi }$ with the shift operator $\\mathcal { O } _ { c } : \\mathcal { Z }  \\mathcal { Z }$ defined by $F _ { \\mathcal { O } _ { c } Z ( s , a ) } ^ { - 1 } ( \\tau ) = F _ { Z ( s , a ) } ^ { - 1 } ( \\tau ) - c ( s , a )$ T; thus, Lemma 3.4 says $\\tilde { Z } ^ { k + \\bar { 1 } } = \\tilde { T } ^ { \\pi } \\tilde { Z } ^ { k }$ . Now, we show that $\\tilde { \\tau } ^ { \\pi }$ is a contraction in the maximum Wasserstein distance $\\bar { d } _ { p }$ . ",
+        "bbox": [
+            173,
+            859,
+            826,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3.5. $\\tilde { \\mathcal { T } } ^ { \\pi }$ is a $\\gamma$ -contraction in $\\bar { d } _ { p }$ , so $\\tilde { Z } ^ { k }$ converges to a unique fixed point $\\tilde { Z } ^ { \\pi }$ ",
+        "bbox": [
+            171,
+            88,
+            740,
+            107
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The first part follows since ${ \\hat { \\mathcal { T } } } ^ { \\pi }$ is a $\\gamma$ -contraction in $\\bar { d } _ { p }$ [4, $\\textcircled { 7 }$ , and $\\mathcal { O } _ { c }$ is a non-expansion in $\\bar { d } _ { p }$ , so by composition, $\\tilde { \\mathcal { T } } ^ { \\pi }$ is a $\\gamma$ -contraction in $\\bar { d } _ { p }$ ; the second follows by the Banach fixed point theorem. ",
+        "bbox": [
+            174,
+            118,
+            823,
+            152
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Now, our first main theorem says that the fixed point $\\tilde { Z } ^ { \\pi }$ of $\\tilde { \\mathcal { T } } ^ { \\pi }$ is a conservative estimate of $Z ^ { \\pi }$ at all quantiles $\\tau$ —i.e., CDE computes quantile estimates that lower bound the quantiles of the true return; furthermore, it says that this lower bound is tight. ",
+        "bbox": [
+            174,
+            159,
+            826,
+            203
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.6. For any $\\delta \\in \\mathbb { R } _ { > 0 }$ , $c _ { 0 } ( s , a ) > 0$ , with probability at least $1 - \\delta$ , ",
+        "bbox": [
+            174,
+            207,
+            684,
+            223
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8f6b75a17e5027fa8c46c1453e845a2efd4f6ed9a5a26e2a1a8730aacaca7eb3.jpg",
+        "text": "$$\n\\begin{array} { r l } & { F _ { Z ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) \\geq F _ { \\tilde { Z } ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) + ( 1 - \\gamma ) ^ { - 1 } \\underset { s ^ { \\prime } , a ^ { \\prime } } { \\operatorname* { m i n } } \\{ c ( s ^ { \\prime } , a ^ { \\prime } ) - \\Delta ( s ^ { \\prime } , a ^ { \\prime } ) \\} , } \\\\ & { F _ { Z ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) \\leq F _ { \\tilde { Z } ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) + ( 1 - \\gamma ) ^ { - 1 } \\underset { s ^ { \\prime } , a ^ { \\prime } } { \\operatorname* { m a x } } \\{ c ( s ^ { \\prime } , a ^ { \\prime } ) - \\Delta ( s ^ { \\prime } , a ^ { \\prime } ) \\} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            229,
+            723,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "for all sufficie $s \\in \\mathcal { D }$ $a \\in { \\mathcal { A } } ,$ $\\tau \\in [ 0 , 1 ]$ $\\begin{array} { r } { \\Delta ( s , a ) = \\frac { 1 } { \\zeta } \\sqrt { \\frac { 5 | S | } { n ( s , a ) } \\log \\frac { 4 | S | | A | } { \\delta } } } \\end{array}$ rmore, for . $\\alpha$ ntly large (i.e., ↵ \u0000 maxs,a{ p·\u0000(s,a)p\u00001c (s,a) } $F _ { Z ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) \\geq F _ { \\tilde { Z } ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) .$ ",
+        "bbox": [
+            173,
+            292,
+            825,
+            340
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We give a proof in Appendix $\\boxed { \\mathbf { A . 2 } }$ The first inequality says that the quantile estimates computed by CDE form a lower bound on the true quantiles; this bound is not vacuous as long as $\\alpha$ satisfies the given condition. Furthermore, the second inequality states that this lower bound is tight. ",
+        "bbox": [
+            173,
+            351,
+            826,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Many RL objectives (e.g., expected or CVaR return) are distorted expectations (i.e, integrals of the return quantiles). We can extend Theorem $3 . 6$ to obtain conservative estimates for all such objectives: ",
+        "bbox": [
+            176,
+            398,
+            823,
+            429
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Corollary 3.7. For any $\\delta \\in \\mathbb { R } _ { > 0 }$ , $c _ { 0 } ( s , a ) > 0$ , $\\alpha$ sufficiently large, and $g ( \\tau )$ , with probability at least $1 - \\delta$ , for all $s \\in \\mathcal { D }$ , $a \\in { \\mathcal { A } }$ , we have $\\Phi _ { g } ( Z ^ { \\pi } ( s , a ) ) \\geq \\Phi _ { g } ( \\tilde { Z } ^ { \\pi } ( s , a ) )$ . ",
+        "bbox": [
+            173,
+            433,
+            823,
+            465
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Choosing $g = { \\mathrm { U n i f o r m } } ( [ 0 , 1 ] )$ gives $Q ^ { \\pi } ( s , a ) \\geq \\tilde { Q } ^ { \\pi } ( s , a ) .$ —i.e., a lower bound on the $Q$ -function. CQL $\\pmb { \\mathbb { Z } } 1 \\mathbf { l }$ obtains a similar lower-bound; thus, CDE generalizes CQL to other objectives—e.g., it can be used in conjunction with any distorted expectation objective (e.g., CVaR, Wang, CPW, etc.) for risk-sensitive offline RL. ",
+        "bbox": [
+            173,
+            476,
+            826,
+            534
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that Theorem $\\boxed { 3 . 6 }$ does not preclude the possibility that the lower bounds are more conservative for good actions (i.e., ones for which $\\hat { \\pi } _ { \\beta } ( a \\mid \\bar { s } )$ is larger). We prove that under the choice1 ",
+        "bbox": [
+            171,
+            539,
+            825,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b601e51b40fc42d4527d96b3725a9ec310dd8278608a5f4b20d0df64b21543de.jpg",
+        "text": "$$\nc _ { 0 } ( s , a ) = { \\frac { \\mu ( a \\mid s ) - { \\hat { \\pi } } _ { \\beta } ( a \\mid s ) } { { \\hat { \\pi } } _ { \\beta } ( a \\mid s ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            577,
+            606,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "for some $\\mu ( a \\mid s ) \\neq { \\hat { \\pi } } _ { \\beta } ( a \\mid s )$ , then $\\tilde { \\mathcal { T } } ^ { \\pi }$ is gap-expanding—i.e., the difference in quantile values between in-distribution and out-of-distribution actions is larger under $\\tilde { \\tau } ^ { \\pi }$ than under $\\mathcal { T } ^ { \\pi }$ . Intuitively, $c _ { 0 } ( s , a )$ is large for actions $a$ with higher probability under $\\mu$ than under $\\hat { \\pi } _ { \\beta }$ (i.e., an OOD action). ",
+        "bbox": [
+            173,
+            619,
+            826,
+            667
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.8. For $p = 2$ , $\\alpha$ sufficiently large, and $c _ { 0 }$ as in $( ^ { \\dag } )$ , for all $s \\in S$ and $\\tau \\in [ 0 , 1 ]$ , ",
+        "bbox": [
+            171,
+            670,
+            769,
+            689
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/095ba7a4970b2e20ec693a75f4f980d8e53c1f54aae63ff1e94cd140fc5750a2.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } _ { \\hat { \\pi } _ { \\beta } ( a \\vert s ) } F _ { \\tilde { Z } ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) - \\mathbb { E } _ { \\mu ( a \\vert s ) } F _ { \\tilde { Z } ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) \\geq \\mathbb { E } _ { \\hat { \\pi } _ { \\beta } ( a \\vert s ) } F _ { Z ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) - \\mathbb { E } _ { \\mu ( a \\vert s ) } F _ { Z ^ { \\pi } ( s , a ) } ^ { - 1 } ( \\tau ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            207,
+            694,
+            789,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As before, the gap-expansion property implies gap-expansion of integrals of the quantiles—i.e.: ",
+        "bbox": [
+            171,
+            731,
+            795,
+            747
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Corollary 3.9. For $p = 2$ , $\\alpha$ sufficiently large, $c _ { 0 }$ as in $\\textcircled { 6 }$ , and any $g ( \\tau )$ , for all $s \\in S$ ",
+        "bbox": [
+            173,
+            750,
+            745,
+            768
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/75d1f96b505b7ba2448d172824f131c319515e4a8410f077fdff23683ed7018a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } _ { \\hat { \\pi } _ { \\beta } ( a | s ) } \\Phi _ { g } \\big ( \\tilde { Z } ^ { \\pi } ( s , a ) \\big ) - \\mathbb { E } _ { \\mu ( a | s ) } \\Phi _ { g } \\big ( \\tilde { Z } ^ { \\pi } ( s , a ) \\big ) \\geq \\mathbb { E } _ { \\hat { \\pi } _ { \\beta } ( a | s ) } \\Phi _ { g } \\big ( Z ^ { \\pi } ( s , a ) \\big ) - \\mathbb { E } _ { \\mu ( a | s ) } \\Phi _ { g } \\big ( Z ^ { \\pi } ( s , a ) \\big ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            773,
+            813,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Together, Corollaries $\\underline { { \\boldsymbol { \\left| 3 . 7 \\right| } } } \\& \\boxed { 3 . 9 }$ say that CDE provides conservative lower bounds on the return quantiles while being less conservative for in-distribution actions. ",
+        "bbox": [
+            176,
+            806,
+            821,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, we briefly discuss the condition on $\\alpha$ in Theorems $3 . 6 \\ : \\& \\ : 3 . 8 .$ In general, $\\alpha$ can be taken to be small as long as $\\Delta ( s , a )$ is small for all $s \\in S$ and $a \\in { \\mathcal { A } }$ , which in turn holds as long as $n ( s , a )$ is large—i.e., the dataset $\\mathcal { D }$ has wide coverage. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            886
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/142f1926c99155859d31045ab575b1c477b26a6df08a0856e9ab15d348af434e.jpg",
+        "image_caption": [
+            "Figure 3: 2D visualization of evaluation trajectories on the Risky PointMass environment. The red region is risky, the solid blue circles indicate initial states, and the blue lines are trajectories. CODAC-C is the only algorithm that successfully avoids the risky region. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            87,
+            815,
+            185
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Conservative offline distributional actor critic ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            262,
+            588,
+            280
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, we incorporate the distributional evaluation algorithm in Section 3 into an actor-critic framework. Following $\\overrightarrow { \\vert 2 1 \\vert }$ , we propose a min-max objective where the inner loop chooses the current policy to maximize the CDE objective, and the outer loop minimizes the CDE objective for this policy: ",
+        "bbox": [
+            173,
+            292,
+            828,
+            335
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/27dc8c0a72a1d3c0a07b98f4a3d2fe2ec7811ba7871904d75057f6235ade64de.jpg",
+        "text": "$$\n\\hat { Z } ^ { k + 1 } = \\underset { Z } { \\arg \\operatorname* { m i n } } \\underset { \\mu } { \\operatorname* { m a x } } \\left\\{ \\alpha \\cdot \\mathbb { E } _ { U ( \\tau ) } \\left[ \\mathbb { E } _ { \\mathcal { D } ( s ) , \\mu ( a \\mid s ) } F _ { Z ( s , a ) } ^ { - 1 } ( \\tau ) - \\mathbb { E } _ { \\mathcal { D } ( s , a ) } F _ { Z ( s , a ) } ^ { - 1 } ( \\tau ) \\right] + \\mathcal { L } _ { p } ( Z , \\hat { T } ^ { \\pi ^ { k } } \\hat { Z } ^ { k } ) \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            342,
+            831,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where we have used $c _ { 0 }$ as in $^ { ( 6 ) }$ . We can interpret $\\mu$ as an actor policy, the first term as the objective for $\\mu$ , and the overall objective as an actor-critic algorithm $\\textcircled { 8 }$ . In this framework, a natural choice for $\\mu$ is a maximum entropy policy $\\mu ( a \\mid s ) \\propto \\exp ( Q ( s , a ) )$ [49]. Then, our objective becomes ",
+        "bbox": [
+            173,
+            377,
+            825,
+            421
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f6f4ddcfba551e4f166fd14b6408766c64b459b44d12bee34a16908ade8a68b.jpg",
+        "text": "$$\n^ { \\mathrm { ~ 1 ~ } } = \\arg \\operatorname* { m i n } _ { Z } \\left\\{ \\alpha \\cdot \\mathbb { E } _ { U ( \\tau ) } \\left[ \\mathbb { E } _ { \\mathcal { D } ( s ) } \\log \\sum _ { a } \\exp ( F _ { Z ( s , a ) } ^ { - 1 } ( \\tau ) ) - \\mathbb { E } _ { \\mathcal { D } ( s , a ) } F _ { Z ( s , a ) } ^ { - 1 } ( \\tau ) \\right] + \\mathcal { L } _ { p } ( Z , \\hat { T } ^ { \\pi ^ { k } } \\hat { Z } ^ { k } ) \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            202,
+            426,
+            861,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $U = { \\mathrm { U n i f o r m } } ( [ 0 , 1 ] )$ ; we provide a derivation in Appendix B. We call this strategy conservative offline distributional actor critic (CODAC). To optimize over $Z$ , we represent the quantile function as a DNN $G _ { \\theta } ( \\tau ; s , a ) \\approx F _ { Z ( s , a ) } ^ { - 1 } ( \\tau )$ . The main challenge is optimizing the term $\\mathcal { L } _ { p } ( Z , \\hat { T } ^ { \\pi } \\hat { Z } ^ { k } ) = W _ { p } ( Z , \\hat { T } ^ { \\pi } \\hat { Z } ^ { k } ) ^ { p }$ . We do so using distributional temporal-differences (TD) [6]. For a sample $( s , a , r , s ^ { \\prime } ) \\tilde { } \\sim \\mathcal { D }$ and $\\smash { \\dot { a ^ { \\prime } } \\sim \\pi ( \\cdot \\mid s ^ { \\prime } ) }$ and random quantiles $\\tau , \\tau ^ { \\prime } \\sim U$ , we have ",
+        "bbox": [
+            173,
+            473,
+            828,
+            553
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/23cd1dbdf3e7991e0619843412511ad6ccef6904ea32bfc1392d7210952d7525.jpg",
+        "text": "$$\n\\mathcal { L } _ { p } ( Z , \\hat { \\mathcal { T } } ^ { \\pi } \\hat { Z } ^ { k } ) \\approx \\mathcal { L } _ { \\kappa } ( \\delta ; \\tau ) \\qquad \\mathrm { w h e r e } \\qquad \\delta = r + \\gamma G _ { \\theta ^ { \\prime } } ( \\tau ^ { \\prime } ; s ^ { \\prime } , a ^ { \\prime } ) - G _ { \\theta } ( \\tau ; s , a ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            559,
+            764,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\delta$ is the distributional TD error, $\\theta ^ { \\prime }$ are the parameters of the target $Q$ -network $\\pmb { \\Vert 3 0 }$ , and ",
+        "bbox": [
+            169,
+            583,
+            779,
+            599
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/672a90d4c8c2203e2ace2a0b14d1f37ee2b772bac5f79646fc2235f31406fedc.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\kappa } ( \\delta ; \\tau ) = \\left\\{ \\begin{array} { l l } { | \\tau - \\mathbb { 1 } ( \\delta < 0 ) | \\cdot \\delta ^ { 2 } / ( 2 \\kappa ) } & { \\mathrm { i f ~ } | \\delta | \\leq \\kappa } \\\\ { | \\tau - \\mathbb { 1 } ( \\delta < 0 ) | \\cdot ( | \\delta | - \\kappa / 2 ) } & { \\mathrm { o t h e r w i s e } \\ . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            606,
+            674,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "is the $\\tau$ -Huber quantile regression loss at threshold $\\kappa$ [15]; then, $\\mathbb { E } _ { U ( \\tau ) } \\mathcal { L } _ { \\kappa } ( \\delta ; \\tau )$ is an unbiased estimator of the Wasserstein distance that can be optimized using stochastic gradient descent (SGD) $\\boxed { 1 9 }$ . With this strategy, our overall objective can be optimized using any off-policy actorcritic method $\\pm \\boxed { 1 3 } \\boxed { 1 1 }$ ; we use distributional soft actor-critic (DSAC) $| \\widetilde { | 2 7 | }$ , which replaces the $Q$ -network in SAC $\\textcircled { 1 3 } \\textcircled { }$ with a quantile distributional critic network $\\perp \\parallel$ . We provide the full CODAC pseudocode in Algorithm 1 of Appendix B. ",
+        "bbox": [
+            173,
+            647,
+            826,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            751,
+            312,
+            768
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We show that CODAC achieves state-of-the-art results on both risk-sensitive (Sections 5.1 &5.2) and risk-neutral (Section 5.3) offline RL tasks, including our risky robot navigation and D4RL [10] We also show that our lower bound (Theorem $\\underline { { \\overline { { 3 . 6 } } } }$ and gap-expansion (Theorem $\\boxed { 3 . 8 }$ results approximately hold in practice, (Section 5.4), validating our theory on CODAC’s effectiveness. We provide additional details (e.g., environment descriptions, hyperparameters, and additional results) in Appendix C. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Risky robot navigation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            868,
+            370,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c7b888d17f028df1fa4fc033d62e37e8428be03884c18ba1f81a073aa6c9858d.jpg",
+        "table_caption": [
+            "Table 1: Risky robot navigation quantitative evaluation. CODAC-C achieves the best performance on most metrics and is the only method that learns risk-averse behavior. This table is reproduced with standard deviations in Table 6 in Appendix C. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Algorithm</td><td colspan=\"4\">Risky PointMass</td><td colspan=\"4\">Risky Ant</td></tr><tr><td>Mean</td><td>Median</td><td>CVaR0.1</td><td>Violations</td><td>Mean</td><td>Median</td><td>CVaRo.1</td><td>Violations</td></tr><tr><td>DSAC (Online)</td><td>-7.69</td><td>-3.82</td><td>-49.9</td><td>94</td><td>-866.1</td><td>-833.3</td><td>-1422.7</td><td>2247</td></tr><tr><td>CODAC-C (Ours)</td><td>-6.05</td><td>-4.89</td><td>-14.73</td><td>0.0</td><td>-456.0</td><td>-433.4</td><td>-686.6</td><td>347.8</td></tr><tr><td>CODAC-N (Ours)</td><td>-8.60</td><td>-4.05</td><td>-51.96</td><td>108.3</td><td>-432.7</td><td>-395.1</td><td>-847.1</td><td>936.0</td></tr><tr><td>ORAAC</td><td>-10.67</td><td>-4.55</td><td>-64.12</td><td>138.7</td><td>-788.1</td><td>-795.3</td><td>-1247.2</td><td>1196</td></tr><tr><td>CQL</td><td>-7.51</td><td>-4.18</td><td>-43.44</td><td>93.4</td><td>-967.8</td><td>-858.5</td><td>-1887.3</td><td>1854.3</td></tr></table>",
+        "bbox": [
+            176,
+            138,
+            825,
+            238
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tasks. We consider an Ant robot whose goal is to navigate from a random initial state to the green circle as quickly as possible (see Figure 4 for a visualization). Passing through the red circle triggers a high cost with small probability, introducing risk. A risk-neutral agent may pass through the red region, but a risk-aware agent should not. We also consider a PointMass variant for illustrative purposes. ",
+        "bbox": [
+            174,
+            284,
+            612,
+            367
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e1bc4e34e6fe671f4b34cffd4d482a7b0d2b35ae1cb7e759adcf766b3b556726.jpg",
+        "image_caption": [
+            "Figure 4: Risky Ant. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            627,
+            286,
+            821,
+            390
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We construct an offline dataset that is the replay buffer of a riskneutral distributional SAC $\\lVert 2 7 \\rVert$ agent. Intuitively, this choice matches the practical goals of offline RL, where data is gathered from a diverse range of sources with no assumptions on their quality and risk tolerance levels. [23] See Appendix C.1 for details on the environments and datasets. ",
+        "bbox": [
+            173,
+            373,
+            614,
+            429
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            429,
+            789,
+            444
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Approaches. We consider two variants of CODAC: (i) CODAC-N, which maximizes the expected return and (ii) CODAC-C, which optimizes the $\\mathrm { C V a R } _ { 0 . 1 }$ objective. We compare to Offline RiskAverse Actor Critic (ORAAC) $\\boxed { \\boxplus 3 }$ , a state-of-the-art offline risk-averse RL algorithm that combines a distributional critic with an imitation-learning based policy to optimize a risk-sensitive objective, and to Conservative Q-Learning (CQL) [21], a state-of-art offline RL algorithm that is non-distributional. ",
+        "bbox": [
+            174,
+            449,
+            826,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. We evaluate each approach using 100 test episodes, reporting the mean, median, and $\\mathrm { C V a R } _ { 0 . 1 }$ (i.e., average over bottom 10 episodes) returns, and the total number of violations (i.e., time steps spent inside the risky region), all averaged over 5 random seeds. We also report the performance of the online DSAC agent used to collect data. See Appendix C for details. Results are in Table 1. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            582
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Performance of CODAC. CODAC-C consistently outperforms the other approaches on the $\\mathrm { C V a R } _ { 0 . 1 }$ return, as well as the number of violations, demonstrating that CODAC-C is able to avoid risky actions. It is also competitive in terms of mean return due to its high $\\mathrm { C V a R } _ { 0 . 1 }$ performance, but performs slightly worse on median return, since it is not designed to optimize this objective. Remarkably, on Risky PointMass, CODAC-C learns a safe policy that completely avoids the risky region (i.e., zero violations), even though such behavior is absent in the dataset. In Appendix $\\underline { { \\mathbf { \\overline { { C . 1 } } } } }$ we also show that CODAC can successfully optimize alternative risk-sensitive objectives such as Wang and CPW. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            684
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison to ORAAC. While ORAAC also optimizes the CVaR objective, it uses imitation learning to regularize the learned policy to stay close to the empirical behavior policy. However, the dataset contains many sub-optimal trajectories generated early in training, and is furthermore risk-neutral. Thus, imitating the behavioral policy encourages poor performance. In practice, a key use of offline RL is to leverage large datasets available for training, and such datasets will rarely consist of data from a single, high-quality behavioral policy. Our results demonstrate that CODAC is significantly better suited to learned in these settings compared to ORAAC. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            787
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison to CQL. On Risky PointMass, CQL learns a risky policy with poor tail-performance, indicated by its high median performance but low $\\mathrm { C V a R } _ { 0 . 1 }$ performance. Interestingly, its mean performance is also poor; intuitively, the mean is highly sensitive to outliers that may not be present in the training dataset. On Risky Ant, possibly due to the added challenge of high-dimensionality, CQL performs poorly on all metrics, failing to reach the goal and to avoid the risky region. As expected, these results show that accounting for risk is necessary in risky environments. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            877
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Qualitative analysis. In Figure 3, we show the 100 evaluation rollouts from each policy on Risky PointMass. As can be seen, CODAC-C extrapolates a safe policy that distances itself from the risky region before proceeding to the goal; in contrast, all other agents traverse the risky region. For Ant, we include plots of the trajectories of trained agents in Appendix C.1, and videos in the supplement. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c36ef47bf3f2a3a36284f6cb1aa05141e59bb3bd6f4381d5a888e6d76386780f.jpg",
+        "table_caption": [
+            "Table 2: D4RL results. CODAC achieves the best overall performance in both risk-sensitive (Left) and risk-neutral (Right) variants of the benchmark. These tables are reproduced with standard deviations in Tables 7 & 9 in Appendix C. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Algorithm</td><td colspan=\"2\">Medium</td><td colspan=\"2\">Mixed</td></tr><tr><td>Mean</td><td>CVaR0.1</td><td>Mean</td><td>CVaR0.1</td></tr><tr><td>Ceeeca</td><td>CQL</td><td>33.2</td><td>-15.0</td><td>214.1</td><td>12.0</td></tr><tr><td></td><td>ORAAC</td><td>361.4</td><td>91.3</td><td>307.1</td><td>118.9</td></tr><tr><td></td><td>CODAC-N</td><td>338</td><td>-41</td><td>347.7</td><td>149.2</td></tr><tr><td></td><td>CODAC-C</td><td>335</td><td>-27</td><td>396.4</td><td>238.5</td></tr><tr><td>Jaddoh</td><td>CQL</td><td>877.9</td><td>693.0</td><td>189.2</td><td>-21.4</td></tr><tr><td></td><td>ORAAC</td><td>1007.1</td><td>767.6</td><td>876.3</td><td>524.9</td></tr><tr><td></td><td>CODAC-N</td><td>993.7</td><td>952.5</td><td>1483.9</td><td>1457.6</td></tr><tr><td></td><td>CODAC-C</td><td>1014.0</td><td>976.4</td><td>1551.2</td><td>1449.6</td></tr><tr><td>Aaaaka</td><td>CQL</td><td>1524.3</td><td>1343.8</td><td>74.3</td><td>-64.0</td></tr><tr><td></td><td>ORAAC</td><td>1134.1</td><td>663.0</td><td>222.0</td><td>-69.6</td></tr><tr><td></td><td>CODAC-N</td><td>1537.3</td><td>1158.8</td><td>358.7</td><td>106.4</td></tr><tr><td></td><td>CODAC-C</td><td>1120.8</td><td>902.3</td><td>450.0</td><td>261.4</td></tr></table>",
+        "bbox": [
+            176,
+            138,
+            464,
+            294
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ddb0ffa32df1e3bd64d11e32b3226d9de67c08709768537289ad14ff4f1f9ec4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>BCQ</td><td>MOPO</td><td>CQL</td><td>ORAAC</td><td>CODAC</td></tr><tr><td>halfcheetah-random</td><td>2.2</td><td>35.4</td><td>35.4</td><td>13.5</td><td>34.6</td></tr><tr><td>hopper-random</td><td>10.6</td><td>11.7</td><td>10.8</td><td>9.8</td><td>11.0</td></tr><tr><td>walker2d-random</td><td>4.9</td><td>13.6</td><td>7.0</td><td>3.2</td><td>18.7</td></tr><tr><td>halfcheetah-medium</td><td>40.7</td><td>42.3</td><td>44.4</td><td>41.0</td><td>46.3</td></tr><tr><td>walker2d-medium</td><td>53.1</td><td>17.8</td><td>79.2</td><td>27.3</td><td>82.0</td></tr><tr><td>hopper-medium</td><td>54.5</td><td>28.0</td><td>58.0</td><td>1.48</td><td>70.8</td></tr><tr><td>halfcheetah-mixed</td><td>38.2</td><td>53.1</td><td>46.2</td><td>30.0</td><td>44.1</td></tr><tr><td>hopper-mixed</td><td>33.1</td><td>67.5</td><td>48.6</td><td>16.3</td><td>100.2</td></tr><tr><td>walker2d-mixed</td><td>15.0</td><td>39.0</td><td>26.7</td><td>28</td><td>33.2</td></tr><tr><td>halfcheetah-med-exp</td><td>64.7</td><td>63.3</td><td>62.4</td><td>24.0</td><td>70.4</td></tr><tr><td>walker2d-med-exp</td><td>57.5</td><td>44.6</td><td>98.7</td><td>28.2</td><td>106.0</td></tr><tr><td>hopper-med-exp</td><td>110.9</td><td>23.7</td><td>111.0</td><td>18.2</td><td>112.0</td></tr></table>",
+        "bbox": [
+            473,
+            141,
+            825,
+            292
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            320,
+            825,
+            351
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 Risk-sensitive D4RL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            366,
+            354,
+            381
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tasks. Next, we consider stochastic D4RL $\\boxed { 4 3 }$ . The original D4RL benchmark $\\pmb { \\mathbb { I O } }$ consists of datasets collected by SAC agents of varying performance (Mixed, Medium, and Expert) on the Hopper, Walker2d, and HalfCheetah MuJoCo environments $\\pmb { \\mathbb { E } } \\mathbf { \\overline { { 4 D } } }$ ; stochastic D4RL relabels the rewards to represent stochastic robot damage for behaviors such as unnatural gaits or high velocities; see Appendix $\\boxed { C . 2 }$ The Expert dataset consists of rollouts from a fixed SAC agent trained to convergence; the Medium dataset is constructed the same way except the agent is trained to only achieve $50 \\%$ of the expert agent’s return. The Mixed dataset is the replay buffer of the Medium agent. ",
+        "bbox": [
+            173,
+            390,
+            826,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results. In Table $\\bigstar$ (Left), we report the mean and $\\mathrm { C V a R } _ { 0 . 1 }$ returns on test episodes from each approach, averaged over 5 random seeds. We show results on the Expert dataset in Appendix $\\underline { { \\vec { \\mathbf { C } . 2 } } }$ CODAC still achieves the strongest performance. As can be seen, CODAC-C and CODAC-N outperform both CQL and ORAAC on most datasets. Surprisingly, CODAC-N is quite effective on the $\\mathrm { C V a R } _ { 0 . 1 }$ metric despite its risk-neutral objective; a likely explanation is that for these datasets, mean and CVaR performance are highly correlated. Furthermore, we observe that directly optimizing CVaR may lead to unstable training, potentially since CVaR estimates have higher variance. This instability occurs for both CODAC-C and ORAAC—on Walker2d-Medium, they perform worse than the risk-neutral algorithms. Overall, CODAC-C outperforms CODAC-N in terms of $\\mathrm { C V a R } _ { 0 . 1 }$ on about half of the datasets, and often improves mean performance as well. Next, while ORAAC is generally effective on Medium datasets, it performs poorly on Mixed datasets; these results mirror the ones in Section $\\boxed { 5 . 1 }$ Finally, CQL’s performance varies drastically across datasets; we hypothesize that learning the full distribution helps stabilize training in CODAC. In Appendix C.2, we also qualitatively analyze the behavior learned by CODAC compared to the baselines, demonstrating that the better CVaR performance CODAC obtains indeed translates to safer locomotion behaviors. ",
+        "bbox": [
+            173,
+            494,
+            825,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 Risk-neutral D4RL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            719,
+            346,
+            734
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Task. Next, we show that CODAC is effective even when the goal is to optimize the standard expected return. To this end, we evaluate CODAC-N on the popular D4RL Mujoco benchmark [10]. ",
+        "bbox": [
+            176,
+            744,
+            825,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We compare to state-of-art algorithms benchmarked in [10] and $\\pm 8 \\mathbb { I }$ , including BatchConstrained Q-Learning (BCQ), Model-Based Offline Policy Optimization (MOPO) $\\pm \\boxed { 4 8 }$ , and CQL. We also include ORAAC as an offline distributional RL baseline. We have omitted less competitive baselines included in $\\pmb { \\mathbb { I O } }$ from the main text; a full comparison is included in Appendix C.3. ",
+        "bbox": [
+            174,
+            779,
+            826,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results. Results for non-distributional approaches are directly taken from $\\boxed { 1 0 }$ ; for ORAAC and CODAC, we evaluate them using 10 test episodes in the environment, averaged over 5 random seeds. As shown in Table 2 (Right), CODAC achieves strong performance across all 12 datasets, obtaining state-of-art results on 5 datasets (walker2d-random, hopper-medium, hopper-mixed, halfcheetahmedium-expert, and walker2d-medium-expert), demonstrating that performance improvements from distributional learning also apply in the offline setting. Note that CODAC’s advantage is not solely due to distributional RL—ORAAC also uses distributional RL, but in most cases underperforms prior state-of-the-art, These results suggest that CODAC’s use of a conservative penalty is critical for it to achieve strong performance. ",
+        "bbox": [
+            174,
+            842,
+            826,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.4 Analysis of Theoretical Insights ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            185,
+            431,
+            200
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We perform additional experiments to validate that our theoretical insights in Section $\\textcircled { 3 }$ hold in practice, suggesting that they help explain CODAC’s empirical performance. ",
+        "bbox": [
+            173,
+            220,
+            356,
+            318
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/d4f9b23cd233e4c7c19ea1d8370506d02d7f0eb5d82f67dc3b7f003c087fec57.jpg",
+        "table_caption": [
+            "Table 3: Monte-Carlo estimate vs. critic prediction. The CODACpredicted expected and $\\mathrm { C V a R } _ { 0 . 1 }$ return is a lower bound on a MC estimate of the true value. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Regular</td><td colspan=\"2\">Walker2d-Medium</td><td colspan=\"2\">Walker2d-Mixed</td><td colspan=\"2\">Walker2d-Medium-Expert</td></tr><tr><td>MC Return</td><td>Q-Estimate</td><td>MC Return</td><td>Q-Estimate</td><td>MC Return</td><td>Q-Estimate</td></tr><tr><td>CODAC</td><td>240.2</td><td>55.7</td><td>127.1</td><td>97.6</td><td>370.</td><td>39.7</td></tr><tr><td>CQL</td><td>247.2</td><td>53.0</td><td>124.5</td><td>-45.2</td><td>369.7</td><td>116.4</td></tr><tr><td>ORAAC</td><td>245.2</td><td>302.2</td><td>118.2</td><td>7.70×105</td><td>68.2</td><td>322.2</td></tr><tr><td>Stochastic</td><td>Walker2d-Medium MC CVaR0.1</td><td>Z-Estimate</td><td>Walker2d-Mixed MC CVaR0.1</td><td>Z-Estimate</td><td>Walker2d-Medium-Expert MC CVaR0.1</td><td>Z-Estimate</td></tr><tr><td>CODAC</td><td>185.7</td><td>204.2</td><td>85.6</td><td>59.9</td><td>265.3</td><td>-127.8</td></tr><tr><td>ORAAC</td><td>201.9</td><td>367.6</td><td>50.9</td><td>1.54×106</td><td>199.5</td><td>343.5</td></tr></table>",
+        "bbox": [
+            369,
+            272,
+            823,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lower bound. We show that in practice, CODAC obtains conservative estimates of the $Q$ and CVaR objectives across different dataset ",
+        "bbox": [
+            173,
+            324,
+            356,
+            392
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "types (i.e., Medium vs. Mixed vs. Medium-Expert). Given an initial state $s _ { 0 }$ , we obtain a Monte Carlo (MC) estimate of $Q$ and CVaR for $( s _ { 0 } , \\pi ( s _ { 0 } ) )$ based on sampled rollouts from $s _ { 0 }$ , and compare them to the values predicted by the critic. In Table $\\triangledown$ we show results averaged over 10 random $s _ { 0 }$ and with $1 0 0 \\mathrm { M C }$ samples for each $s _ { 0 }$ . CODAC obtains conservative estimates for both $Q$ and $\\mathrm { C V a R }$ ; in contrast, ORAAC overestimates these values, especially on Mixed datasets, and CQL only obtains conservative estimates for $Q$ , not CVaR. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            476
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gap-Expansion. Next, we verify that CODAC’s quantile estimates expand their gap between in-distribution and out-of-distribution actions. We use the D4RL ",
+        "bbox": [
+            173,
+            482,
+            356,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/b5e2aee2bfa941d3057fd9e89b3e2e04d301f68f2f408fb9aac8b3998f2dae8f.jpg",
+        "table_caption": [
+            "Table 4: Gap-expansion: CODAC expands the quantile gap and obtains higher returns than an ablation without the conservative penalty. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">HalfCheetah-Medium-Expert</td><td rowspan=\"2\">Hopper-Medium-Expert Positive Gap %</td><td rowspan=\"2\">Return</td><td colspan=\"2\">Walker2d-Medium-Expert</td></tr><tr><td>Positive Gap %</td><td>Return</td><td>Positive Gap %</td><td>Return</td></tr><tr><td>CODAC</td><td>95.3</td><td>93.6</td><td>91.3</td><td>111.9</td><td>91.1</td><td>111.3</td></tr><tr><td>CODAC w.o. Penalty</td><td>4.7</td><td>12.1</td><td>8.7</td><td>25.8</td><td>8.9</td><td>5.9</td></tr></table>",
+        "bbox": [
+            369,
+            521,
+            823,
+            563
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Medium-Expert datasets where CODAC uniformly performs well, making them ideal for understanding the source of CODAC’s empirical performance. We train “CODAC w.o. Penalty”, a non-conservative variant of CODAC (i.e., $\\alpha = 0$ ), and use its actor as $\\mu$ and its critic as $F _ { Z ^ { \\pi } } ^ { - 1 }$ . Next, for each dataset, we randomly sample 1000 state-action pairs and 32 quantiles $\\tau$ , resulting in 32000 $( s , a , \\tau )$ tuples; for each one, we compute the quantile gaps for CODAC and CODAC w.o. Penalty. In Table $\\textcircled { 4 }$ we show the percentage of tuples where each CODAC variant has a larger quantile gap, along with their average return. As can be seen, CODAC has a larger gap for more than $9 0 \\%$ of the tuples on all datasets, as well as significantly higher returns. These results show that gap-expansion holds in practice and suggest that it helps CODAC achieve good performance. ",
+        "bbox": [
+            173,
+            564,
+            826,
+            690
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            720,
+            299,
+            738
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have introduced Conservative Offline Distributional Actor-Critic (CODAC), a general purpose offline distributional reinforcement learning algorithm. We have proven that CODAC obtains conservative estimates of the return quantile, which translate into lower bounds on $Q$ and CVaR values. In our experiments, CODAC outperforms prior approaches on both stochastic, risk-sensitive offline RL benchmarks, as well as traditional, risk-neutral benchmarks. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "One limitation of our work is that CODAC has hyperparameters that must be tuned (in particular, the penalty magnitude $\\alpha$ ). As in prior work, we choose these hyperparameters by evaluate online rollouts in the environment. Designing better hyperparameter selection strategies for offline RL is an important direction for future work. Finally, we do not foresee any societal impacts or ethical concerns for our work, other than the usual risks around algorithms for improving robotics capabilities. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work is funded in part by an Amazon Research Award, gift funding from NEC Laboratories America, NSF Award CCF-1910769, and ARO Award W911NF-20-1-0080. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            178
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            198,
+            266,
+            213
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Rishabh Agarwal, Dale Schuurmans, and Mohammad Norouzi. An optimistic perspective on offline reinforcement learning. In International Conference on Machine Learning, pages 104–114. PMLR, 2020.   \n[2] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   \n[3] Gabriel Barth-Maron, Matthew W Hoffman, David Budden, Will Dabney, Dan Horgan, Dhruva Tb, Alistair Muldal, Nicolas Heess, and Timothy Lillicrap. Distributed distributional deterministic policy gradients. arXiv preprint arXiv:1804.08617, 2018.   \n[4] Marc G Bellemare, Will Dabney, and Rémi Munos. A distributional perspective on reinforcement learning. In International Conference on Machine Learning, pages 449–458. PMLR, 2017.   \n[5] Yinlam Chow, Mohammad Ghavamzadeh, Lucas Janson, and Marco Pavone. Risk-constrained reinforcement learning with percentile risk criteria. The Journal of Machine Learning Research, 18(1):6070–6120, 2017.   \n[6] Will Dabney, Georg Ostrovski, David Silver, and Rémi Munos. Implicit quantile networks for distributional reinforcement learning. In International conference on machine learning, pages 1096–1105. PMLR, 2018.   \n[7] Will Dabney, Mark Rowland, Marc Bellemare, and Rémi Munos. Distributional reinforcement learning with quantile regression. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.   \n[8] Thomas Degris, Martha White, and Richard S Sutton. Off-policy actor-critic. arXiv preprint arXiv:1205.4839, 2012.   \n[9] Damien Ernst, Pierre Geurts, and Louis Wehenkel. Tree-based batch mode reinforcement learning. Journal of Machine Learning Research, 6:503–556, 2005.   \n[10] Justin Fu, Aviral Kumar, Ofir Nachum, George Tucker, and Sergey Levine. D4rl: Datasets for deep data-driven reinforcement learning. arXiv preprint arXiv:2004.07219, 2020.   \n[11] Scott Fujimoto, Herke Hoof, and David Meger. Addressing function approximation error in actor-critic methods. In International Conference on Machine Learning, pages 1587–1596. PMLR, 2018.   \n[12] Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. In International Conference on Machine Learning, pages 2052–2062. PMLR, 2019.   \n[13] Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Offpolicy maximum entropy deep reinforcement learning with a stochastic actor. In International Conference on Machine Learning, pages 1861–1870. PMLR, 2018.   \n[14] Matteo Hessel, Joseph Modayil, Hado Van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.   \n[15] Peter J. Huber. Robust Estimation of a Location Parameter. The Annals of Mathematical Statistics, 35(1):73 – 101, 1964.   \n[16] Nan Jiang and Lihong Li. Doubly robust off-policy value evaluation for reinforcement learning, 2016.   \n[17] Ramtin Keramati, Christoph Dann, Alex Tamkin, and Emma Brunskill. Being optimistic to be conservative: Quickly learning a cvar policy. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 4436–4443, 2020.   \n[18] Rahul Kidambi, Aravind Rajeswaran, Praneeth Netrapalli, and Thorsten Joachims. Morel: Model-based offline reinforcement learning. arXiv preprint arXiv:2005.05951, 2020.   \n[19] Roger Koenker and Kevin F Hallock. Quantile regression. Journal of economic perspectives, z15(4):143–156, 2001.   \n[20] Aviral Kumar, Justin Fu, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning via bootstrapping error reduction. arXiv preprint arXiv:1906.00949, 2019.   \n[21] Aviral Kumar, Aurick Zhou, George Tucker, and Sergey Levine. Conservative q-learning for offline reinforcement learning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 1179–1191. Curran Associates, Inc., 2020.   \n[22] Sascha Lange, Thomas Gabel, and Martin Riedmiller. Batch reinforcement learning. In Reinforcement learning, pages 45–73. Springer, 2012.   \n[23] Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643, 2020.   \n[24] 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.   \n[25] Qiang Liu, Lihong Li, Ziyang Tang, and Dengyong Zhou. Breaking the curse of horizon: Infinite-horizon off-policy estimation. arXiv preprint arXiv:1810.12429, 2018.   \n[26] Clare Lyle, Marc G Bellemare, and Pablo Samuel Castro. A comparative analysis of expected and distributional reinforcement learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 4504–4511, 2019.   \n[27] Xiaoteng Ma, Qiyuan Zhang, Li Xia, Zhengyuan Zhou, Jun Yang, and Qianchuan Zhao. Distributional soft actor critic for risk sensitive learning. arXiv preprint arXiv:2004.14547, 2020.   \n[28] Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International conference on machine learning, pages 1928–1937. PMLR, 2016.   \n[29] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.   \n[30] 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.   \n[31] Thanh Tang Nguyen, Sunil Gupta, and Svetha Venkatesh. Distributional reinforcement learning via moment matching, 2020.   \n[32] Doina Precup. Eligibility traces for off-policy policy evaluation. Computer Science Department Faculty Publication Series, page 80, 2000.   \n[33] Martin L Puterman. Markov decision processes: discrete stochastic dynamic programming. John Wiley & Sons, 2014.   \n[34] Martin Riedmiller. Neural fitted q iteration–first experiences with a data efficient neural reinforcement learning method. In European Conference on Machine Learning, pages 317–328. Springer, 2005.   \n[35] R Tyrrell Rockafellar and Stanislav Uryasev. Conditional value-at-risk for general loss distributions. Journal of banking & finance, 26(7):1443–1471, 2002.   \n[36] Mark Rowland, Robert Dadashi, Saurabh Kumar, Rémi Munos, Marc G Bellemare, and Will Dabney. Statistics and samples in distributional reinforcement learning. In International Conference on Machine Learning, pages 5528–5536. PMLR, 2019.   \n[37] Simon P. Shen, Yecheng Jason Ma, Omer Gottesman, and Finale Doshi-Velez. State relevance for off-policy evaluation, 2021.   \n[38] Yichuan Charlie Tang, Jian Zhang, and Ruslan Salakhutdinov. Worst cases policy gradients. arXiv preprint arXiv:1911.03618, 2019.   \n[39] Philip Thomas and Emma Brunskill. Data-efficient off-policy policy evaluation for reinforcement learning. In International Conference on Machine Learning, pages 2139–2148. PMLR, 2016.   \n[40] Sebastian Thrun and Anton Schwartz. Issues in using function approximation for reinforcement learning. In Proceedings of the Fourth Connectionist Models Summer School, pages 255–263. Hillsdale, NJ, 1993.   \n[41] Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 5026–5033. IEEE, 2012.   \n[42] Amos Tversky and Daniel Kahneman. Advances in prospect theory: Cumulative representation of uncertainty. Journal of Risk and uncertainty, 5(4):297–323, 1992.   \n[43] Núria Armengol Urpí, Sebastian Curi, and Andreas Krause. Risk-averse offline reinforcement learning. arXiv preprint arXiv:2102.05371, 2021.   \n[44] Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double q-learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 30, 2016.   \n[45] Shaun S Wang. A class of distortion operators for pricing financial and insurance risks. Journal of risk and insurance, pages 15–36, 2000.   \n[46] Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement learning. arXiv preprint arXiv:1911.11361, 2019.   \n[47] Derek Yang, Li Zhao, Zichuan Lin, Tao Qin, Jiang Bian, and Tieyan Liu. Fully parameterized quantile function for distributional reinforcement learning. arXiv preprint arXiv:1911.02140, 2019.   \n[48] Tianhe Yu, Garrett Thomas, Lantao Yu, Stefano Ermon, James Y Zou, Sergey Levine, Chelsea Finn, and Tengyu Ma. Mopo: Model-based offline policy optimization. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 14129–14142. Curran Associates, Inc., 2020.   \n[49] Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. In Aaai, volume 8, pages 1433–1438. Chicago, IL, USA, 2008. ",
+        "bbox": [
+            171,
+            208,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            54,
+            828,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            22,
+            828,
+            835
+        ],
+        "page_idx": 12
+    }
+]

parse/train/wTutcPE7zOC/wTutcPE7zOC.md

@@ -0,0 +1,444 @@
+# Metropolis-CVAE: Bootstrapping Labels for Bayesian Inference via Semi-Supervised Conditional Variational Autoencoders
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 In Bayesian parameter estimation, models make simplifying assumptions to make   
+2 parameter inference feasible. If learned inference methods are trained using data   
+3 simulated by models, however, distributional differences between simulated and   
+4 observed data may lead to biased inference results on the observed data. In this   
+5 work, we introduce a semi-supervised learned Bayesian inference method which   
+6 makes use of both simulated data – for which the underlying parameters are known   
+7 by construction – and unlabeled data, which may depend on nuissance parameters   
+8 not captured by the simulation procedure. A conditional variational autoencoder   
+9 (CVAE) is trained to perform approximate inference simultaneously on the sets of   
+10 labeled simulated data and unlabeled data, where the unlabeled data is initialized   
+11 with arbitrary pseudo labels. At each training iteration, new candidate pseudo   
+12 labels are drawn from the CVAE posterior and the pseudo labels are updated using   
+13 the Metropolis-Hastings algorithm. This process results in a Markov chain of   
+14 bootstrapped pseudo labels for each unlabeled datum, effectively performing online   
+15 Markov chain Monte Carlo (MCMC) inference wherein the proposal distribution   
+16 is a CVAE informed by labeled simulated data, producing proposals which are   
+17 increasingly likely to be accepted as training proceeds. The resulting CVAE is   
+18 able to efficiently produce samples from the posterior distributions of both the   
+19 simulated and unlabeled data, implicitly marginalizing over nuissance parameters   
+20 in the unlabeled data. We demonstrate the effectiveness of this method in magnetic   
+21 resonance imaging (MRI) where MCMC is computationally impractical to due the   
+22 $( 3 + 1 ) \mathrm { D }$ nature of the images, showing improvement against traditional MCMC   
+23 inference in both speed and posterior quality.
+
+# 24 1 Introduction
+
+25 Bayesian parameter estimation methods are robust techniques for quantifying properties of a system   
+26 that cannot be observed directly [1]. In order to estimate such parameters, one first needs to develop   
+27 a model of the phenomena to be studied. This process requires deep domain-specific knowledge. For   
+28 all but the most basic of systems, a series of simplifying assumptions on the system are required to   
+29 make parameter inference tractable. Typically, tractable is synonymous with not being unreasonably   
+30 expensive to compute. Examples of such methodologies include perturbation theory, in which models   
+31 containing Taylor series expansions drop higher order terms; mean-field theory, in which interactions   
+32 involving many degrees of freedom are replaced by averaged approximations; and (stochastic)   
+33 differential equations, when used as continuous limits of discrete stochastic processes. The price one   
+34 pays for utilizing a given approximation is highly problem dependent. When approximate models   
+35 are used for parameter inference, the mismatch between model predictions and data may propagate   
+36 through the inference process and lead to bias and other misestimations of the inferred parameters. In   
+37 this work, we are interested in the following research question: can a deep learning model be trained   
+38 to perform inference, while incorporating both labeled data generated from a well-understood model,   
+39 and unlabeled data which contains additional complex structure which cannot be modeled?   
+40 Here, we present Metropolis conditional variational autoencoders (Metropolis-CVAEs). Metropolis  
+41 CVAEs combine traditional CVAEs with the Metropolis-Hastings Markov chain monte carlo (MCMC)   
+42 inference method. The resulting networks combine the ability of CVAEs to learn to perform rapid   
+43 approximate Bayesian inference from labeled data with traditional MCMC methodology which   
+44 requires only a likelihood model and a prior distribution over the parameters of interest. The   
+45 Metropolis-CVAE initializes the unlabeled data with pseudo labels drawn from the prior distribution   
+46 and, informed by the labeled data, iteratively improves the pseudo labels throughout training. We   
+47 demonstrate the effectiveness of the Metropolis-CVAE network compared to traditional MCMC   
+48 methods on an inference problem from magnetic resonance imaging (MRI) which is inherently   
+49 computationally challenging due to the $( 3 + 1 ) \mathrm { D }$ nature of the data.
+
+# 2 Methods
+
+# 2.1 Related work
+
+In the pioneering work by Sohn et al. [2], conditional variational autoencoders were introduced by considering a variational lower bound to the conditional log-likelihood $\log p ( \mathbf { y } | \mathbf { x } )$ of labels $\mathbf { y }$ given corresponding data $\mathbf { x }$ . Ideally, to perform data-driven approximate inference, one would like to train a network to learn to maximize the conditional log-likelihood directly. However, this is known to be an intractable problem. To mitigate this issue, the stochastic gradient variational Bayes (SGVB) framework is employed. In SGVB, a latent space which factorizes the marginal likelihood is introduced via $\begin{array} { r } { p ( \mathbf { y } | \mathbf { x } ) = \int _ { \mathbf { z } } \mathrm { d } \mathbf { z } p ( \mathbf { z } | \mathbf { x } ) p ( \mathbf { y } | \mathbf { z } , \mathbf { x } ) } \end{array}$ , as well as a recognition distribution $q ( \mathbf { z } | \mathbf { x } , \mathbf { y } )$ . The conditional log-likelihood is then maximized indirectly via maximizing the variational lower bound
+
+$$
+\begin{array} { r l } & { \log p ( \mathbf { y } | \mathbf { x } ) \geq - \mathrm { K L } \left( q ( \mathbf { z } | \mathbf { x } , \mathbf { y } ) \left| \right| p ( \mathbf { z } | \mathbf { x } ) \right) + \mathbb { E } _ { q ( \mathbf { z } | \mathbf { x } , \mathbf { y } ) } \left[ \log p ( \mathbf { y } | \mathbf { x } , \mathbf { z } ) \right] } \\ & { \qquad : = - \mathcal { L } ( \mathbf { x } , \mathbf { y } ) } \end{array}
+$$
+
+60 where $\mathrm { K L }$ is the Kullback-Leibler divergence. The interpretation as a conditional autoencoder is   
+61 as follows: let $p ( \mathbf { z } | \mathbf { x } )$ , $q ( \mathbf { z } | \mathbf { x } , \mathbf { y } )$ , and $p ( \mathbf { y } | \mathbf { x } , \mathbf { z } )$ be parameterized by deep neural networks $E _ { 1 } ( \mathbf { z } | \mathbf { x } )$ ,   
+62 $E _ { 2 } ( \mathbf { z } | \mathbf { x } , \mathbf { y } )$ , and $D ( \mathbf { y } | \mathbf { x } , \mathbf { z } )$ , respectively. Then, $E _ { 1 }$ and $E _ { 2 }$ can be viewed as encoders which map   
+63 their inputs into distributions over the latent variables $\mathbf { z }$ . $D$ can be viewed as a decoder which maps   
+64 stochastic latent representations $\mathbf { z }$ and data $\mathbf { x }$ into posterior distributions over the labels y. Hence, $\mathbf { y }$   
+65 is conditionally autoencoded via the encoder-decoder pipeline $\mathbf { z } \sim E _ { 2 } ( \mathbf { z } | \mathbf { x } , \mathbf { y } )  \mathbf { y } \sim D ( \mathbf { y } | \mathbf { x } , \mathbf { z } )$ .   
+66 At inference time, posterior samples are similarly drawn via $\mathbf { z } \sim E _ { 1 } ( \mathbf { z } | \mathbf { x } )  \mathbf { y } \sim D ( \mathbf { y } | \mathbf { x } , \mathbf { z } )$ . The   
+67 CVAE – the triplet of networks $( E _ { 1 } , E _ { 2 } , D ) -$ is trained by minimizing $\mathcal { L }$ over the CVAE parameters,   
+68 thereby maximizing the variational lower bound on $\log p ( \mathbf { y } | \mathbf { x } )$ .   
+69 The CVAE approach by Sohn et al. [2] is designed for supervised learning problems. Earlier work of   
+70 a similar vein by Kingma et al. [3] introduces a semi-supervised framework in which labeled data   
+71 $\left( \mathbf { x } _ { \ell } , \mathbf { y } \right)$ is used to infer labels for unlabeled data $\mathbf { x } _ { u }$ via the minimization of a two-term loss function.   
+72 The first term of the loss function is a supervised loss over $\left( \mathbf { x } _ { \ell } , \mathbf { y } \right)$ samples, similar to Equation 1,   
+73 derived from a variational lower bound on the joint log-likelihood $\log p ( \mathbf { x } _ { \ell } , \mathbf { y } )$ . The second term is an   
+74 unsupervised loss over $\mathbf { x } _ { u }$ samples which treats label inference as a data imputation task. Specifically,   
+75 the unknown label is treated as a parameter over which posterior inference is performed; the resulting   
+76 loss is a variational lower bound on the log-likelihood $\bar { \log { p ( \mathbf { x } _ { u } ) } }$ .   
+77 While the semi-supervised method of Kingma et al. is an elegant approach to discovering labels,   
+78 it is not quite suitable for inferring labels for out of distribution data. This is due to the implicit   
+79 assumption that relationships between $\mathbf { x } _ { \ell }$ and $\mathbf { y }$ learned from the joint distribution $p ( \mathbf x _ { \ell } , \mathbf y )$ generalize   
+80 to data from $p ( \mathbf { x } _ { u } )$ . In fact, this assumption is made explicit via an extended objective function which   
+81 adds a regularization term $\mathbb { E } _ { \widetilde { p } _ { \ell } ( \mathbf { x } , \mathbf { y } ) } \left[ - \log q ( \mathbf { y } | \mathbf { x } _ { \ell } ) \right]$ over the empirical distribution $\widetilde { p } _ { \ell } ( \mathbf { x } , \mathbf { y } )$ of labeled   
+82 edata. This penalty encourages the learned posterior distribution $q ( \mathbf { y } \vert \mathbf { x } )$ e to generate labels for $\mathbf { x } _ { u }$ by   
+83 extrapolating from the relationships it discovers between $\left( \mathbf { x } _ { \ell } , \mathbf { y } \right)$ pairs. This will naturally lead to   
+84 biased labels for $\mathbf { x } _ { u }$ when the distribution underlying $\mathbf { x } _ { u }$ differs from that of $\mathbf { x } _ { \ell }$ .   
+85 Gabbard et al., who made use of CVAEs to accelerate inference for an application in gravitational   
+86 wave astronomy [4], presented an alternate view of Equation 1. Gabbard et al. begin by aiming to   
+87 minimize the expected cross-entropy
+
+$$
+\mathcal { H } : = - \mathbb { E } _ { p ( \mathbf { x } ) } \left[ \int _ { \mathbf { y } } \mathrm { d } \mathbf { y } p ( \mathbf { y } | \mathbf { x } ) \log \hat { p } ( \mathbf { y } | \mathbf { x } ) \right]
+$$
+
+88 over the data distribution $p ( \mathbf { x } )$ between the true posterior $p ( \mathbf { y } \vert \mathbf { x } )$ and approximate posterior ${ \hat { p } } ( \mathbf { y } | \mathbf { x } )$ . Employing the SGVB framework and letting 89 $\begin{array} { r } { \hat { p } ( \mathbf { y } | \mathbf { x } ) = \int _ { \mathbf { z } } \mathrm { d } \mathbf { z } \hat { p } ( \mathbf { z } | \mathbf { x } ) \hat { p } ( \mathbf { y } | \mathbf { z } , \mathbf { x } ) } \end{array}$ , it follows from 1 that
+
+$$
+\mathcal { H } \leq \mathbb { E } _ { p ( \mathbf { x } ) } \left[ \int _ { \mathbf { y } } \mathrm { d } \mathbf { y } p ( \mathbf { y } | \mathbf { x } ) \mathcal { L } ( \mathbf { x } , \mathbf { y } ) \right] .
+$$
+
+90 Applying Bayes’ theorem, we equivalently have that
+
+$$
+\begin{array} { r l } & { \mathcal { H } \leq \mathbb { E } _ { p ( \mathbf { x } ) } \mathbb { E } _ { p ( \mathbf { y } \mid \mathbf { x } ) } \left[ \mathcal { L } ( \mathbf { x } , \mathbf { y } ) \right] } \\ & { \quad = \mathbb { E } _ { p ( \mathbf { y } ) } \mathbb { E } _ { p ( \mathbf { x } \mid \mathbf { y } ) } \left[ \mathcal { L } ( \mathbf { x } , \mathbf { y } ) \right] } \\ & { \quad = \mathbb { E } _ { p ( \mathbf { x } , \mathbf { y } ) } \left[ \mathcal { L } ( \mathbf { x } , \mathbf { y } ) \right] . } \end{array}
+$$
+
+91 Therefore, maximizing the variational lower bound to $\log p ( \mathbf { y } | \mathbf { x } )$ over a dataset of $\displaystyle ( \mathbf { x } , \mathbf { y } )$ pairs, as in   
+92 Equation 1, is equivalent to minimizing the expected cross-entropy via Equation 6. The interpretation   
+93 of Equations 4 and 5, however, will prove useful for remedying the issue of label inference for out of   
+94 distribution data.
+
+# 95 2.2 Theoretical contributions
+
+96 Equation 5 is a natural framework for using CVAEs to perform inference on simulated data with   
+97 known labels [4]. Suppose labels $\mathbf { y } \sim p ( \mathbf { y } )$ are sampled from a prior distribution and $\mathbf { x } \sim p ( \mathbf { x } | \mathbf { y } )$   
+98 is subsequently given by a (possibly stochastic) model function $\mathbf { x } = f ( \mathbf { y } )$ . Then, Equation 5   
+99 corresponds to minimizing the average CVAE loss $\mathcal { L } ( \mathbf { x } , \mathbf { y } )$ over pairs of simulated data $( \mathbf { x } = f ( \mathbf { y } ) , \mathbf { y } )$ .   
+100 The novel contribution of this work stems from of Equation 4. Using this formulation directly would   
+101 require sampling from the posterior $p ( \mathbf { y } \vert \mathbf { x } )$ , which is our stated objective. However, this can be   
+102 circumvented by making the observation that if we could construct a Markov chain of pseudo labels   
+103 $\widetilde { \mathbf { y } }$ during training, such that the stationary distribution of the sequence $( \widetilde { \mathbf { y } } _ { k } ) _ { k \in \mathbb { N } }$ was $p ( \mathbf { y } \vert \mathbf { x } )$ , then   
+104 eEquation 4 could be approximated as
+
+$$
+\mathbb { E } _ { p ( \mathbf { x } ) } \mathbb { E } _ { p ( \mathbf { y } | \mathbf { x } ) } \left[ \mathcal { L } ( \mathbf { x } , \mathbf { y } ) \right] \approx \mathbb { E } _ { p ( \mathbf { x } ) } \left[ \frac { 1 } { L _ { c } } \sum _ { i = 0 } ^ { L _ { c } - 1 } \mathcal { L } ( \mathbf { x } , \widetilde { \mathbf { y } } _ { n - i } ) \right]
+$$
+
+105 where $( \widetilde { \mathbf { y } } _ { n - L _ { c } + 1 } , \ldots , \widetilde { \mathbf { y } } _ { n } )$ are the $L _ { c }$ most recent samples in the Markov chain. This approach to   
+106 e edistribution sampling – Markov chain Monte Carlo (MCMC) sampling – is considered the gold   
+107 standard in parameter inference.   
+108 In this work, we consider the Metropolis-Hastings (MH) algorithm [5, 6]. In the context of Bayesian   
+109 inference for recovering labels $\mathbf { y }$ from data $\mathbf { x }$ , MH sampling begins with a prior distribution $p ( \mathbf { y } )$ , a   
+110 likelihood function $p ( \mathbf { x } | \mathbf { y } )$ , and a proposal distribution $Q ( \mathbf { y } ^ { \prime } | \mathbf { y } )$ which quantifies the probability of   
+111 transitioning from y to $\mathbf { y } ^ { \prime }$ in the space of possible labels. Given a sample ${ \bf y } _ { n }$ of a Markov chain, the   
+112 MH update rule is given by
+
+![](images/97cf94220a9e5f30dc3213d1f093a81f544c1b859c6af51de3cb1c59aca7af8f.jpg)  
+Figure 1: (A-G) Comparison of inference results for data simulated using Equation 14 with parameters drawn from Equation 17. Histograms of errors between the means of the empirical distributions and the true labels are shown. $\mathrm { ( H ) }$ ) p-p plot for each label. In all plots, MCMC with 100 samples, MCMC with 3000 samples, and Metropolis-CVAE with 100 samples are shown in red, green, and blue, respectively.
+
+$$
+\begin{array} { r l } & { \mathbf { y } ^ { \prime } \sim Q ( \mathbf { y } ^ { \prime } | \mathbf { y } _ { n } ) } \\ & { \alpha = \operatorname* { m i n } ( 1 , \frac { p ( \mathbf { y } ^ { \prime } ) } { p ( \mathbf { y } _ { n } ) } \cdot \frac { p ( \mathbf { x } | \mathbf { y } ^ { \prime } ) } { p ( \mathbf { x } | \mathbf { y } _ { n } ) } ) } \\ & { u \sim \mathrm { U n i f o r m } ( 0 , 1 ) } \\ & { \mathbf { y } _ { n + 1 } = \{ \mathbf { y } ^ { \prime } \quad u \leq \alpha  } \\ & {  \mathbf { y } _ { n } + \mathrm { o t h e r w i s e } . } \end{array}
+$$
+
+113 The proposal distribution $Q ( \mathbf { y } ^ { \prime } | \mathbf { y } )$ is a free parameter of the MH algorithm. In general, choosing $Q$   
+114 to resemble the true posterior as closely as possible improves the efficiency of the MH algorithm.   
+115 Therefore, we propose to use the approximate posterior ${ \hat { p } } ( \mathbf { y } | \mathbf { x } )$ of the CVAE itself as the proposal   
+116 distribution. Recalling that $\begin{array} { r } { \hat { p } ( { \bf y } | { \bf x } ) = \int _ { \bf z } \mathrm { d } { \bf z } \hat { p } ( { \bf z } | { \bf x } ) \hat { p } ( { \bf y } | { \bf z } , { \bf x } ) : = \int _ { \bf z } \mathrm { d } { \bf z } E _ { 1 } ( { \bf z } | { \bf x } ) D ( { \bf y } | { \bf z } , { \bf x } ) } \end{array}$ , we let
+
+$$
+\begin{array} { r l r } {  { Q ( \mathbf { y } ^ { \prime } | \mathbf { y } _ { n } ) = Q ( \mathbf { y } ^ { \prime } ) = \int _ { \mathbf { z } } \mathrm { d } \mathbf { z } E _ { 1 } ( \mathbf { z } | \mathbf { x } ) D ( \mathbf { y } ^ { \prime } | \mathbf { z } , \mathbf { x } ) } } \\ & { } & { \approx \frac { 1 } { L _ { \mathbf { z } } } \sum _ { i = 1 } ^ { L _ { \mathbf { z } } } D ( \mathbf { y } ^ { \prime } | \mathbf { z } _ { i } , \mathbf { x } ) \quad \mathrm { w h e r e } \quad \mathbf { z } _ { i } \sim E _ { 1 } ( \mathbf { z } | \mathbf { x } ) . } \end{array}
+$$
+
+117 By choosing this proposal function, we are able to bootstrap pseudo labels $\widetilde { \mathbf { y } }$ onto unlabeled data $\mathbf { x } _ { u }$ .   
+118 In particular, we minimize the semi-supervised hybrid loss
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mathrm { h y b r i d } } = \mathcal { L } _ { \mathrm { s u p e r } } + \mathcal { L } _ { \mathrm { s e l f } } } \\ & { \mathcal { L } _ { \mathrm { s u p e r } } = \mathbb { E } _ { ( \mathbf { x } _ { \ell } , \mathbf { y } ) \sim \widetilde { p } _ { \ell } ( \mathbf { x } , \mathbf { y } ) } \left[ \mathcal { L } ( \mathbf { x } _ { \ell } , \mathbf { y } ) \right] } \\ & { \quad \mathcal { L } _ { \mathrm { s e l f } } = \mathbb { E } _ { ( \mathbf { x } _ { u } , \widetilde { \mathbf { y } } ) \sim \widetilde { p } _ { u } ( \mathbf { x } , \widetilde { \mathbf { y } } ) } \left[ \mathcal { L } ( \mathbf { x } _ { u } , \widetilde { \mathbf { y } } ) \right] } \end{array}
+$$
+
+![](images/b3d49121ec203886e2bc9c61ce626fb10e54c05e6823fcb7acd2debb6477c954.jpg)  
+Figure 2: (A) Pseudo label acceptance rate vs. epochs for the MRI datasets $\widetilde { p } _ { \ell , 1 } ( \mathbf { x } )$ and $\widetilde { p } _ { \ell , 2 } ( \mathbf { x } )$ . (B) e eWasserstein distance vs. epochs between empirical label distributions and MCMC with 100 posterior samples, and (C) same as (B) but MCMC with 3000 posterior samples.
+
+119 where $\widetilde { p } _ { \ell } ( \mathbf x , \mathbf y )$ and $\widetilde { p } _ { u } ( \mathbf { x } , \widetilde { \mathbf { y } } )$ are the empirical distributions over the pairs of labeled data $\left( \mathbf { x } _ { \ell } , \mathbf { y } \right)$   
+120 e e eand unlabeled data with bootstrapped pseudo labels $\left( \mathbf { x } _ { u } , \widetilde { \mathbf { y } } \right)$ , respectively. The pseudolabels $\widetilde { \mathbf { y } }$ are   
+121 initialized uniformly from the prior space $p ( \mathbf { y } )$ e eand are updated according to the MH algorithm 8 at   
+122 each training iteration.   
+123 Note that in the MH update step, the MH acceptance ratio $\alpha$ can be interepreted as computing a   
+124 Bayesian goodness of fit check relative to the current label $\widetilde { \mathbf { y } } _ { n }$ . Therefore, $\widetilde { p } _ { \ell } ( \mathbf { x } )$ and $\widetilde { p } _ { u } ( \mathbf { x } )$ need   
+125 e e enot be identical distributions, merely close enough such that decreasing the supervised loss $\mathcal { L } _ { \mathrm { s u p e r } }$   
+126 improves the proposal quality for the self-supervised loss $\mathcal { L } _ { \mathrm { s e l f } }$ early in training.
+
+# 2.3 MRI physics application
+
+128 We consider an application in magnetic resonance imaging. In MRI, data is typically acquired in   
+129 the form of $( 3 + 1 ) \mathrm { D }$ spatio-temporal grids, with 1D magnetic resonance time signals measured in   
+130 each voxel of the three spatial dimensions. Advanced imaging methods typically involve voxelwise   
+131 parameter inference for each time signal for the computation of quantitative maps. Modeling the   
+132 individual time signals for inference, however, is challenging due to imperfections in the magnetic   
+133 field generated by the scanner and other sources of signal corruption. Effectively, in MRI there is a   
+134 distributional mismatch problem: simulated data $\widetilde { p } _ { \ell } ( \mathbf { x } )$ , with labels corresponding to well understood   
+135 ephysics parameters, does not contain the full distribution of measured data $\widetilde { p } _ { u } ( \mathbf { x } )$ which, while   
+136 egenerated by the same physics in principle, depends on additional nuissance parameters which cannot   
+137 be modeled. Machine learning models which intended to generalize to $\widetilde { p } _ { u } ( \mathbf { x } )$ should therefore not be   
+138 trained only on data from $\widetilde { p } _ { \ell } ( \mathbf { x } )$ .   
+139 In this work, we acquire multi spin-echo (MSE) MRI images. The MSE time signals are modeled   
+140 using a two-component extended phase graph (EPG) model using the algorithm detailed in Prasloski   
+141 et al. [7]. Using this model, the $j$ -th time point for each signal is given by
+
+$$
+\begin{array} { l } { { \displaystyle { \widehat { \mathbf { x } } } _ { j } = f ( j \cdot \mathrm { T E } ) } } \\ { { \displaystyle f ( t ) = \sum _ { \ell = 1 } ^ { 2 } A _ { \ell } \mathrm { E P G } ( t , \alpha , \beta , T _ { 2 , \ell } , T _ { 1 } ) } } \end{array}
+$$
+
+142 where $\alpha$ is the spin flip angle, $\beta$ the refocusing control angle, $A _ { 1 } , A _ { 2 }$ the component amplitudes,   
+143 $T _ { 2 , 1 } \leq T _ { 2 , 2 }$ the short and long transverse relaxation times, and $T _ { 1 }$ the longitudinal relaxation time.   
+144 The $\mathrm { E P G } ( t , \ldots )$ terms are approximately exponentially decaying in $t$ with time constants $T _ { 2 , \ell }$ , with   
+145 additional modifications due to MRI physics determined by $\alpha$ , $\beta$ , and $T _ { 1 }$ . The echo time $\mathrm { T E }$ is the   
+146 uniform spacing between time points. We reparameterize $A _ { 1 }$ , $A _ { 2 }$ , $T _ { 2 , 1 }$ , and $T _ { 2 , 2 }$ in terms of the   
+147 unconstrained parameters $\eta , \delta _ { 1 }$ , and $\delta _ { 2 }$ as follows: $A _ { 1 } = \eta$ , $A _ { 2 } = 1 - \eta$ , $\log T _ { 2 , 1 } = \log T _ { 2 , \mathrm { m i n } } +$   
+148 $( \log T _ { 2 , \mathrm { m a x } } - \log T _ { 2 , \mathrm { m i n } } ) \cdot \delta _ { 1 }$ , and $\log T _ { 2 , 2 } = \log T _ { 2 , \mathrm { m i n } } + \left( \log T _ { 2 , \mathrm { m a x } } - \log T _ { 2 , \mathrm { m i n } } \right) \cdot \left( \delta _ { 1 } + \delta _ { 2 } \cdot \left( 1 - \delta _ { 1 } \right) \right)$ ,   
+149 where $T _ { \mathrm { 2 , m i n } } = 1 0 \mathrm { m s }$ and $T _ { \mathrm { 2 , m a x } } = 1 \mathrm { s }$ . The longitudinal relaxation time is fixed $T _ { 1 } = 1 . 0 \mathrm { s }$ .   
+150 MRI signal noise can be modeled as Rician [8, 9]. Given data $\mathbf { x }$ normalized to have maximum value   
+151 1, the likelihood $p ( \mathbf { x } | \mathbf { y } )$ under Rician noise is given by
+
+$$
+\begin{array} { r l } & { \log p ( { \bf x } | { \bf y } ) = \displaystyle \sum _ { j = 1 } ^ { N _ { \bf x } } \log p _ { \mathrm { R i c e } } \left( { \bf x } _ { j } ~ \middle | \frac { { \boldsymbol s } \cdot \hat { \bf x } ( \boldsymbol \theta ) _ { j } } { \operatorname* { m a x } _ { \boldsymbol k } \hat { \bf x } ( \boldsymbol \theta ) _ { k } } ~ , ~ { \boldsymbol s } \cdot { \boldsymbol \epsilon } \right) , } \\ & { p _ { \mathrm { R i c e } } ( \boldsymbol { \xi } | \nu , \sigma ) = \displaystyle \frac { \boldsymbol { \xi } } { \sigma ^ { 2 } } \exp \left( - \frac { \boldsymbol { \xi } ^ { 2 } + \nu ^ { 2 } } { 2 \sigma ^ { 2 } } \right) I _ { 0 } \left( \frac { \boldsymbol { \xi } \nu } { \sigma ^ { 2 } } \right) } \end{array}
+$$
+
+152 is the Rician probability density function with location parameter $\nu$ and scale parameter $\sigma ; I _ { 0 }$ is   
+153 the modified Bessel function of the first kind with order zero. We have introduced two additional   
+154 parameters: a scale parameter $s$ to account for signal normalization, and a noise level $\epsilon$ relative to this   
+155 scale. Additionally, we denote $\theta = \left( \alpha , \beta , \eta , \delta _ { 1 } , \delta _ { 2 } \right)$ the parameters of the EPG model 14.   
+156 In total, there are 7 labels to be inferred: $\mathbf { y } = ( \alpha , \beta , \eta , \delta _ { 1 } , \delta _ { 2 } , \log \epsilon , \log s )$ . We place the following   
+157 priors on the parameters:
+
+$$
+\begin{array} { c c } { { \begin{array} { l } { \alpha \sim { \mathcal { T N } } ( 1 8 0 ^ { \circ } , 4 5 ^ { \circ } , 9 0 ^ { \circ } , 1 8 0 ^ { \circ } ) } \\ { \beta \sim { \mathcal { T N } } ( 1 8 0 ^ { \circ } , 4 5 ^ { \circ } , 9 0 ^ { \circ } , 1 8 0 ^ { \circ } ) } \\ { \eta \sim { \mathcal { T N } } ( 0 . 0 , 0 . 5 , 0 . 0 , 1 . 0 ) } \\ { \delta _ { 1 } \sim { \mathcal { T N } } ( 0 . 0 , 0 . 5 , 0 . 0 , 1 . 0 ) } \end{array} } } & { { \begin{array} { r } { \delta _ { 2 } \sim { \mathcal { T N } } ( 1 . 0 , 0 . 5 , 0 . 0 , 1 . 0 ) } \\ { \log \epsilon \sim { \mathcal { U } } ( \log 1 0 ^ { - 5 } , \log 1 0 ^ { - 1 } ) } \\ { \log s \sim { \mathcal { T N } } ( 0 . 0 , 0 . 5 , - 2 . 5 , 2 . 5 ) } \end{array} } } \end{array}
+$$
+
+158 where $\mathcal { T N } ( \mu , \sigma , a , b )$ is the normal distribution with parameters $( \mu , \sigma )$ truncated to the interval $[ a , b ]$ ,   
+159 and $\boldsymbol { \mathcal { U } } ( a , b )$ is the uniform distribution on $[ a , b ]$ . The priors were chosen to align with the expectations   
+160 that: $\alpha , \beta$ are typically near $1 8 0 ^ { \circ }$ ; the short component amplitude $\eta$ is typically less than the long   
+161 amplitude $1 - \eta ; \delta _ { 1 }$ and $\delta _ { 2 }$ should prefer to represent the shortest and longest components; the noise   
+162 level $\epsilon$ is chosen uniformly from signal-to-noise ratios between 20 and 100; the scale parameter $s$   
+163 should prefer to be 1.
+
+# 3 Experiments
+
+# 3.1 Data sets
+
+166 MRI data The MRI data used for this study consists of two anonymized brain scans acquired using   
+167 a Carr-Purcell-Meiboom-Gill (CPMG) [10, 11] multi spin-echo sequence [12]. The first data set,   
+168 denoted $\widetilde { p } _ { u , 1 } ( \mathbf { x } )$ , contains signals with $N _ { \mathbf { x } , 1 } = 4 8$ samples at times $t _ { i } = i \cdot \mathrm { T E }$ , with echo spacing   
+169 $\mathrm { T E } = 8 \mathrm { m s }$ , repetition time $\mathrm { T R } = 1 0 7 3 \mathrm { m }$ s, matrix size $2 4 0 \times 2 4 0 \times 4 8$ , and spatial resolution   
+170 $0 . 9 6 \times 0 . 9 6 \times 2 . 5 \mathrm { m m ^ { 3 } }$ . The second data set, denoted $\widetilde { p } _ { u , 2 } ( \mathbf { x } )$ , contains signals with $N _ { \mathbf { x } , 2 } = 5 6$   
+171 samples at times $t _ { i } = i \cdot \mathrm { T E }$ , with echo spacing $\mathrm { T E } = 7 \mathrm { m s }$ , repetition time $\mathrm { T R } = 1 0 6 6 \mathrm { m s } .$   
+172 matrix size $2 4 0 \times 2 4 0 \times 1 1 3$ , and spatial resolution $1 . 0 \times 1 . 0 \times 3 . 0 \mathrm { { \dot { m } m } ^ { 3 } }$ . Following the extraction   
+173 of image volumes containing the brain, $\widetilde { p } _ { u , 1 } ( \mathbf { x } )$ and $\widetilde { p } _ { u , 2 } ( \mathbf { x } )$ contain 821 145 and 1 265 306 signals,   
+174 erespectively. MRI data was acquired on a $3 \mathrm { T }$ eMR system (Ingenia Elition, Philips Medical Systems,   
+175 Best, The Netherlands) from healthy volunteers giving written and informed consent, and approved   
+176 by our university ethics board.   
+177 Simulated data Using the EPG physics model 14 with Rician noise, we consider two simulated   
+178 data sets. First, the labeled data set $\widetilde { p } _ { \ell } ( \mathbf { x } )$ which is generated on demand during training using labels   
+179 $\mathbf { y } \sim p ( \mathbf { y } )$ e drawn from the prior distributions 17. Second, a precomputed simulated data set $\widetilde { p } _ { u , 3 } ( \mathbf { x } )$   
+180 eused for validation of the method, where the labels are held out during training. All simulated signals   
+181 are generated with $N _ { \mathbf { x } , 3 } = 6 4$ samples and $\mathrm { T E } = 1 0 \mathrm { m s }$ .   
+182 MCMC data MCMC is performed using the No-U-Turn Sampler [13] algorithm to generate   
+183 posterior samples $\hat { \mathbf { y } } \sim p ( \mathbf { y } | \mathbf { x } _ { u } )$ which can be compared with the (Metropolis-)CVAE posterior   
+184 samples. MCMC was performed twice: once to draw 100 posterior samples for every time signal in   
+185 $\widetilde { p } _ { u , 1 } ( \mathbf { x } )$ , $\widetilde { p } _ { u , 2 } ( \mathbf { x } )$ , and $\bar { \widetilde { p } } _ { u , 3 } ( { \bf x } )$ , and once to draw 3000 posterior samples for a subset of 5000 signals   
+186 e e efrom the training, validation, and testing partitions of all three data sets. In total, performing the   
+187 above MCMC analysis took approximately $7 2 \mathrm { h }$ using an AMD Ryzen 9 3950X 16-Core CPU.
+
+![](images/9b33f26f0cc59901628e3fadea310d4a50d7248c7e97428a7324e60c3f9b4790.jpg)  
+Figure 3: (A-G) Histograms of Wasserstein distances between (Metropolis-)CVAE and MCMC empirical distributions for the two MRI data sets. Histograms of errors between the means of the empirical distributions and the true labels are shown. (H) Quantile-quantile plot for each label between global empirical distributions of CVAE samples and MCMC samples. In all plots, comparison with MCMC with 100 samples and 3000 samples are shown in red and green, respectively; CVAE trained only on simulated data is shown in dashed lines; Metropolis-CVAE shown in solid lines.
+
+# 188 3.2 Model architecture
+
+189 CVAE components Let $\mathbf { x } \in \mathbb { R } ^ { N _ { \mathbf { x } } }$ , $\mathbf { y } \in \mathbb { R } ^ { N _ { \mathbf { y } } }$ , and $\mathbf { z } \in \mathbb { R } ^ { N _ { \mathbf { z } } }$ be input data, corresponding labels,   
+190 and latent space samples, respectively. The encoders $E _ { 1 }$ and $E _ { 2 }$ are chosen to be multivariate normal   
+191 distributions: $E _ { 1 } ( \mathbf { z } | \mathbf { \bar { x } } ) = \bar { \mathcal { N } } ( \mu _ { \mathbf { z } _ { 1 } } , \bar { \mathcal { \sigma } _ { \mathbf { z } _ { 1 } } } )$ and $E _ { 2 } ( \mathbf { z } | \mathbf { x } , \mathbf { y } ) = \mathcal { N } ( \mu _ { \mathbf { z } _ { 2 } } , \sigma _ { \mathbf { z } _ { 2 } } )$ , where $\mu _ { \mathbf { z } _ { 1 } } , \mu _ { \mathbf { z } _ { 2 } } \in \mathbb { R } ^ { N _ { \mathbf { z } } }$ and   
+192 $\sigma _ { \mathbf { z } _ { 1 } } , \sigma _ { \mathbf { z } _ { 2 } } \in \mathbb { R } _ { + } ^ { N _ { \mathbf { z } } }$ . Similarly, the decoder is given by $D ( \mathbf { y } | \mathbf { x } , \mathbf { z } ) = \mathscr { T N } ( \mu _ { \mathbf { y } } , \sigma _ { \mathbf { y } } , 0 , 1 )$ , where $\mu _ { \mathbf { y } } \in \mathbb { R } ^ { N _ { \mathbf { y } } }$   
+193 and $\boldsymbol { \sigma _ { \mathbf { y } } } \in \mathbb { R } _ { + } ^ { N _ { \mathbf { y } } }$ parameterize independent multivariate normal distributions truncated to [0, 1]. The   
+194 labels $\mathbf { y }$ are scaled linearly from the prior domains 17 to $[ 0 , 1 ] ^ { N _ { \mathbf { y } } }$ in order to better condition the   
+195 network during training. Similarly, as we are interested only in the relative $\mathbf { x }$ values and not their   
+196 absolute scale, inputs $\mathbf { x }$ are normalized to $[ 0 , 1 ] ^ { N _ { \mathbf { x } } }$ .   
+197 Each of the $E _ { 1 }$ , $E _ { 2 }$ , and $D$ networks are composed of fully connected layers with ReLU activation   
+198 functions and $H = 2$ hidden layers, with hidden dimension $N _ { H } = 5 1 2$ , for a total of $H + 2 = 4$   
+199 layers. The dimensions of the data, labels, and latent space are $N _ { \mathbf { x } } = 6 4$ , $N _ { \mathbf { y } } = 7$ , and $N _ { \mathbf { z } } = 1 2$ ,   
+200 respectively. The encoder networks output $\mu _ { \mathbf { z } _ { 1 } }$ , $\log \sigma _ { \mathbf { z } _ { 1 } }$ , $\mu _ { \mathbf { z } _ { 2 } }$ , and $\log \sigma _ { \mathbf { z } _ { 2 } }$ vectors. In order to avoid   
+201 latent space collapse during early training stages – that is, one or both of $\vert \mu _ { \mathbf { z } _ { i } } \vert , \vert \log \sigma _ { \mathbf { z } _ { i } } \vert  \infty -$   
+202 each $\mu _ { \mathbf { z } _ { i } }$ was bounded to $( - 3 , 3 )$ using the activation function $x  3 \operatorname { t a n h } ( x )$ , and each $\log \sigma _ { \mathbf { z } _ { i } }$ was   
+203 bounded to $( - 6 , 0 )$ using the activation function $x  3 \operatorname { t a n h } ( x ) - 3$ . These bounds were determined   
+204 by observing empirical $\mu _ { \mathbf { z } _ { i } }$ and $\log \sigma _ { \mathbf { z } _ { i } }$ values and choosing intervals which clipped only the tails of   
+205 the distributions. The decoder network outputs $\mu _ { \mathbf { y } }$ and $\log \sigma _ { \mathbf { y } }$ vectors without further nonlinearities.   
+206 Loss functions The terms $\mathcal { L } _ { \mathrm { s u p e r } }$ and $\mathcal { L } _ { \mathrm { s e l f } }$ in Equation 11 are identical apart from their inputs,   
+207 with each term consisting of the KL-divergence and evidence lower bound (ELBO) terms from the   
+208 variational lower bound of Equation 1. The KL-divergence can be computed in closed closed-form,   
+209 and is given by
+
+$$
+\displaystyle \mathrm { K L } \left( E _ { 2 } ( \mathbf { z } | \mathbf { x } , \mathbf { y } ) \left| \right| E _ { 1 } ( \mathbf { z } | \mathbf { x } ) \right) = \sum _ { j = 1 } ^ { N _ { \mathbf { z } } } \frac { \sigma _ { \mathbf { z } _ { 2 } , j } ^ { 2 } + ( \mu _ { \mathbf { z } _ { 2 } , j } - \mu _ { \mathbf { z } _ { 1 } , j } ) ^ { 2 } } { 2 \sigma _ { \mathbf { z } _ { 1 } , j } ^ { 2 } } + \log \frac { \sigma _ { \mathbf { z } _ { 1 } , j } } { \sigma _ { \mathbf { z } _ { 2 } , j } } - \frac { 1 } { 2 }
+$$
+
+210 Following sampling $\mathbf { z } _ { 2 } \sim E _ { 2 } ( \mathbf { z } | \mathbf { x } , \mathbf { y } )$ and subsequently computing $( \mu _ { \mathbf { y } } , \log \sigma _ { \mathbf { y } } ) = D ( \mathbf { y } | \mathbf { x } , \mathbf { z } _ { 2 } )$ , the   
+211 ELBO component is approximated as
+
+$$
+\begin{array} { r l } { \displaystyle \mathbb { E } _ { E _ { 2 } ( { \mathbf z } | { \mathbf x } , { \mathbf y } ) } \left[ \log D ( \mathbf { y } | { \mathbf x } , { \mathbf z } ) \right] \approx _ { j = 1 } ^ { N _ { y } } \Bigg \{ } & { } \\ { \displaystyle \log \phi \left( \frac { \mathbf { y } _ { j } - \mu _ { { \mathbf y } , j } } { \sigma _ { { \mathbf y } , j } } \right) - \log \left( \Phi \left( \frac { 1 - \mu _ { { \mathbf y } , j } } { \sigma _ { { \mathbf y } , j } } \right) - \Phi \left( \frac { 0 - \mu _ { { \mathbf y } , j } } { \sigma _ { { \mathbf y } , j } } \right) \right) - \log \sigma _ { { \mathbf y } , j } \Bigg \} } & { } \\ { \displaystyle \mathrm { w h e r e } \quad } & { \phi ( \xi ) = \frac { 1 } { \sqrt { 2 \pi } } \exp \left( - \frac { 1 } { 2 } \xi ^ { 2 } \right) } \\ & { \displaystyle \Phi ( \zeta ) = \frac { 1 } { 2 } \left( 1 + \mathrm { e r f } \left( \frac { \zeta } { \sqrt { 2 } } \right) \right) . } \end{array}
+$$
+
+$\phi ( \xi )$ and $\Phi ( \zeta )$ are the probability density and cumulative distribution functions of the standard normal distribution, respectively. Note that each term in the sum of Equation 19 is the log-likelihood of a normal distribution with parameters $( \mu _ { \mathbf { y } , i } , \sigma _ { \mathbf { y } , i } )$ truncated to the unit interval [0, 1].
+
+# 3.3 Training
+
+All data sets were split into training/validation/testing with proportions $5 0 \% / 2 5 \% / 2 5 \%$ . Input data was padded with zeros to length $N _ { \mathbf { x } } = 6 4$ , if necessary. To support data with differing unpadded lengths, random masking was performed during training: for each x, a random integer $j _ { \mathrm { m a s k } }$ was sampled from 32–64 and all elements $\mathbf { x } _ { j } { > } j _ { \mathrm { m a s k } }$ were set to zero. The ADAM optimizer was used with√ an initial learning rate of $1 0 ^ { - 4 }$ . The learning rate was decreased every 1000 epochs by a factor of $\sqrt { 1 0 }$ Training was completed after 5000 epochs, where an epoch is defined as 100 iterations. Each iteration, a batch of 1024 data and (pseudo-)label pairs are drawn from either a labeled or an unlabeled dataset, with equal probability. If labeled data are sampled, the loss component $\mathcal { L } _ { \mathrm { s u p e r } } ( \mathbf { x } _ { \ell } , \mathbf { y } )$ is descended on. If unlabeled data are sampled, the pseudo labels $\widetilde { \mathbf { y } }$ corresponding to the sampled $\mathbf { x } _ { u }$ are updated eusing Equation 8 before descending on the loss component $\bar { \mathcal { L } } _ { \mathrm { s e l f } } ( \mathbf { x } _ { u } , \widetilde { \mathbf { y } } )$ . In the Metropolis-Hastings update step, we set $L _ { c } = 1$ in equation 7 and $L _ { \mathbf { z } } = 1$ ein equation 9. Training was performed on a single Nvidia GeForce RTX 3080 GPU with 10 GB of VRAM; approximately 15 hours was required to train for 5000 epochs.
+
+# 229 4 Results and discussion
+
+In the first experiment, a Metropolis-CVAE is trained on online simulated labeled data $\mathbf { x } _ { \ell } \sim \widetilde { p } _ { \ell } ( \mathbf { x } )$ as well as precomputed simulated data $\mathbf { x } _ { u } \sim \widetilde { p } _ { u , 3 } ( \mathbf { x } )$ with labels held out during training. Figure 1(A-G) eshows the distributions of prediction errors by the trained network for each label. For each method, the prediction error is defined as the difference between the true label and the mean of the posterior samples. The labels have been normalized to [0, 1]. The histograms for the Metropolis-CVAE with 100 posterior samples are more tightly clustered around zero than MCMC with either 100 or 3000 posterior samples – denoted MCMC-100 and MCMC-3000 – in all cases except for one (Figure 1F). Figure 1H shows a $p { - } p$ plot: the fraction of posterior samples greater than or equal to the true label, $p$ is plotted against the cumulative distribution of $p$ -values across the data set; the Metropolis-CVAE produces similar curves as MCMC-3000.
+
+240 In the second experiment, a Metropolis-CVAE is similarly trained using labeled simulated $\mathbf { x } _ { \ell } \sim \widetilde { p } _ { \ell } ( \mathbf { x } )$ ,   
+241 but now with the unlabeled data $\mathbf { x } _ { u }$ drawn from the MRI data sets $\widetilde { p } _ { u , 1 } ( \mathbf { x } )$ and $\widetilde { p } _ { u , 2 } ( \mathbf { x } )$ e. For   
+242 e ecomparison, a second traditional CVAE is trained on the simulated data only. Figure 2A shows the   
+243 acceptance rate of the proposed pseudo labels $\widetilde { \mathbf { y } } ^ { \prime } \sim Q ( \mathbf { y } ^ { \prime } )$ for each data set during training. As the   
+244 eMetropolis-CVAE continually learns from both data sets, we find that the network quickly enters   
+245 a negative feedback loop in which the acceptance rate continually increases throughout training.   
+246 Noteworthy is that the acceptance rate of $\widetilde { \mathbf { y } }$ converges to a value between 0.6 and 0.7 for both datasets.   
+247 eThe default target acceptance rate of the No-U-Turn sampler is 0.65, a value which originates from   
+248 a theoretical result pertaining to Hamiltonian Monte Carlo (HMC) [14]. Theoretical work would   
+249 be required to demonstrate a direct connection between Metropolis-CVAEs and the HMC result.   
+250 However, this illustrates that the network neither accepts nor rejects more proposals than is typically   
+251 desired. Figure 2(B-C) shows the average Wasserstein distance between empirical label distributions   
+252 from the Metropolis-CVAE with MCMC-100 and MCMC-3000, respectively. During training, the   
+253 Metropolis-CVAE quickly reaches minimum Wasserstein distances with respect to MCMC-100.   
+254 Minima are reached with respect to MCMC-3000 similarly quickly. We can extrapolate from this   
+255 result that the Metropolis-CVAE likely produces higher quality posterior samples than MCMC-3000.   
+256 This may be expected, as the Metropolis-CVAE updates its pseudo labels at every training iteration,   
+257 continuously performing MCMC throughout training using the MH update rule 8.   
+258 Figure 3(A-G) compares the empirical distributions of a traditional CVAE trained only on simulated   
+259 data with a Metropolis-CVAE. Histograms of the Wasserstein distances between the two networks and   
+260 MCMC-100 do not show large differences, due to the low-quality of MCMC-100. Compared with   
+261 MCMC-3000, parameters which are traditionally easier to infer, such as $\alpha$ and $\beta$ , show little difference   
+262 between the networks. The CVAE trained on supervised data alone shows significant deviation from   
+263 MCMC-3000 for several parameters, particularly $\eta$ , $\delta _ { 1 }$ , and $\log \epsilon$ . This illustrates the ability of the   
+264 Metropolis-CVAE to generalize well to the unlabeled test data, as unlabeled training data from $\widetilde { p } _ { u } ( \mathbf { x } )$   
+265 ehas been explicitly incorporated into its training process. Figure 3(H) shows quantile-quantile plots   
+266 for distributions of all label samples across the data sets. All methods agree.   
+267 Limitations A limitation of this method is the requirement of a likelihood function which is fast to   
+268 compute in order to perform the Metropolis-Hastings update step 8. For physics models, computing   
+269 the likelihood of a set of parameters often involves costly forward simulations of complex models.   
+270 Therefore, computationally intensive models which require solving non-trivial integral or differential   
+271 equations will not be suitable.   
+272 Another limitation is that the pseudo label sampling procedure may converge to a stable local   
+273 minimum which is far from the globally optimal labels. This is inherent to the MH update step; while   
+274 MCMC methods often provide convergence guarantees in the limit of large numbers of update steps,   
+275 one can not predict how many update steps this will require in practice. However, by training the   
+276 Metropolis-CVAE on both simulated data generated from the prior space as well as real unlabeled   
+277 data, we have not found this to be a practical concern.
+
+Potential negative societal impacts This work describes a framework for ascribing labels to unlabeled data. Potential malicious and unintended uses could occur if this framework were significantly extended beyond the MRI physics inference problem which we considered. For example, this methodology could be used to infer missing data generally, with the inferred data then presented under the pretense that it were true data. Further, we have not shown that our method of data inference for unlabeled data is inherently fair, nor that the clinical MRI data under which the Metropolis-CVAE model is trained on cannot be recovered from the network weights.
+
+285 References   
+286 [1] Udo von Toussaint. Bayesian inference in physics. Reviews of Modern Physics, 83(3):943–999,   
+287 September 2011. doi: 10.1103/RevModPhys.83.943. URL https://link.aps.org/doi/   
+288 10.1103/RevModPhys.83.943. Publisher: American Physical Society.   
+289 [2] Kihyuk Sohn, Honglak Lee, and Xinchen Yan. Learning Structured Output Representation   
+290 using Deep Conditional Generative Models. In C. Cortes, N. Lawrence, D. Lee, M. Sugiyama,   
+291 and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 28. Curran   
+292 Associates, Inc., December 2015. URL https://proceedings.neurips.cc/paper/2015/   
+293 file/8d55a249e6baa5c06772297520da2051-Paper.pdf.   
+294 [3] Diederik P. Kingma, Danilo J. Rezende, Shakir Mohamed, and Max Welling. Semi-Supervised   
+295 Learning with Deep Generative Models. arXiv:1406.5298 [cs, stat], October 2014. URL   
+296 http://arxiv.org/abs/1406.5298. arXiv: 1406.5298.   
+297 [4] Hunter Gabbard, Chris Messenger, Ik Siong Heng, Francesco Tonolini, and Roderick   
+298 Murray-Smith. Bayesian parameter estimation using conditional variational autoencoders   
+299 for gravitational-wave astronomy. arXiv:1909.06296 [astro-ph, physics:gr-qc], September   
+300 2019. URL http://arxiv.org/abs/1909.06296. arXiv: 1909.06296.   
+301 [5] Nicholas Metropolis, Arianna W. Rosenbluth, Marshall N. Rosenbluth, Augusta H. Teller, and   
+302 Edward Teller. Equation of State Calculations by Fast Computing Machines. The Journal of   
+303 Chemical Physics, 21(6):1087–1092, June 1953. ISSN 0021-9606. doi: 10.1063/1.1699114.   
+304 URL https://aip.scitation.org/doi/10.1063/1.1699114. Publisher: American In  
+305 stitute of Physics.   
+306 [6] W. K. Hastings. Monte Carlo sampling methods using Markov chains and their applications.   
+307 Biometrika, 57(1):97–109, April 1970. ISSN 0006-3444. doi: 10.1093/biomet/57.1.97. URL   
+308 https://doi.org/10.1093/biomet/57.1.97.   
+309 [7] Thomas Prasloski, Burkhard Mädler, Qing-San Xiang, Alex MacKay, and Craig Jones.   
+310 Applications of stimulated echo correction to multicomponent T2 analysis. Magnetic   
+311 Resonance in Medicine, 67(6):1803–1814, 2012. ISSN 1522-2594. doi: 10.1002/   
+312 mrm.23157. URL https://onlinelibrary.wiley.com/doi/abs/10.1002/mrm.23157.   
+313 _eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1002/mrm.23157.   
+314 [8] S. O. Rice. Mathematical Analysis of Random Noise. Bell System Technical Journal, 23(3):   
+315 282–332, 1944. ISSN 1538-7305. doi: 10.1002/j.1538-7305.1944.tb00874.x. URL https:   
+316 //onlinelibrary.wiley.com/doi/abs/10.1002/j.1538-7305.1944.tb00874.x.   
+317 _eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1002/j.1538-7305.1944.tb00874.x.   
+318 [9] S. O. Rice. Mathematical Analysis of Random Noise. Bell System Technical Journal, 24(1):   
+319 46–156, 1945. ISSN 1538-7305. doi: 10.1002/j.1538-7305.1945.tb00453.x. URL https:   
+320 //onlinelibrary.wiley.com/doi/abs/10.1002/j.1538-7305.1945.tb00453.x.   
+321 _eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1002/j.1538-7305.1945.tb00453.x.   
+322 [10] H. Y. Carr and E. M. Purcell. Effects of Diffusion on Free Precession in Nuclear Magnetic   
+323 Resonance Experiments. Physical Review, 94(3):630–638, May 1954. doi: 10.1103/PhysRev.94.   
+324 630. URL https://link.aps.org/doi/10.1103/PhysRev.94.630. Publisher: American   
+325 Physical Society.   
+326 [11] S. Meiboom and D. Gill. Modified Spin-Echo Method for Measuring Nuclear Relaxation   
+327 Times. Review of Scientific Instruments, 29(8):688–691, August 1958. ISSN 0034-6748. doi:   
+328 10.1063/1.1716296. URL https://aip.scitation.org/doi/abs/10.1063/1.1716296.   
+329 Publisher: American Institute of Physics.   
+330 [12] Kenneth P. Whittall, Alex L. Mackay, Douglas A. Graeb, Robert A. Nugent, David K. B.   
+331 Li, and Donald W. Paty. In vivo measurement of T2 distributions and water contents in   
+332 normal human brain. Magnetic Resonance in Medicine, 37(1):34–43, 1997. ISSN 1522-2594.   
+333 doi: 10.1002/mrm.1910370107. URL https://onlinelibrary.wiley.com/doi/abs/10.   
+334 1002/mrm.1910370107.
+
+35 [13] Matthew D Hoffman and Andrew Gelman. The No-U-Turn sampler: adaptively setting path lengths in Hamiltonian Monte Carlo. J. Mach. Learn. Res., 15(1):1593–1623, 2014.
+
+[14] Alexandros Beskos, Natesh Pillai, Gareth Roberts, Jesus-Maria Sanz-Serna, and Andrew Stuart. Optimal tuning of the hybrid Monte Carlo algorithm. Bernoulli, 19 (5A):1501–1534, November 2013. ISSN 1350-7265. doi: 10.3150/12-BEJ414. URL https://projecteuclid.org/journals/bernoulli/volume-19/issue-5A/ Optimal-tuning-of-the-hybrid-Monte-Carlo-algorithm/10.3150/12-BEJ414. full. Publisher: Bernoulli Society for Mathematical Statistics and Probability.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See the Limitations paragraph of the Results and discussion section.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See the Potential negative societal impacts paragraph of the Results and discussion section.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] Code to reproduce the main results is included with the supplemental material. The MRI data cannot be included, as it is medical data. However, the simulated data is provided in the supplemental material.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See the Training subsection of the Experiments section.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We provide entire histograms of relevant error metrics; see Figures 1 and 3.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See the MCMC data paragraph of the Data sets subsection of the Experiments section, as well as the Training subsection of the Experiments section.
+
+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? [N/A]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] The trained models are supplied in the supplemental material.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] See the MRI data paragraph of the Data sets subsection of the Experiments section.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] The MRI data used in this work is anonymized; see the MRI data paragraph of the Data sets subsection of the Experiments section.
+
+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? [No] This was a prospective study; this information was not available.
+
+385 (b) Did you describe any potential participant risks, with links to Institutional Review   
+386 Board (IRB) approvals, if applicable? [Yes] These MRI scans were acquired with   
+387 approval from our university ethics board; see the MRI data paragraph of the Data sets   
+388 subsection of the Experiments section.   
+389 (c) Did you include the estimated hourly wage paid to participants and the total amount   
+390 spent on participant compensation? [N/A]

parse/train/wTutcPE7zOC/wTutcPE7zOC_content_list.json

@@ -0,0 +1,1021 @@
+[
+    {
+        "type": "text",
+        "text": "Metropolis-CVAE: Bootstrapping Labels for Bayesian Inference via Semi-Supervised Conditional Variational Autoencoders ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            122,
+            823,
+            196
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            247,
+            578,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            338,
+            535,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 In Bayesian parameter estimation, models make simplifying assumptions to make   \n2 parameter inference feasible. If learned inference methods are trained using data   \n3 simulated by models, however, distributional differences between simulated and   \n4 observed data may lead to biased inference results on the observed data. In this   \n5 work, we introduce a semi-supervised learned Bayesian inference method which   \n6 makes use of both simulated data – for which the underlying parameters are known   \n7 by construction – and unlabeled data, which may depend on nuissance parameters   \n8 not captured by the simulation procedure. A conditional variational autoencoder   \n9 (CVAE) is trained to perform approximate inference simultaneously on the sets of   \n10 labeled simulated data and unlabeled data, where the unlabeled data is initialized   \n11 with arbitrary pseudo labels. At each training iteration, new candidate pseudo   \n12 labels are drawn from the CVAE posterior and the pseudo labels are updated using   \n13 the Metropolis-Hastings algorithm. This process results in a Markov chain of   \n14 bootstrapped pseudo labels for each unlabeled datum, effectively performing online   \n15 Markov chain Monte Carlo (MCMC) inference wherein the proposal distribution   \n16 is a CVAE informed by labeled simulated data, producing proposals which are   \n17 increasingly likely to be accepted as training proceeds. The resulting CVAE is   \n18 able to efficiently produce samples from the posterior distributions of both the   \n19 simulated and unlabeled data, implicitly marginalizing over nuissance parameters   \n20 in the unlabeled data. We demonstrate the effectiveness of this method in magnetic   \n21 resonance imaging (MRI) where MCMC is computationally impractical to due the   \n22 $( 3 + 1 ) \\mathrm { D }$ nature of the images, showing improvement against traditional MCMC   \n23 inference in both speed and posterior quality. ",
+        "bbox": [
+            147,
+            369,
+            766,
+            689
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "24 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            715,
+            310,
+            733
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "25 Bayesian parameter estimation methods are robust techniques for quantifying properties of a system   \n26 that cannot be observed directly [1]. In order to estimate such parameters, one first needs to develop   \n27 a model of the phenomena to be studied. This process requires deep domain-specific knowledge. For   \n28 all but the most basic of systems, a series of simplifying assumptions on the system are required to   \n29 make parameter inference tractable. Typically, tractable is synonymous with not being unreasonably   \n30 expensive to compute. Examples of such methodologies include perturbation theory, in which models   \n31 containing Taylor series expansions drop higher order terms; mean-field theory, in which interactions   \n32 involving many degrees of freedom are replaced by averaged approximations; and (stochastic)   \n33 differential equations, when used as continuous limits of discrete stochastic processes. The price one   \n34 pays for utilizing a given approximation is highly problem dependent. When approximate models   \n35 are used for parameter inference, the mismatch between model predictions and data may propagate   \n36 through the inference process and lead to bias and other misestimations of the inferred parameters. In   \n37 this work, we are interested in the following research question: can a deep learning model be trained   \n38 to perform inference, while incorporating both labeled data generated from a well-understood model,   \n39 and unlabeled data which contains additional complex structure which cannot be modeled?   \n40 Here, we present Metropolis conditional variational autoencoders (Metropolis-CVAEs). Metropolis  \n41 CVAEs combine traditional CVAEs with the Metropolis-Hastings Markov chain monte carlo (MCMC)   \n42 inference method. The resulting networks combine the ability of CVAEs to learn to perform rapid   \n43 approximate Bayesian inference from labeled data with traditional MCMC methodology which   \n44 requires only a likelihood model and a prior distribution over the parameters of interest. The   \n45 Metropolis-CVAE initializes the unlabeled data with pseudo labels drawn from the prior distribution   \n46 and, informed by the labeled data, iteratively improves the pseudo labels throughout training. We   \n47 demonstrate the effectiveness of the Metropolis-CVAE network compared to traditional MCMC   \n48 methods on an inference problem from magnetic resonance imaging (MRI) which is inherently   \n49 computationally challenging due to the $( 3 + 1 ) \\mathrm { D }$ nature of the data. ",
+        "bbox": [
+            147,
+            747,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            154,
+            825,
+            292
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Methods ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            310,
+            277,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Related work ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            342,
+            305,
+            356
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the pioneering work by Sohn et al. [2], conditional variational autoencoders were introduced by considering a variational lower bound to the conditional log-likelihood $\\log p ( \\mathbf { y } | \\mathbf { x } )$ of labels $\\mathbf { y }$ given corresponding data $\\mathbf { x }$ . Ideally, to perform data-driven approximate inference, one would like to train a network to learn to maximize the conditional log-likelihood directly. However, this is known to be an intractable problem. To mitigate this issue, the stochastic gradient variational Bayes (SGVB) framework is employed. In SGVB, a latent space which factorizes the marginal likelihood is introduced via $\\begin{array} { r } { p ( \\mathbf { y } | \\mathbf { x } ) = \\int _ { \\mathbf { z } } \\mathrm { d } \\mathbf { z } p ( \\mathbf { z } | \\mathbf { x } ) p ( \\mathbf { y } | \\mathbf { z } , \\mathbf { x } ) } \\end{array}$ , as well as a recognition distribution $q ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } )$ . The conditional log-likelihood is then maximized indirectly via maximizing the variational lower bound ",
+        "bbox": [
+            165,
+            367,
+            825,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6066ca64b04e61fe886f3ebfc9cbae90e40ce6fcd7cd2e2bb35ac97c2829a7a5.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\log p ( \\mathbf { y } | \\mathbf { x } ) \\geq - \\mathrm { K L } \\left( q ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } ) \\left| \\right| p ( \\mathbf { z } | \\mathbf { x } ) \\right) + \\mathbb { E } _ { q ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } ) } \\left[ \\log p ( \\mathbf { y } | \\mathbf { x } , \\mathbf { z } ) \\right] } \\\\ & { \\qquad : = - \\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            501,
+            720,
+            540
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "60 where $\\mathrm { K L }$ is the Kullback-Leibler divergence. The interpretation as a conditional autoencoder is   \n61 as follows: let $p ( \\mathbf { z } | \\mathbf { x } )$ , $q ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } )$ , and $p ( \\mathbf { y } | \\mathbf { x } , \\mathbf { z } )$ be parameterized by deep neural networks $E _ { 1 } ( \\mathbf { z } | \\mathbf { x } )$ ,   \n62 $E _ { 2 } ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } )$ , and $D ( \\mathbf { y } | \\mathbf { x } , \\mathbf { z } )$ , respectively. Then, $E _ { 1 }$ and $E _ { 2 }$ can be viewed as encoders which map   \n63 their inputs into distributions over the latent variables $\\mathbf { z }$ . $D$ can be viewed as a decoder which maps   \n64 stochastic latent representations $\\mathbf { z }$ and data $\\mathbf { x }$ into posterior distributions over the labels y. Hence, $\\mathbf { y }$   \n65 is conditionally autoencoded via the encoder-decoder pipeline $\\mathbf { z } \\sim E _ { 2 } ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } )  \\mathbf { y } \\sim D ( \\mathbf { y } | \\mathbf { x } , \\mathbf { z } )$ .   \n66 At inference time, posterior samples are similarly drawn via $\\mathbf { z } \\sim E _ { 1 } ( \\mathbf { z } | \\mathbf { x } )  \\mathbf { y } \\sim D ( \\mathbf { y } | \\mathbf { x } , \\mathbf { z } )$ . The   \n67 CVAE – the triplet of networks $( E _ { 1 } , E _ { 2 } , D ) -$ is trained by minimizing $\\mathcal { L }$ over the CVAE parameters,   \n68 thereby maximizing the variational lower bound on $\\log p ( \\mathbf { y } | \\mathbf { x } )$ .   \n69 The CVAE approach by Sohn et al. [2] is designed for supervised learning problems. Earlier work of   \n70 a similar vein by Kingma et al. [3] introduces a semi-supervised framework in which labeled data   \n71 $\\left( \\mathbf { x } _ { \\ell } , \\mathbf { y } \\right)$ is used to infer labels for unlabeled data $\\mathbf { x } _ { u }$ via the minimization of a two-term loss function.   \n72 The first term of the loss function is a supervised loss over $\\left( \\mathbf { x } _ { \\ell } , \\mathbf { y } \\right)$ samples, similar to Equation 1,   \n73 derived from a variational lower bound on the joint log-likelihood $\\log p ( \\mathbf { x } _ { \\ell } , \\mathbf { y } )$ . The second term is an   \n74 unsupervised loss over $\\mathbf { x } _ { u }$ samples which treats label inference as a data imputation task. Specifically,   \n75 the unknown label is treated as a parameter over which posterior inference is performed; the resulting   \n76 loss is a variational lower bound on the log-likelihood $\\bar { \\log { p ( \\mathbf { x } _ { u } ) } }$ .   \n77 While the semi-supervised method of Kingma et al. is an elegant approach to discovering labels,   \n78 it is not quite suitable for inferring labels for out of distribution data. This is due to the implicit   \n79 assumption that relationships between $\\mathbf { x } _ { \\ell }$ and $\\mathbf { y }$ learned from the joint distribution $p ( \\mathbf x _ { \\ell } , \\mathbf y )$ generalize   \n80 to data from $p ( \\mathbf { x } _ { u } )$ . In fact, this assumption is made explicit via an extended objective function which   \n81 adds a regularization term $\\mathbb { E } _ { \\widetilde { p } _ { \\ell } ( \\mathbf { x } , \\mathbf { y } ) } \\left[ - \\log q ( \\mathbf { y } | \\mathbf { x } _ { \\ell } ) \\right]$ over the empirical distribution $\\widetilde { p } _ { \\ell } ( \\mathbf { x } , \\mathbf { y } )$ of labeled   \n82 edata. This penalty encourages the learned posterior distribution $q ( \\mathbf { y } \\vert \\mathbf { x } )$ e to generate labels for $\\mathbf { x } _ { u }$ by   \n83 extrapolating from the relationships it discovers between $\\left( \\mathbf { x } _ { \\ell } , \\mathbf { y } \\right)$ pairs. This will naturally lead to   \n84 biased labels for $\\mathbf { x } _ { u }$ when the distribution underlying $\\mathbf { x } _ { u }$ differs from that of $\\mathbf { x } _ { \\ell }$ .   \n85 Gabbard et al., who made use of CVAEs to accelerate inference for an application in gravitational   \n86 wave astronomy [4], presented an alternate view of Equation 1. Gabbard et al. begin by aiming to   \n87 minimize the expected cross-entropy ",
+        "bbox": [
+            145,
+            550,
+            825,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            681,
+            825,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            799,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            90,
+            825,
+            135
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a2e96bed20a6dfe430e4bc44d480d618010e95db0f6ac8adf91397b174b767f5.jpg",
+        "text": "$$\n\\mathcal { H } : = - \\mathbb { E } _ { p ( \\mathbf { x } ) } \\left[ \\int _ { \\mathbf { y } } \\mathrm { d } \\mathbf { y } p ( \\mathbf { y } | \\mathbf { x } ) \\log \\hat { p } ( \\mathbf { y } | \\mathbf { x } ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            164,
+            637,
+            200
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "88 over the data distribution $p ( \\mathbf { x } )$ between the true posterior $p ( \\mathbf { y } \\vert \\mathbf { x } )$ and approximate posterior ${ \\hat { p } } ( \\mathbf { y } | \\mathbf { x } )$ . Employing the SGVB framework and letting 89 $\\begin{array} { r } { \\hat { p } ( \\mathbf { y } | \\mathbf { x } ) = \\int _ { \\mathbf { z } } \\mathrm { d } \\mathbf { z } \\hat { p } ( \\mathbf { z } | \\mathbf { x } ) \\hat { p } ( \\mathbf { y } | \\mathbf { z } , \\mathbf { x } ) } \\end{array}$ , it follows from 1 that ",
+        "bbox": [
+            142,
+            219,
+            830,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/afc23f01bd5a0279dea31fad27250d26ebe452e29a0b6cfb94a559d3d4ae73f4.jpg",
+        "text": "$$\n\\mathcal { H } \\leq \\mathbb { E } _ { p ( \\mathbf { x } ) } \\left[ \\int _ { \\mathbf { y } } \\mathrm { d } \\mathbf { y } p ( \\mathbf { y } | \\mathbf { x } ) \\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            279,
+            622,
+            315
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "90 Applying Bayes’ theorem, we equivalently have that ",
+        "bbox": [
+            145,
+            334,
+            517,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de2ba5dce8bd1c3273f4caceba3b57adb06c97b699361e9e82dd38aeb0d1df9b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { H } \\leq \\mathbb { E } _ { p ( \\mathbf { x } ) } \\mathbb { E } _ { p ( \\mathbf { y } \\mid \\mathbf { x } ) } \\left[ \\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ) \\right] } \\\\ & { \\quad = \\mathbb { E } _ { p ( \\mathbf { y } ) } \\mathbb { E } _ { p ( \\mathbf { x } \\mid \\mathbf { y } ) } \\left[ \\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ) \\right] } \\\\ & { \\quad = \\mathbb { E } _ { p ( \\mathbf { x } , \\mathbf { y } ) } \\left[ \\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            381,
+            596,
+            441
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "91 Therefore, maximizing the variational lower bound to $\\log p ( \\mathbf { y } | \\mathbf { x } )$ over a dataset of $\\displaystyle ( \\mathbf { x } , \\mathbf { y } )$ pairs, as in   \n92 Equation 1, is equivalent to minimizing the expected cross-entropy via Equation 6. The interpretation   \n93 of Equations 4 and 5, however, will prove useful for remedying the issue of label inference for out of   \n94 distribution data. ",
+        "bbox": [
+            145,
+            459,
+            825,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "95 2.2 Theoretical contributions ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            539,
+            388,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "96 Equation 5 is a natural framework for using CVAEs to perform inference on simulated data with   \n97 known labels [4]. Suppose labels $\\mathbf { y } \\sim p ( \\mathbf { y } )$ are sampled from a prior distribution and $\\mathbf { x } \\sim p ( \\mathbf { x } | \\mathbf { y } )$   \n98 is subsequently given by a (possibly stochastic) model function $\\mathbf { x } = f ( \\mathbf { y } )$ . Then, Equation 5   \n99 corresponds to minimizing the average CVAE loss $\\mathcal { L } ( \\mathbf { x } , \\mathbf { y } )$ over pairs of simulated data $( \\mathbf { x } = f ( \\mathbf { y } ) , \\mathbf { y } )$ .   \n100 The novel contribution of this work stems from of Equation 4. Using this formulation directly would   \n101 require sampling from the posterior $p ( \\mathbf { y } \\vert \\mathbf { x } )$ , which is our stated objective. However, this can be   \n102 circumvented by making the observation that if we could construct a Markov chain of pseudo labels   \n103 $\\widetilde { \\mathbf { y } }$ during training, such that the stationary distribution of the sequence $( \\widetilde { \\mathbf { y } } _ { k } ) _ { k \\in \\mathbb { N } }$ was $p ( \\mathbf { y } \\vert \\mathbf { x } )$ , then   \n104 eEquation 4 could be approximated as ",
+        "bbox": [
+            143,
+            566,
+            826,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            628,
+            825,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/744464a54b459d31ae1e6a9b58f4d0e0b58d06d67e014f287b5c6d048f7738f6.jpg",
+        "text": "$$\n\\mathbb { E } _ { p ( \\mathbf { x } ) } \\mathbb { E } _ { p ( \\mathbf { y } | \\mathbf { x } ) } \\left[ \\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ) \\right] \\approx \\mathbb { E } _ { p ( \\mathbf { x } ) } \\left[ \\frac { 1 } { L _ { c } } \\sum _ { i = 0 } ^ { L _ { c } - 1 } \\mathcal { L } ( \\mathbf { x } , \\widetilde { \\mathbf { y } } _ { n - i } ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            729,
+            687,
+            773
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "105 where $( \\widetilde { \\mathbf { y } } _ { n - L _ { c } + 1 } , \\ldots , \\widetilde { \\mathbf { y } } _ { n } )$ are the $L _ { c }$ most recent samples in the Markov chain. This approach to   \n106 e edistribution sampling – Markov chain Monte Carlo (MCMC) sampling – is considered the gold   \n107 standard in parameter inference.   \n108 In this work, we consider the Metropolis-Hastings (MH) algorithm [5, 6]. In the context of Bayesian   \n109 inference for recovering labels $\\mathbf { y }$ from data $\\mathbf { x }$ , MH sampling begins with a prior distribution $p ( \\mathbf { y } )$ , a   \n110 likelihood function $p ( \\mathbf { x } | \\mathbf { y } )$ , and a proposal distribution $Q ( \\mathbf { y } ^ { \\prime } | \\mathbf { y } )$ which quantifies the probability of   \n111 transitioning from y to $\\mathbf { y } ^ { \\prime }$ in the space of possible labels. Given a sample ${ \\bf y } _ { n }$ of a Markov chain, the   \n112 MH update rule is given by ",
+        "bbox": [
+            142,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            840,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/97cf94220a9e5f30dc3213d1f093a81f544c1b859c6af51de3cb1c59aca7af8f.jpg",
+        "image_caption": [
+            "Figure 1: (A-G) Comparison of inference results for data simulated using Equation 14 with parameters drawn from Equation 17. Histograms of errors between the means of the empirical distributions and the true labels are shown. $\\mathrm { ( H ) }$ ) p-p plot for each label. In all plots, MCMC with 100 samples, MCMC with 3000 samples, and Metropolis-CVAE with 100 samples are shown in red, green, and blue, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            85,
+            826,
+            386
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1cf156bd9ad5d296266ae0f52c2170681d82486ad91e1e9879841a3c672d6842.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { y } ^ { \\prime } \\sim Q ( \\mathbf { y } ^ { \\prime } | \\mathbf { y } _ { n } ) } \\\\ & { \\alpha = \\operatorname* { m i n } ( 1 , \\frac { p ( \\mathbf { y } ^ { \\prime } ) } { p ( \\mathbf { y } _ { n } ) } \\cdot \\frac { p ( \\mathbf { x } | \\mathbf { y } ^ { \\prime } ) } { p ( \\mathbf { x } | \\mathbf { y } _ { n } ) } ) } \\\\ & { u \\sim \\mathrm { U n i f o r m } ( 0 , 1 ) } \\\\ & { \\mathbf { y } _ { n + 1 } = \\{ \\mathbf { y } ^ { \\prime } \\quad u \\leq \\alpha  } \\\\ & {  \\mathbf { y } _ { n } + \\mathrm { o t h e r w i s e } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            507,
+            622,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "113 The proposal distribution $Q ( \\mathbf { y } ^ { \\prime } | \\mathbf { y } )$ is a free parameter of the MH algorithm. In general, choosing $Q$   \n114 to resemble the true posterior as closely as possible improves the efficiency of the MH algorithm.   \n115 Therefore, we propose to use the approximate posterior ${ \\hat { p } } ( \\mathbf { y } | \\mathbf { x } )$ of the CVAE itself as the proposal   \n116 distribution. Recalling that $\\begin{array} { r } { \\hat { p } ( { \\bf y } | { \\bf x } ) = \\int _ { \\bf z } \\mathrm { d } { \\bf z } \\hat { p } ( { \\bf z } | { \\bf x } ) \\hat { p } ( { \\bf y } | { \\bf z } , { \\bf x } ) : = \\int _ { \\bf z } \\mathrm { d } { \\bf z } E _ { 1 } ( { \\bf z } | { \\bf x } ) D ( { \\bf y } | { \\bf z } , { \\bf x } ) } \\end{array}$ , we let ",
+        "bbox": [
+            137,
+            631,
+            826,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f3f7ce68d3802c1c1d2bc999963ff691a9cd8ae4c643907d32d48610b9a29f1.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { Q ( \\mathbf { y } ^ { \\prime } | \\mathbf { y } _ { n } ) = Q ( \\mathbf { y } ^ { \\prime } ) = \\int _ { \\mathbf { z } } \\mathrm { d } \\mathbf { z } E _ { 1 } ( \\mathbf { z } | \\mathbf { x } ) D ( \\mathbf { y } ^ { \\prime } | \\mathbf { z } , \\mathbf { x } ) } } \\\\ & { } & { \\approx \\frac { 1 } { L _ { \\mathbf { z } } } \\sum _ { i = 1 } ^ { L _ { \\mathbf { z } } } D ( \\mathbf { y } ^ { \\prime } | \\mathbf { z } _ { i } , \\mathbf { x } ) \\quad \\mathrm { w h e r e } \\quad \\mathbf { z } _ { i } \\sim E _ { 1 } ( \\mathbf { z } | \\mathbf { x } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            710,
+            723,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "117 By choosing this proposal function, we are able to bootstrap pseudo labels $\\widetilde { \\mathbf { y } }$ onto unlabeled data $\\mathbf { x } _ { u }$ .   \n118 In particular, we minimize the semi-supervised hybrid loss ",
+        "bbox": [
+            137,
+            799,
+            826,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/012ef2419901580f1d17eb91b339e7b60685b2360a9c569b0225d401c28be25e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\mathrm { h y b r i d } } = \\mathcal { L } _ { \\mathrm { s u p e r } } + \\mathcal { L } _ { \\mathrm { s e l f } } } \\\\ & { \\mathcal { L } _ { \\mathrm { s u p e r } } = \\mathbb { E } _ { ( \\mathbf { x } _ { \\ell } , \\mathbf { y } ) \\sim \\widetilde { p } _ { \\ell } ( \\mathbf { x } , \\mathbf { y } ) } \\left[ \\mathcal { L } ( \\mathbf { x } _ { \\ell } , \\mathbf { y } ) \\right] } \\\\ & { \\quad \\mathcal { L } _ { \\mathrm { s e l f } } = \\mathbb { E } _ { ( \\mathbf { x } _ { u } , \\widetilde { \\mathbf { y } } ) \\sim \\widetilde { p } _ { u } ( \\mathbf { x } , \\widetilde { \\mathbf { y } } ) } \\left[ \\mathcal { L } ( \\mathbf { x } _ { u } , \\widetilde { \\mathbf { y } } ) \\right] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            853,
+            620,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3d49121ec203886e2bc9c61ce626fb10e54c05e6823fcb7acd2debb6477c954.jpg",
+        "image_caption": [
+            "Figure 2: (A) Pseudo label acceptance rate vs. epochs for the MRI datasets $\\widetilde { p } _ { \\ell , 1 } ( \\mathbf { x } )$ and $\\widetilde { p } _ { \\ell , 2 } ( \\mathbf { x } )$ . (B) e eWasserstein distance vs. epochs between empirical label distributions and MCMC with 100 posterior samples, and (C) same as (B) but MCMC with 3000 posterior samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            825,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "119 where $\\widetilde { p } _ { \\ell } ( \\mathbf x , \\mathbf y )$ and $\\widetilde { p } _ { u } ( \\mathbf { x } , \\widetilde { \\mathbf { y } } )$ are the empirical distributions over the pairs of labeled data $\\left( \\mathbf { x } _ { \\ell } , \\mathbf { y } \\right)$   \n120 e e eand unlabeled data with bootstrapped pseudo labels $\\left( \\mathbf { x } _ { u } , \\widetilde { \\mathbf { y } } \\right)$ , respectively. The pseudolabels $\\widetilde { \\mathbf { y } }$ are   \n121 initialized uniformly from the prior space $p ( \\mathbf { y } )$ e eand are updated according to the MH algorithm 8 at   \n122 each training iteration.   \n123 Note that in the MH update step, the MH acceptance ratio $\\alpha$ can be interepreted as computing a   \n124 Bayesian goodness of fit check relative to the current label $\\widetilde { \\mathbf { y } } _ { n }$ . Therefore, $\\widetilde { p } _ { \\ell } ( \\mathbf { x } )$ and $\\widetilde { p } _ { u } ( \\mathbf { x } )$ need   \n125 e e enot be identical distributions, merely close enough such that decreasing the supervised loss $\\mathcal { L } _ { \\mathrm { s u p e r } }$   \n126 improves the proposal quality for the self-supervised loss $\\mathcal { L } _ { \\mathrm { s e l f } }$ early in training. ",
+        "bbox": [
+            142,
+            371,
+            825,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            433,
+            825,
+            489
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 MRI physics application ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            505,
+            382,
+            520
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "128 We consider an application in magnetic resonance imaging. In MRI, data is typically acquired in   \n129 the form of $( 3 + 1 ) \\mathrm { D }$ spatio-temporal grids, with 1D magnetic resonance time signals measured in   \n130 each voxel of the three spatial dimensions. Advanced imaging methods typically involve voxelwise   \n131 parameter inference for each time signal for the computation of quantitative maps. Modeling the   \n132 individual time signals for inference, however, is challenging due to imperfections in the magnetic   \n133 field generated by the scanner and other sources of signal corruption. Effectively, in MRI there is a   \n134 distributional mismatch problem: simulated data $\\widetilde { p } _ { \\ell } ( \\mathbf { x } )$ , with labels corresponding to well understood   \n135 ephysics parameters, does not contain the full distribution of measured data $\\widetilde { p } _ { u } ( \\mathbf { x } )$ which, while   \n136 egenerated by the same physics in principle, depends on additional nuissance parameters which cannot   \n137 be modeled. Machine learning models which intended to generalize to $\\widetilde { p } _ { u } ( \\mathbf { x } )$ should therefore not be   \n138 trained only on data from $\\widetilde { p } _ { \\ell } ( \\mathbf { x } )$ .   \n139 In this work, we acquire multi spin-echo (MSE) MRI images. The MSE time signals are modeled   \n140 using a two-component extended phase graph (EPG) model using the algorithm detailed in Prasloski   \n141 et al. [7]. Using this model, the $j$ -th time point for each signal is given by ",
+        "bbox": [
+            140,
+            530,
+            825,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            688,
+            825,
+            732
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5609a94b354038ab54e8f7901d949574d257820178e2a02021cdf4355a3435de.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle { \\widehat { \\mathbf { x } } } _ { j } = f ( j \\cdot \\mathrm { T E } ) } } \\\\ { { \\displaystyle f ( t ) = \\sum _ { \\ell = 1 } ^ { 2 } A _ { \\ell } \\mathrm { E P G } ( t , \\alpha , \\beta , T _ { 2 , \\ell } , T _ { 1 } ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            752,
+            622,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "142 where $\\alpha$ is the spin flip angle, $\\beta$ the refocusing control angle, $A _ { 1 } , A _ { 2 }$ the component amplitudes,   \n143 $T _ { 2 , 1 } \\leq T _ { 2 , 2 }$ the short and long transverse relaxation times, and $T _ { 1 }$ the longitudinal relaxation time.   \n144 The $\\mathrm { E P G } ( t , \\ldots )$ terms are approximately exponentially decaying in $t$ with time constants $T _ { 2 , \\ell }$ , with   \n145 additional modifications due to MRI physics determined by $\\alpha$ , $\\beta$ , and $T _ { 1 }$ . The echo time $\\mathrm { T E }$ is the   \n146 uniform spacing between time points. We reparameterize $A _ { 1 }$ , $A _ { 2 }$ , $T _ { 2 , 1 }$ , and $T _ { 2 , 2 }$ in terms of the   \n147 unconstrained parameters $\\eta , \\delta _ { 1 }$ , and $\\delta _ { 2 }$ as follows: $A _ { 1 } = \\eta$ , $A _ { 2 } = 1 - \\eta$ , $\\log T _ { 2 , 1 } = \\log T _ { 2 , \\mathrm { m i n } } +$   \n148 $( \\log T _ { 2 , \\mathrm { m a x } } - \\log T _ { 2 , \\mathrm { m i n } } ) \\cdot \\delta _ { 1 }$ , and $\\log T _ { 2 , 2 } = \\log T _ { 2 , \\mathrm { m i n } } + \\left( \\log T _ { 2 , \\mathrm { m a x } } - \\log T _ { 2 , \\mathrm { m i n } } \\right) \\cdot \\left( \\delta _ { 1 } + \\delta _ { 2 } \\cdot \\left( 1 - \\delta _ { 1 } \\right) \\right)$ ,   \n149 where $T _ { \\mathrm { 2 , m i n } } = 1 0 \\mathrm { m s }$ and $T _ { \\mathrm { 2 , m a x } } = 1 \\mathrm { s }$ . The longitudinal relaxation time is fixed $T _ { 1 } = 1 . 0 \\mathrm { s }$ .   \n150 MRI signal noise can be modeled as Rician [8, 9]. Given data $\\mathbf { x }$ normalized to have maximum value   \n151 1, the likelihood $p ( \\mathbf { x } | \\mathbf { y } )$ under Rician noise is given by ",
+        "bbox": [
+            142,
+            827,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            90,
+            826,
+            121
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            125,
+            825,
+            155
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/68a06daa9614863c6edd46b091664a8e1fc20b60df209bae753b84c8b50a8a2f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\log p ( { \\bf x } | { \\bf y } ) = \\displaystyle \\sum _ { j = 1 } ^ { N _ { \\bf x } } \\log p _ { \\mathrm { R i c e } } \\left( { \\bf x } _ { j } ~ \\middle | \\frac { { \\boldsymbol s } \\cdot \\hat { \\bf x } ( \\boldsymbol \\theta ) _ { j } } { \\operatorname* { m a x } _ { \\boldsymbol k } \\hat { \\bf x } ( \\boldsymbol \\theta ) _ { k } } ~ , ~ { \\boldsymbol s } \\cdot { \\boldsymbol \\epsilon } \\right) , } \\\\ & { p _ { \\mathrm { R i c e } } ( \\boldsymbol { \\xi } | \\nu , \\sigma ) = \\displaystyle \\frac { \\boldsymbol { \\xi } } { \\sigma ^ { 2 } } \\exp \\left( - \\frac { \\boldsymbol { \\xi } ^ { 2 } + \\nu ^ { 2 } } { 2 \\sigma ^ { 2 } } \\right) I _ { 0 } \\left( \\frac { \\boldsymbol { \\xi } \\nu } { \\sigma ^ { 2 } } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            179,
+            722,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "152 is the Rician probability density function with location parameter $\\nu$ and scale parameter $\\sigma ; I _ { 0 }$ is   \n153 the modified Bessel function of the first kind with order zero. We have introduced two additional   \n154 parameters: a scale parameter $s$ to account for signal normalization, and a noise level $\\epsilon$ relative to this   \n155 scale. Additionally, we denote $\\theta = \\left( \\alpha , \\beta , \\eta , \\delta _ { 1 } , \\delta _ { 2 } \\right)$ the parameters of the EPG model 14.   \n156 In total, there are 7 labels to be inferred: $\\mathbf { y } = ( \\alpha , \\beta , \\eta , \\delta _ { 1 } , \\delta _ { 2 } , \\log \\epsilon , \\log s )$ . We place the following   \n157 priors on the parameters: ",
+        "bbox": [
+            140,
+            272,
+            825,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            334,
+            826,
+            363
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/90b6b3d26980558b7e286d6abd3e5fddd1cc52f96c8dd7e80da1b03038197f85.jpg",
+        "text": "$$\n\\begin{array} { c c } { { \\begin{array} { l } { \\alpha \\sim { \\mathcal { T N } } ( 1 8 0 ^ { \\circ } , 4 5 ^ { \\circ } , 9 0 ^ { \\circ } , 1 8 0 ^ { \\circ } ) } \\\\ { \\beta \\sim { \\mathcal { T N } } ( 1 8 0 ^ { \\circ } , 4 5 ^ { \\circ } , 9 0 ^ { \\circ } , 1 8 0 ^ { \\circ } ) } \\\\ { \\eta \\sim { \\mathcal { T N } } ( 0 . 0 , 0 . 5 , 0 . 0 , 1 . 0 ) } \\\\ { \\delta _ { 1 } \\sim { \\mathcal { T N } } ( 0 . 0 , 0 . 5 , 0 . 0 , 1 . 0 ) } \\end{array} } } & { { \\begin{array} { r } { \\delta _ { 2 } \\sim { \\mathcal { T N } } ( 1 . 0 , 0 . 5 , 0 . 0 , 1 . 0 ) } \\\\ { \\log \\epsilon \\sim { \\mathcal { U } } ( \\log 1 0 ^ { - 5 } , \\log 1 0 ^ { - 1 } ) } \\\\ { \\log s \\sim { \\mathcal { T N } } ( 0 . 0 , 0 . 5 , - 2 . 5 , 2 . 5 ) } \\end{array} } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            386,
+            741,
+            459
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "158 where $\\mathcal { T N } ( \\mu , \\sigma , a , b )$ is the normal distribution with parameters $( \\mu , \\sigma )$ truncated to the interval $[ a , b ]$ ,   \n159 and $\\boldsymbol { \\mathcal { U } } ( a , b )$ is the uniform distribution on $[ a , b ]$ . The priors were chosen to align with the expectations   \n160 that: $\\alpha , \\beta$ are typically near $1 8 0 ^ { \\circ }$ ; the short component amplitude $\\eta$ is typically less than the long   \n161 amplitude $1 - \\eta ; \\delta _ { 1 }$ and $\\delta _ { 2 }$ should prefer to represent the shortest and longest components; the noise   \n162 level $\\epsilon$ is chosen uniformly from signal-to-noise ratios between 20 and 100; the scale parameter $s$   \n163 should prefer to be 1. ",
+        "bbox": [
+            140,
+            472,
+            826,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            575,
+            312,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 Data sets ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            606,
+            276,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "166 MRI data The MRI data used for this study consists of two anonymized brain scans acquired using   \n167 a Carr-Purcell-Meiboom-Gill (CPMG) [10, 11] multi spin-echo sequence [12]. The first data set,   \n168 denoted $\\widetilde { p } _ { u , 1 } ( \\mathbf { x } )$ , contains signals with $N _ { \\mathbf { x } , 1 } = 4 8$ samples at times $t _ { i } = i \\cdot \\mathrm { T E }$ , with echo spacing   \n169 $\\mathrm { T E } = 8 \\mathrm { m s }$ , repetition time $\\mathrm { T R } = 1 0 7 3 \\mathrm { m }$ s, matrix size $2 4 0 \\times 2 4 0 \\times 4 8$ , and spatial resolution   \n170 $0 . 9 6 \\times 0 . 9 6 \\times 2 . 5 \\mathrm { m m ^ { 3 } }$ . The second data set, denoted $\\widetilde { p } _ { u , 2 } ( \\mathbf { x } )$ , contains signals with $N _ { \\mathbf { x } , 2 } = 5 6$   \n171 samples at times $t _ { i } = i \\cdot \\mathrm { T E }$ , with echo spacing $\\mathrm { T E } = 7 \\mathrm { m s }$ , repetition time $\\mathrm { T R } = 1 0 6 6 \\mathrm { m s } .$   \n172 matrix size $2 4 0 \\times 2 4 0 \\times 1 1 3$ , and spatial resolution $1 . 0 \\times 1 . 0 \\times 3 . 0 \\mathrm { { \\dot { m } m } ^ { 3 } }$ . Following the extraction   \n173 of image volumes containing the brain, $\\widetilde { p } _ { u , 1 } ( \\mathbf { x } )$ and $\\widetilde { p } _ { u , 2 } ( \\mathbf { x } )$ contain 821 145 and 1 265 306 signals,   \n174 erespectively. MRI data was acquired on a $3 \\mathrm { T }$ eMR system (Ingenia Elition, Philips Medical Systems,   \n175 Best, The Netherlands) from healthy volunteers giving written and informed consent, and approved   \n176 by our university ethics board.   \n177 Simulated data Using the EPG physics model 14 with Rician noise, we consider two simulated   \n178 data sets. First, the labeled data set $\\widetilde { p } _ { \\ell } ( \\mathbf { x } )$ which is generated on demand during training using labels   \n179 $\\mathbf { y } \\sim p ( \\mathbf { y } )$ e drawn from the prior distributions 17. Second, a precomputed simulated data set $\\widetilde { p } _ { u , 3 } ( \\mathbf { x } )$   \n180 eused for validation of the method, where the labels are held out during training. All simulated signals   \n181 are generated with $N _ { \\mathbf { x } , 3 } = 6 4$ samples and $\\mathrm { T E } = 1 0 \\mathrm { m s }$ .   \n182 MCMC data MCMC is performed using the No-U-Turn Sampler [13] algorithm to generate   \n183 posterior samples $\\hat { \\mathbf { y } } \\sim p ( \\mathbf { y } | \\mathbf { x } _ { u } )$ which can be compared with the (Metropolis-)CVAE posterior   \n184 samples. MCMC was performed twice: once to draw 100 posterior samples for every time signal in   \n185 $\\widetilde { p } _ { u , 1 } ( \\mathbf { x } )$ , $\\widetilde { p } _ { u , 2 } ( \\mathbf { x } )$ , and $\\bar { \\widetilde { p } } _ { u , 3 } ( { \\bf x } )$ , and once to draw 3000 posterior samples for a subset of 5000 signals   \n186 e e efrom the training, validation, and testing partitions of all three data sets. In total, performing the   \n187 above MCMC analysis took approximately $7 2 \\mathrm { h }$ using an AMD Ryzen 9 3950X 16-Core CPU. ",
+        "bbox": [
+            147,
+            631,
+            826,
+            784
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            797,
+            825,
+            868
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            882,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/9b33f26f0cc59901628e3fadea310d4a50d7248c7e97428a7324e60c3f9b4790.jpg",
+        "image_caption": [
+            "Figure 3: (A-G) Histograms of Wasserstein distances between (Metropolis-)CVAE and MCMC empirical distributions for the two MRI data sets. Histograms of errors between the means of the empirical distributions and the true labels are shown. (H) Quantile-quantile plot for each label between global empirical distributions of CVAE samples and MCMC samples. In all plots, comparison with MCMC with 100 samples and 3000 samples are shown in red and green, respectively; CVAE trained only on simulated data is shown in dashed lines; Metropolis-CVAE shown in solid lines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            85,
+            826,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            539,
+            825,
+            595
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "188 3.2 Model architecture ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            628,
+            346,
+            643
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "189 CVAE components Let $\\mathbf { x } \\in \\mathbb { R } ^ { N _ { \\mathbf { x } } }$ , $\\mathbf { y } \\in \\mathbb { R } ^ { N _ { \\mathbf { y } } }$ , and $\\mathbf { z } \\in \\mathbb { R } ^ { N _ { \\mathbf { z } } }$ be input data, corresponding labels,   \n190 and latent space samples, respectively. The encoders $E _ { 1 }$ and $E _ { 2 }$ are chosen to be multivariate normal   \n191 distributions: $E _ { 1 } ( \\mathbf { z } | \\mathbf { \\bar { x } } ) = \\bar { \\mathcal { N } } ( \\mu _ { \\mathbf { z } _ { 1 } } , \\bar { \\mathcal { \\sigma } _ { \\mathbf { z } _ { 1 } } } )$ and $E _ { 2 } ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } ) = \\mathcal { N } ( \\mu _ { \\mathbf { z } _ { 2 } } , \\sigma _ { \\mathbf { z } _ { 2 } } )$ , where $\\mu _ { \\mathbf { z } _ { 1 } } , \\mu _ { \\mathbf { z } _ { 2 } } \\in \\mathbb { R } ^ { N _ { \\mathbf { z } } }$ and   \n192 $\\sigma _ { \\mathbf { z } _ { 1 } } , \\sigma _ { \\mathbf { z } _ { 2 } } \\in \\mathbb { R } _ { + } ^ { N _ { \\mathbf { z } } }$ . Similarly, the decoder is given by $D ( \\mathbf { y } | \\mathbf { x } , \\mathbf { z } ) = \\mathscr { T N } ( \\mu _ { \\mathbf { y } } , \\sigma _ { \\mathbf { y } } , 0 , 1 )$ , where $\\mu _ { \\mathbf { y } } \\in \\mathbb { R } ^ { N _ { \\mathbf { y } } }$   \n193 and $\\boldsymbol { \\sigma _ { \\mathbf { y } } } \\in \\mathbb { R } _ { + } ^ { N _ { \\mathbf { y } } }$ parameterize independent multivariate normal distributions truncated to [0, 1]. The   \n194 labels $\\mathbf { y }$ are scaled linearly from the prior domains 17 to $[ 0 , 1 ] ^ { N _ { \\mathbf { y } } }$ in order to better condition the   \n195 network during training. Similarly, as we are interested only in the relative $\\mathbf { x }$ values and not their   \n196 absolute scale, inputs $\\mathbf { x }$ are normalized to $[ 0 , 1 ] ^ { N _ { \\mathbf { x } } }$ .   \n197 Each of the $E _ { 1 }$ , $E _ { 2 }$ , and $D$ networks are composed of fully connected layers with ReLU activation   \n198 functions and $H = 2$ hidden layers, with hidden dimension $N _ { H } = 5 1 2$ , for a total of $H + 2 = 4$   \n199 layers. The dimensions of the data, labels, and latent space are $N _ { \\mathbf { x } } = 6 4$ , $N _ { \\mathbf { y } } = 7$ , and $N _ { \\mathbf { z } } = 1 2$ ,   \n200 respectively. The encoder networks output $\\mu _ { \\mathbf { z } _ { 1 } }$ , $\\log \\sigma _ { \\mathbf { z } _ { 1 } }$ , $\\mu _ { \\mathbf { z } _ { 2 } }$ , and $\\log \\sigma _ { \\mathbf { z } _ { 2 } }$ vectors. In order to avoid   \n201 latent space collapse during early training stages – that is, one or both of $\\vert \\mu _ { \\mathbf { z } _ { i } } \\vert , \\vert \\log \\sigma _ { \\mathbf { z } _ { i } } \\vert  \\infty -$   \n202 each $\\mu _ { \\mathbf { z } _ { i } }$ was bounded to $( - 3 , 3 )$ using the activation function $x  3 \\operatorname { t a n h } ( x )$ , and each $\\log \\sigma _ { \\mathbf { z } _ { i } }$ was   \n203 bounded to $( - 6 , 0 )$ using the activation function $x  3 \\operatorname { t a n h } ( x ) - 3$ . These bounds were determined   \n204 by observing empirical $\\mu _ { \\mathbf { z } _ { i } }$ and $\\log \\sigma _ { \\mathbf { z } _ { i } }$ values and choosing intervals which clipped only the tails of   \n205 the distributions. The decoder network outputs $\\mu _ { \\mathbf { y } }$ and $\\log \\sigma _ { \\mathbf { y } }$ vectors without further nonlinearities.   \n206 Loss functions The terms $\\mathcal { L } _ { \\mathrm { s u p e r } }$ and $\\mathcal { L } _ { \\mathrm { s e l f } }$ in Equation 11 are identical apart from their inputs,   \n207 with each term consisting of the KL-divergence and evidence lower bound (ELBO) terms from the   \n208 variational lower bound of Equation 1. The KL-divergence can be computed in closed closed-form,   \n209 and is given by ",
+        "bbox": [
+            140,
+            659,
+            825,
+            781
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            786,
+            826,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            90,
+            825,
+            148
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e36776ec31eb8b8d1d58361f7e9e1415ed89561280f9ece3bd3bc0340376b7a3.jpg",
+        "text": "$$\n\\displaystyle \\mathrm { K L } \\left( E _ { 2 } ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } ) \\left| \\right| E _ { 1 } ( \\mathbf { z } | \\mathbf { x } ) \\right) = \\sum _ { j = 1 } ^ { N _ { \\mathbf { z } } } \\frac { \\sigma _ { \\mathbf { z } _ { 2 } , j } ^ { 2 } + ( \\mu _ { \\mathbf { z } _ { 2 } , j } - \\mu _ { \\mathbf { z } _ { 1 } , j } ) ^ { 2 } } { 2 \\sigma _ { \\mathbf { z } _ { 1 } , j } ^ { 2 } } + \\log \\frac { \\sigma _ { \\mathbf { z } _ { 1 } , j } } { \\sigma _ { \\mathbf { z } _ { 2 } , j } } - \\frac { 1 } { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            171,
+            754,
+            217
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "210 Following sampling $\\mathbf { z } _ { 2 } \\sim E _ { 2 } ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } )$ and subsequently computing $( \\mu _ { \\mathbf { y } } , \\log \\sigma _ { \\mathbf { y } } ) = D ( \\mathbf { y } | \\mathbf { x } , \\mathbf { z } _ { 2 } )$ , the   \n211 ELBO component is approximated as ",
+        "bbox": [
+            138,
+            229,
+            825,
+            260
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/647a67370d86aefde32f956a11a08128b6c5eea1f20953a4acf8c9379477c6aa.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\displaystyle \\mathbb { E } _ { E _ { 2 } ( { \\mathbf z } | { \\mathbf x } , { \\mathbf y } ) } \\left[ \\log D ( \\mathbf { y } | { \\mathbf x } , { \\mathbf z } ) \\right] \\approx _ { j = 1 } ^ { N _ { y } } \\Bigg \\{ } & { } \\\\ { \\displaystyle \\log \\phi \\left( \\frac { \\mathbf { y } _ { j } - \\mu _ { { \\mathbf y } , j } } { \\sigma _ { { \\mathbf y } , j } } \\right) - \\log \\left( \\Phi \\left( \\frac { 1 - \\mu _ { { \\mathbf y } , j } } { \\sigma _ { { \\mathbf y } , j } } \\right) - \\Phi \\left( \\frac { 0 - \\mu _ { { \\mathbf y } , j } } { \\sigma _ { { \\mathbf y } , j } } \\right) \\right) - \\log \\sigma _ { { \\mathbf y } , j } \\Bigg \\} } & { } \\\\ { \\displaystyle \\mathrm { w h e r e } \\quad } & { \\phi ( \\xi ) = \\frac { 1 } { \\sqrt { 2 \\pi } } \\exp \\left( - \\frac { 1 } { 2 } \\xi ^ { 2 } \\right) } \\\\ & { \\displaystyle \\Phi ( \\zeta ) = \\frac { 1 } { 2 } \\left( 1 + \\mathrm { e r f } \\left( \\frac { \\zeta } { \\sqrt { 2 } } \\right) \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            284,
+            758,
+            445
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "$\\phi ( \\xi )$ and $\\Phi ( \\zeta )$ are the probability density and cumulative distribution functions of the standard normal distribution, respectively. Note that each term in the sum of Equation 19 is the log-likelihood of a normal distribution with parameters $( \\mu _ { \\mathbf { y } , i } , \\sigma _ { \\mathbf { y } , i } )$ truncated to the unit interval [0, 1]. ",
+        "bbox": [
+            158,
+            455,
+            823,
+            500
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3 Training ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            515,
+            274,
+            530
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "All data sets were split into training/validation/testing with proportions $5 0 \\% / 2 5 \\% / 2 5 \\%$ . Input data was padded with zeros to length $N _ { \\mathbf { x } } = 6 4$ , if necessary. To support data with differing unpadded lengths, random masking was performed during training: for each x, a random integer $j _ { \\mathrm { m a s k } }$ was sampled from 32–64 and all elements $\\mathbf { x } _ { j } { > } j _ { \\mathrm { m a s k } }$ were set to zero. The ADAM optimizer was used with√ an initial learning rate of $1 0 ^ { - 4 }$ . The learning rate was decreased every 1000 epochs by a factor of $\\sqrt { 1 0 }$ Training was completed after 5000 epochs, where an epoch is defined as 100 iterations. Each iteration, a batch of 1024 data and (pseudo-)label pairs are drawn from either a labeled or an unlabeled dataset, with equal probability. If labeled data are sampled, the loss component $\\mathcal { L } _ { \\mathrm { s u p e r } } ( \\mathbf { x } _ { \\ell } , \\mathbf { y } )$ is descended on. If unlabeled data are sampled, the pseudo labels $\\widetilde { \\mathbf { y } }$ corresponding to the sampled $\\mathbf { x } _ { u }$ are updated eusing Equation 8 before descending on the loss component $\\bar { \\mathcal { L } } _ { \\mathrm { s e l f } } ( \\mathbf { x } _ { u } , \\widetilde { \\mathbf { y } } )$ . In the Metropolis-Hastings update step, we set $L _ { c } = 1$ in equation 7 and $L _ { \\mathbf { z } } = 1$ ein equation 9. Training was performed on a single Nvidia GeForce RTX 3080 GPU with 10 GB of VRAM; approximately 15 hours was required to train for 5000 epochs. ",
+        "bbox": [
+            163,
+            540,
+            825,
+            723
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "229 4 Results and discussion ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            741,
+            392,
+            758
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the first experiment, a Metropolis-CVAE is trained on online simulated labeled data $\\mathbf { x } _ { \\ell } \\sim \\widetilde { p } _ { \\ell } ( \\mathbf { x } )$ as well as precomputed simulated data $\\mathbf { x } _ { u } \\sim \\widetilde { p } _ { u , 3 } ( \\mathbf { x } )$ with labels held out during training. Figure 1(A-G) eshows the distributions of prediction errors by the trained network for each label. For each method, the prediction error is defined as the difference between the true label and the mean of the posterior samples. The labels have been normalized to [0, 1]. The histograms for the Metropolis-CVAE with 100 posterior samples are more tightly clustered around zero than MCMC with either 100 or 3000 posterior samples – denoted MCMC-100 and MCMC-3000 – in all cases except for one (Figure 1F). Figure 1H shows a $p { - } p$ plot: the fraction of posterior samples greater than or equal to the true label, $p$ is plotted against the cumulative distribution of $p$ -values across the data set; the Metropolis-CVAE produces similar curves as MCMC-3000. ",
+        "bbox": [
+            165,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "240 In the second experiment, a Metropolis-CVAE is similarly trained using labeled simulated $\\mathbf { x } _ { \\ell } \\sim \\widetilde { p } _ { \\ell } ( \\mathbf { x } )$ ,   \n241 but now with the unlabeled data $\\mathbf { x } _ { u }$ drawn from the MRI data sets $\\widetilde { p } _ { u , 1 } ( \\mathbf { x } )$ and $\\widetilde { p } _ { u , 2 } ( \\mathbf { x } )$ e. For   \n242 e ecomparison, a second traditional CVAE is trained on the simulated data only. Figure 2A shows the   \n243 acceptance rate of the proposed pseudo labels $\\widetilde { \\mathbf { y } } ^ { \\prime } \\sim Q ( \\mathbf { y } ^ { \\prime } )$ for each data set during training. As the   \n244 eMetropolis-CVAE continually learns from both data sets, we find that the network quickly enters   \n245 a negative feedback loop in which the acceptance rate continually increases throughout training.   \n246 Noteworthy is that the acceptance rate of $\\widetilde { \\mathbf { y } }$ converges to a value between 0.6 and 0.7 for both datasets.   \n247 eThe default target acceptance rate of the No-U-Turn sampler is 0.65, a value which originates from   \n248 a theoretical result pertaining to Hamiltonian Monte Carlo (HMC) [14]. Theoretical work would   \n249 be required to demonstrate a direct connection between Metropolis-CVAEs and the HMC result.   \n250 However, this illustrates that the network neither accepts nor rejects more proposals than is typically   \n251 desired. Figure 2(B-C) shows the average Wasserstein distance between empirical label distributions   \n252 from the Metropolis-CVAE with MCMC-100 and MCMC-3000, respectively. During training, the   \n253 Metropolis-CVAE quickly reaches minimum Wasserstein distances with respect to MCMC-100.   \n254 Minima are reached with respect to MCMC-3000 similarly quickly. We can extrapolate from this   \n255 result that the Metropolis-CVAE likely produces higher quality posterior samples than MCMC-3000.   \n256 This may be expected, as the Metropolis-CVAE updates its pseudo labels at every training iteration,   \n257 continuously performing MCMC throughout training using the MH update rule 8.   \n258 Figure 3(A-G) compares the empirical distributions of a traditional CVAE trained only on simulated   \n259 data with a Metropolis-CVAE. Histograms of the Wasserstein distances between the two networks and   \n260 MCMC-100 do not show large differences, due to the low-quality of MCMC-100. Compared with   \n261 MCMC-3000, parameters which are traditionally easier to infer, such as $\\alpha$ and $\\beta$ , show little difference   \n262 between the networks. The CVAE trained on supervised data alone shows significant deviation from   \n263 MCMC-3000 for several parameters, particularly $\\eta$ , $\\delta _ { 1 }$ , and $\\log \\epsilon$ . This illustrates the ability of the   \n264 Metropolis-CVAE to generalize well to the unlabeled test data, as unlabeled training data from $\\widetilde { p } _ { u } ( \\mathbf { x } )$   \n265 ehas been explicitly incorporated into its training process. Figure 3(H) shows quantile-quantile plots   \n266 for distributions of all label samples across the data sets. All methods agree.   \n267 Limitations A limitation of this method is the requirement of a likelihood function which is fast to   \n268 compute in order to perform the Metropolis-Hastings update step 8. For physics models, computing   \n269 the likelihood of a set of parameters often involves costly forward simulations of complex models.   \n270 Therefore, computationally intensive models which require solving non-trivial integral or differential   \n271 equations will not be suitable.   \n272 Another limitation is that the pseudo label sampling procedure may converge to a stable local   \n273 minimum which is far from the globally optimal labels. This is inherent to the MH update step; while   \n274 MCMC methods often provide convergence guarantees in the limit of large numbers of update steps,   \n275 one can not predict how many update steps this will require in practice. However, by training the   \n276 Metropolis-CVAE on both simulated data generated from the prior space as well as real unlabeled   \n277 data, we have not found this to be a practical concern. ",
+        "bbox": [
+            138,
+            90,
+            826,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            345,
+            825,
+            470
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            486,
+            825,
+            554
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            561,
+            825,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Potential negative societal impacts This work describes a framework for ascribing labels to unlabeled data. Potential malicious and unintended uses could occur if this framework were significantly extended beyond the MRI physics inference problem which we considered. For example, this methodology could be used to infer missing data generally, with the inferred data then presented under the pretense that it were true data. Further, we have not shown that our method of data inference for unlabeled data is inherently fair, nor that the clinical MRI data under which the Metropolis-CVAE model is trained on cannot be recovered from the network weights. ",
+        "bbox": [
+            161,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "285 References   \n286 [1] Udo von Toussaint. Bayesian inference in physics. Reviews of Modern Physics, 83(3):943–999,   \n287 September 2011. doi: 10.1103/RevModPhys.83.943. URL https://link.aps.org/doi/   \n288 10.1103/RevModPhys.83.943. Publisher: American Physical Society.   \n289 [2] Kihyuk Sohn, Honglak Lee, and Xinchen Yan. Learning Structured Output Representation   \n290 using Deep Conditional Generative Models. In C. Cortes, N. Lawrence, D. Lee, M. Sugiyama,   \n291 and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 28. Curran   \n292 Associates, Inc., December 2015. URL https://proceedings.neurips.cc/paper/2015/   \n293 file/8d55a249e6baa5c06772297520da2051-Paper.pdf.   \n294 [3] Diederik P. Kingma, Danilo J. Rezende, Shakir Mohamed, and Max Welling. Semi-Supervised   \n295 Learning with Deep Generative Models. arXiv:1406.5298 [cs, stat], October 2014. URL   \n296 http://arxiv.org/abs/1406.5298. arXiv: 1406.5298.   \n297 [4] Hunter Gabbard, Chris Messenger, Ik Siong Heng, Francesco Tonolini, and Roderick   \n298 Murray-Smith. Bayesian parameter estimation using conditional variational autoencoders   \n299 for gravitational-wave astronomy. arXiv:1909.06296 [astro-ph, physics:gr-qc], September   \n300 2019. URL http://arxiv.org/abs/1909.06296. arXiv: 1909.06296.   \n301 [5] Nicholas Metropolis, Arianna W. Rosenbluth, Marshall N. Rosenbluth, Augusta H. Teller, and   \n302 Edward Teller. Equation of State Calculations by Fast Computing Machines. The Journal of   \n303 Chemical Physics, 21(6):1087–1092, June 1953. ISSN 0021-9606. doi: 10.1063/1.1699114.   \n304 URL https://aip.scitation.org/doi/10.1063/1.1699114. Publisher: American In  \n305 stitute of Physics.   \n306 [6] W. K. Hastings. Monte Carlo sampling methods using Markov chains and their applications.   \n307 Biometrika, 57(1):97–109, April 1970. ISSN 0006-3444. doi: 10.1093/biomet/57.1.97. URL   \n308 https://doi.org/10.1093/biomet/57.1.97.   \n309 [7] Thomas Prasloski, Burkhard Mädler, Qing-San Xiang, Alex MacKay, and Craig Jones.   \n310 Applications of stimulated echo correction to multicomponent T2 analysis. Magnetic   \n311 Resonance in Medicine, 67(6):1803–1814, 2012. ISSN 1522-2594. doi: 10.1002/   \n312 mrm.23157. URL https://onlinelibrary.wiley.com/doi/abs/10.1002/mrm.23157.   \n313 _eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1002/mrm.23157.   \n314 [8] S. O. Rice. Mathematical Analysis of Random Noise. Bell System Technical Journal, 23(3):   \n315 282–332, 1944. ISSN 1538-7305. doi: 10.1002/j.1538-7305.1944.tb00874.x. URL https:   \n316 //onlinelibrary.wiley.com/doi/abs/10.1002/j.1538-7305.1944.tb00874.x.   \n317 _eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1002/j.1538-7305.1944.tb00874.x.   \n318 [9] S. O. Rice. Mathematical Analysis of Random Noise. Bell System Technical Journal, 24(1):   \n319 46–156, 1945. ISSN 1538-7305. doi: 10.1002/j.1538-7305.1945.tb00453.x. URL https:   \n320 //onlinelibrary.wiley.com/doi/abs/10.1002/j.1538-7305.1945.tb00453.x.   \n321 _eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1002/j.1538-7305.1945.tb00453.x.   \n322 [10] H. Y. Carr and E. M. Purcell. Effects of Diffusion on Free Precession in Nuclear Magnetic   \n323 Resonance Experiments. Physical Review, 94(3):630–638, May 1954. doi: 10.1103/PhysRev.94.   \n324 630. URL https://link.aps.org/doi/10.1103/PhysRev.94.630. Publisher: American   \n325 Physical Society.   \n326 [11] S. Meiboom and D. Gill. Modified Spin-Echo Method for Measuring Nuclear Relaxation   \n327 Times. Review of Scientific Instruments, 29(8):688–691, August 1958. ISSN 0034-6748. doi:   \n328 10.1063/1.1716296. URL https://aip.scitation.org/doi/abs/10.1063/1.1716296.   \n329 Publisher: American Institute of Physics.   \n330 [12] Kenneth P. Whittall, Alex L. Mackay, Douglas A. Graeb, Robert A. Nugent, David K. B.   \n331 Li, and Donald W. Paty. In vivo measurement of T2 distributions and water contents in   \n332 normal human brain. Magnetic Resonance in Medicine, 37(1):34–43, 1997. ISSN 1522-2594.   \n333 doi: 10.1002/mrm.1910370107. URL https://onlinelibrary.wiley.com/doi/abs/10.   \n334 1002/mrm.1910370107. ",
+        "bbox": [
+            143,
+            65,
+            828,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "35 [13] Matthew D Hoffman and Andrew Gelman. The No-U-Turn sampler: adaptively setting path lengths in Hamiltonian Monte Carlo. J. Mach. Learn. Res., 15(1):1593–1623, 2014. ",
+        "bbox": [
+            150,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[14] Alexandros Beskos, Natesh Pillai, Gareth Roberts, Jesus-Maria Sanz-Serna, and Andrew Stuart. Optimal tuning of the hybrid Monte Carlo algorithm. Bernoulli, 19 (5A):1501–1534, November 2013. ISSN 1350-7265. doi: 10.3150/12-BEJ414. URL https://projecteuclid.org/journals/bernoulli/volume-19/issue-5A/ Optimal-tuning-of-the-hybrid-Monte-Carlo-algorithm/10.3150/12-BEJ414. full. Publisher: Bernoulli Society for Mathematical Statistics and Probability. ",
+        "bbox": [
+            176,
+            130,
+            825,
+            214
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            239,
+            254,
+            256
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            267,
+            339,
+            281
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See the Limitations paragraph of the Results and discussion section.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] See the Potential negative societal impacts paragraph of the Results and discussion section.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            286,
+            825,
+            406
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            410,
+            493,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "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": [
+            236,
+            429,
+            738,
+            460
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            465,
+            393,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] Code to reproduce the main results is included with the supplemental material. The MRI data cannot be included, as it is medical data. However, the simulated data is provided in the supplemental material.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See the Training subsection of the Experiments section.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We provide entire histograms of relevant error metrics; see Figures 1 and 3.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See the MCMC data paragraph of the Data sets subsection of the Experiments section, as well as the Training subsection of the Experiments section. ",
+        "bbox": [
+            238,
+            484,
+            825,
+            685
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            690,
+            823,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] The trained models are supplied in the supplemental material.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] See the MRI data paragraph of the Data sets subsection of the Experiments section.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] The MRI data used in this work is anonymized; see the MRI data paragraph of the Data sets subsection of the Experiments section. ",
+        "bbox": [
+            238,
+            709,
+            825,
+            859
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            863,
+            705,
+            878
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [No] This was a prospective study; this information was not available. ",
+        "bbox": [
+            236,
+            883,
+            828,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "385 (b) Did you describe any potential participant risks, with links to Institutional Review   \n386 Board (IRB) approvals, if applicable? [Yes] These MRI scans were acquired with   \n387 approval from our university ethics board; see the MRI data paragraph of the Data sets   \n388 subsection of the Experiments section.   \n389 (c) Did you include the estimated hourly wage paid to participants and the total amount   \n390 spent on participant compensation? [N/A] ",
+        "bbox": [
+            140,
+            90,
+            826,
+            179
+        ],
+        "page_idx": 11
+    }
+]