Add files using upload-large-folder tool

parse/train/BkxAUjRqY7/BkxAUjRqY7.md

@@ -0,0 +1,569 @@
+# AN INFORMATION-THEORETIC METRIC OF TRANSFERABILITY FOR TASK TRANSFER LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+An important question in task transfer learning is to determine task transferability, i.e. given a common input domain, estimating to what extent representations learned from a source task can help in learning a target task. Typically, transferability is either measured experimentally or inferred through task relatedness, which is often defined without a clear operational meaning. In this paper, we present a novel metric, $H$ -score, an easily-computable evaluation function that estimates the performance of transferred representations from one task to another in classification problems. Inspired by a principled information theoretic approach, H-score has a direct connection to the asymptotic error probability of the decision function based on the transferred feature. This formulation of transferability can further be used to select a suitable set of source tasks in task transfer learning problems or to devise efficient transfer learning policies. Experiments using both synthetic and real image data show that not only our formulation of transferability is meaningful in practice, but also it can generalize to inference problems beyond classification, such as recognition tasks for 3D indoor-scene understanding.
+
+# 1 INTRODUCTION
+
+Transfer learning is a learning paradigm that exploits relatedness between different learning tasks in order to gain certain benefits, e.g. reducing the demand for supervision (Pratt (1993)). In task transfer learning, we assume that the input domain of the different tasks are the same. Then for a target task $\mathcal { T } _ { T }$ , instead of learning a model from scratch, we can initialize the parameters from a previously trained model for some related source task $\mathcal { T } _ { S }$ . For example, deep convolutional neural networks trained for the ImageNet classification task have been used as the source network in transfer learning for target tasks with fewer labeled data (Donahue et al. (2014)), such as medical image analysis (Shie et al. (2015)) and structural damage recognition in buildings (Gao & Mosalam).
+
+An imperative question in task transfer learning is transferability, i.e. when a transfer may work and to what extent. Given a metric capable of efficiently and accurately measuring transferability across arbitrary tasks, the problem of task transfer learning, to a large extent, is simplified to search procedures over potential transfer sources and targets as quantified by the metric. Traditionally, transferability is measured purely empirically using model loss or accuracy on the validation set (Yosinski et al. (2014); Zamir et al. (2018); Conneau et al. (2017)). There have been theoretical studies that focus on task relatedness (Baxter (2000); Maurer (2009); Pentina & Lampert (2014); Ben-David et al. (2003)). However, they either cannot be computed explicitly from data or do not directly explain task transfer performance. In this study, we aim to estimate transferability analytically, directly from the training data.
+
+We quantify the transferability of feature representations across tasks via an approach grounded in statistics and information theory. The key idea of our method is to show that the error probability of using a feature of the input data to solve a learning task can be characterized by a linear projection of this feature between the input and output domains. Hence we adopt the projection length as a metric of the feature’s effectiveness for the given task, and refer to it as the $H$ -score of the feature. More generally, H-score can be applied to evaluate the performance of features in different tasks, and is particularly useful to quantify feature transferability among tasks. Using this idea, we define task transferability as the normalized H-score of the optimal source feature with respect to the target task.
+
+As we demonstrate in this paper, the advantage of our transferability metric is threefold. (i) it has a strong operational meaning rooted in statistics and information theory; (ii) it can be computed directly and efficiently from the input data, with fewer samples than those needed for empirical learning; (iii) it can be shown to be strongly consistent with empirical transferability measurements.
+
+In this paper, we will first present the theoretical results of the proposed transferability metric in Section 2-4. Section 5 presents several experiments on real image data , including image classificaton tasks using the Cifar 100 dataset and 3D indoor scene understanding tasks using the Taskonomy dataset created by Zamir et al. (2018). A brief review of the related works is included in Section 6.
+
+# 2 BACKGROUND
+
+In this section, we will introduce the notations used throughout this paper, as well as some related concepts in Euclidean information theory and statistics.
+
+$X$ $, x , \chi$ and $P _ { X }$ represent a random variable, a value, the alphabet and the probability distribution respectively. $\sqrt { \mathrm { P } _ { X } }$ denotes the vector with entries $\sqrt { P _ { X } ( x ) }$ and $[ { \sqrt { \operatorname { P } _ { X } } } ]$ the diagonal matrix of $\sqrt { P _ { X } ( X ) }$ . For joint distribution $P _ { Y X }$ , $\operatorname { P } _ { Y X }$ represents the $| y | \times | \mathcal { X } |$ probability matrix. Depending on the context, $\operatorname { f } ( X )$ is either a $| \mathcal { X } |$ -dimensional vector whose entries are $f ( x )$ , or a $| { \mathcal { X } } | \times k$ feature matrix. Further, we define a task to be a tuple $\mathcal { T } = ( X , Y , P _ { X Y } )$ , where $X$ is the training features and $Y$ is the training label, and $P _ { X Y }$ the joint probability (possibly unknown). Subscripts $S$ and $T$ are used to distinguish the source task from the target task.
+
+# 2.1 LOCAL INFORMATION GEOMETRY AND HYPOTHESIS TESTING
+
+Our definiton of transferability uses concepts in local information geometry developed by Makur et al. (2015), which characterizes probability distributions as vectors in the information space. Consider the following binary hypothesis testing problem: test whether i.i.d. samples $\mathbf { x } ^ { m } = \{ x ^ { ( i ) } \} _ { i = 1 } ^ { m }$ )}mi=1 are drawn from distribution $P _ { 1 }$ or distribution $P _ { 2 }$ , where $P _ { 1 } , P _ { 2 }$ belong to an $\epsilon$ -neighborhood $\mathcal { N } _ { \epsilon } ( P _ { 0 } ) \overset { \Delta } { = }$ $\begin{array} { r } { \{ P \vert \sum _ { x \in \mathcal { X } } \frac { ( P ( x ) - P _ { 0 } ( x ) ) ^ { 2 } } { P _ { 0 } ( x ) } \leq \epsilon ^ { 2 } \} } \end{array}$ centered at a reference distributon $P _ { 0 }$ . And denote $\begin{array} { r } { \phi _ { i } = \frac { P _ { i } ( x ) - P _ { 0 } ( x ) } { \epsilon \sqrt { P _ { 0 } ( x ) } } } \end{array}$ as the information vector corresponding to $P _ { i }$ for $i = 1 , 2$ .
+
+Given $k$ normalized feature functions $f ( x ) = [ f _ { 1 } ( x ) , \ldots , f _ { k } ( x ) ]$ , let $\Xi ( x ) = [ \xi _ { 1 } ( x ) , \dots , \xi _ { k } ( x ) ]$ be the matrix of feature vectors $\xi _ { i } ( x ) = \sqrt { P _ { 0 } ( x ) } f _ { i } ( x )$ . Given observations $\mathbf { x } ^ { m }$ , feature $f$ is associated with a $\mathbf { k }$ -dimensional statistics $\begin{array} { r } { l ( \mathbf { x } ^ { m } ) = \frac { 1 } { m } \sum _ { i = 1 } ^ { m } ( f ( x ^ { ( i ) } ) ) } \end{array}$ for the binary hypothesis testing problem. Let $E _ { f }$ be the error exponent of decision region $\{ \mathbf { x } ^ { m } \mid l ( \mathbf { x } ^ { m } ) > T \}$ for , which characterizes the asymptotic error probability $P _ { e }$ of $l$ (i.e. $\begin{array} { r } { \operatorname* { l i m } _ { m  \infty } - \frac { 1 } { m } \log ( P _ { e } ) = E _ { f } ^ { k } } \end{array}$ ). $E _ { f }$ can be written as the squared length of a projection:
+
+$$
+E _ { f } ^ { k } = \sum _ { i = 1 } ^ { k } E _ { f _ { i } } = \sum _ { i = l } ^ { k } \frac { \epsilon ^ { 2 } } { 8 } \left. \xi _ { i } , \phi _ { 1 } - \phi _ { 2 } \right. ^ { 2 } + o \left( \epsilon ^ { 2 } \right)
+$$
+
+When the la $\begin{array} { r } { f ( x ) = \log \frac { P _ { 1 } ( x ) } { P _ { 2 } ( x ) } } \end{array}$ is tent $l$ m sufficient statistics that achievesby the Chernoff theorem. (See $\begin{array} { r } { E _ { f } ^ { k } = \sum _ { i = 1 } ^ { k } \frac { \epsilon ^ { 2 } } { 8 } | | \phi _ { 1 } - \phi _ { 2 } | | ^ { 2 } + o ( \epsilon ^ { 2 } ) } \end{array}$   
+Appendix A for details.) In the rest of this paper, we assume $\epsilon$ is small.
+
+# 2.2 DIVERGENCE TRANSITION MATRIX
+
+Definition 1. Matrix $\tilde { B }$ is the Divergence Transition Matrix (DTM) of a joint probability $P _ { Y X }$ if $\tilde { B } = \left[ \sqrt { \mathrm { P } _ { Y } } \right] ^ { - 1 } \mathrm { P } _ { Y X } \left[ \sqrt { \mathrm { P } _ { X } } \right] ^ { - 1 } - \sqrt { \mathrm { P } _ { Y } } \sqrt { \mathrm { P } _ { X } } ^ { \mathrm { T } }$ .
+
+The singular values of $\tilde { B }$ satisfy that $1 \geq \sigma _ { 1 } \geq \cdot \cdot \cdot \geq \sigma _ { K } = 0 , K \triangleq \operatorname* { m i n } \{ | \mathcal { X } | , | \mathcal { V } | \}$ . Let $\Psi =$ $[ \psi _ { 1 } , \dots , \psi _ { K } ]$ and $\Phi = [ \phi _ { 1 } , \dots , \phi _ { K } ]$ be the left and right singular vectors of $\tilde { B }$ . Define functions $\begin{array} { r } { f _ { i } ^ { * } ( x ) = \frac { \phi _ { i } ( x ) } { \sqrt { P _ { X } ( x ) } } } \end{array}$ and $\begin{array} { r } { g _ { i } ^ { * } ( y ) = \frac { \psi _ { i } ( y ) } { \sqrt { P _ { Y } ( y ) } } } \end{array}$ for each $i = 1 , \ldots , K - 1$ . Makur et al. (2015) further
+
+proved that $f _ { i } ^ { * }$ and $g _ { i } ^ { * }$ are solutions to the maximal HGR correlation problem studied by Hirschfeld (1935); Gebelein (1941); Renyi (1959), defined as follows: ´
+
+$$
+\begin{array} { c } { \rho ( X ; Y ) = \displaystyle \operatorname* { s u p } _ { f : \mathcal { X } \to \mathbb { R } ^ { k } , g : \mathcal { Y } \to \mathbb { R } ^ { k } } \mathbb { E } [ f ( X ) ^ { T } g ( Y ) ] } \\ { \mathbb { E } [ f ( X ) ] = \mathbb { E } [ g ( Y ) ] = 0 } \\ { \mathbb { E } [ f ( X ) f ( X ) ^ { T } ] = I } \end{array}
+$$
+
+The maximal HGR problem finds the $K$ strongest, independent modes in $P _ { X Y }$ from data. It can be solved efficiently using the Alternating Conditional Expectation (ACE) algorithm with provable error bound (see Appendix B). Huang et al. (2017) further showed that $f ^ { * }$ and $g ^ { * }$ are the universal minimum error probability features in the sense that they can achieve the smallest error probability over all possible inference tasks.
+
+3 MEASURING THE EFFECTIVENESS OF FEATURES IN CLASSIFICATION TASKS
+
+In this section, we present a performance metric of a given feature representation for a learning task.
+
+# 3.1 H-SCORE
+
+For a classification task involving input variable $X$ and label $Y$ , most learning algorithms work by finding a $k$ -dimensional functional representation $f ( x )$ of $X$ that is most discriminative for the classification. To measure how effective $f ( x )$ is in predicting $Y$ , rather than train the model via gradient descent and evaluate its accuracy, we present an analytical approach based on the definition below:
+
+Definition 2. Given data matrix $\boldsymbol { X } ~ \in ~ \mathbb { R } ^ { m \times d }$ and label $Y \in \{ 1 , \dots , | y | \}$ . Let $f ( x )$ be a $k$ - dimensional, zero-mean feature function. The $H$ -Score of $f ( x )$ with respect to the learning task represented by $P _ { Y X }$ is:
+
+$$
+\mathcal { H } ( f ) = \mathrm { t r } ( \mathrm { c o v } ( f ( X ) ) ^ { - 1 } \mathrm { c o v } ( \mathbb { E } _ { P _ { X | Y } } [ f ( X ) | Y ] ) )
+$$
+
+This definition is intuitive from a nearest neighbor search perspective. i.e. a high $_ \mathrm { H }$ -score implies the inter-class variance c $\operatorname { o v } ( \mathbb { E } _ { P _ { X \mid Y } } [ f ( X ) | Y ] )$ of $f$ is large, while feature redundancy $\operatorname { t r } ( \operatorname { c o v } ( f ( X ) ) )$ is small. Such a feature is discriminative and efficient for learning label Y. More importantly, $\mathcal { H } ( f )$ has a deeper operational meaning related to the asymptotic error probability for a decision rule based on $f$ in the hypothesis testing context, discussed in the next section.
+
+# 3.2 OPERATIONAL MEANING OF H-SCORE
+
+Without loss of generality, we consider the binary classification task as a hypothesis testing problem defined in Section 2.1, with $P _ { 1 } = P _ { X | Y = 0 }$ , and $P _ { 2 } = P _ { X | Y = 1 }$ . For any $\mathbf { k }$ -dimensional feature representation $f ( x )$ , we can quantify its performance with respect to the learning task using its error exponent $E _ { f } ^ { k }$ .
+
+Theorem 1. Given $P _ { X | Y = 0 } , P _ { X | Y = 1 } \in \mathcal { N } _ { \epsilon } ^ { \mathcal { X } } ( P _ { 0 , X } )$ and features $f$ such that $\mathbb { E } \left[ f ( X ) \right] = 0$ and $\mathbb { E } [ f ( X ) f ( X ) ^ { \mathrm { T } } ] = I$ , there exists some constant $c$ independent of $f$ such that $E _ { f } ^ { k } = c { \mathcal { H } } ( f )$ .
+
+See Appendix C for the proof. The above theorem shows that $_ \mathrm { H }$ -score $\mathcal { H } ( f )$ is proportional to the error exponent of the decision region based on $f ( x )$ when $f ( x )$ is zero-mean with identity covariance. To compute the $_ \mathrm { H }$ -score of arbitrary $f$ , we can center the features $f _ { S } ( x ) - \mathbb { E } [ f _ { S } ( x ) ]$ , and incorporate normalization into the computation of the error exponent, which results in Definition 2. The details are presented in Appendix D.
+
+The proof for Theorem 1 uses the fact that $\mathcal { H } ( f ) = \| \tilde { B } \Xi \| _ { F } ^ { 2 }$ , where $\tilde { B }$ is the DTM matrix, $\Xi \triangleq$ $[ \xi _ { 1 } \cdot \cdot \cdot \xi _ { k } ]$ is the matrix composed of information vectors $\xi _ { i }$ and $c$ is a constant. This allows us to infer an upper bound for the $_ \mathrm { H }$ -score of a given learning task:
+
+Corollary 1. For all normalized feature $f ( x ) = [ f _ { 1 } ( x ) , \ldots , f _ { k } ( x ) ] ,$ , its $H .$ -score satisfies $\mathcal { H } ( f ) \leq$ $\textstyle \sum _ { i = 1 } ^ { k } \sigma _ { i } ^ { 2 } \leq k$ , where $\sigma _ { i }$ is the ith singular value of $\tilde { B }$ .
+
+![](images/cfab31041936a54f0b428e33c560129864be3cefccfb8af62435731212aebb0b.jpg)  
+Figure 1: A simple neural network topology for transfer learning
+
+The first inequality is achieved when $\Xi$ is composed of the right singular vectors of $\tilde { B }$ , i.e. $\mathrm { m a x } _ { \Xi } | | \tilde { B } \Xi | | _ { F } ^ { 2 } = | | \tilde { B } _ { T } | | _ { F } ^ { 2 }$ . The corresponding feature functions $\mathrm { f _ { o p t } } ( X )$ is in fact the same as the universal minimum error probability features from the maximum HGR correlation problem. The final inequality in Corollary 1 is due to the fact all singular values of $\tilde { B }$ are less than or equal to 1.
+
+# 4 TRANSFERABILITY
+
+Next, we apply $_ \mathrm { H }$ -score to efficiently measure the effectiveness of task transfer learning. We will also discuss how this approach can be used to solve the source task selection problem.
+
+# 4.1 TASK TRANSFERABILITY
+
+A typical way to transfer knowledge from the source task $\mathcal { T } _ { S }$ to target task $\mathcal { T } _ { T }$ is to train the target task using source feature representation $f _ { S } ( x )$ . In a neural network setting, this idea can be implemented by copying the parameters from the first $\mathbf { N }$ layers in the trained source model to the target model, assuming the model architecture on those layers are the same. The target classifier then can be trained while freezing parameters in the copied layers (Figure 1). Under this model, a natural way to quantify transferability is as follows:
+
+Definition 3 (Task transferability). Given source task $\tau _ { S }$ and target task $\mathcal { T } _ { T }$ , and trained source feature representation $f _ { S } ( x )$ , the transferability from $\mathcal { T } _ { S }$ to $\mathcal { T } _ { T }$ is $\begin{array} { r } { \mathfrak { T } ( S , T ) \triangleq \frac { \mathcal { H } _ { T } ( f _ { S } ) } { \mathcal { H } _ { T } ( f _ { T _ { \mathrm { o p t } } } ) } } \end{array}$ , where $f _ { T _ { \mathrm { o p t } } } ( x )$ is the minimum error probability feature of the target task.
+
+The statement ${ \mathfrak { T } } ( S , T ) = r$ means the error exponent of transfering from $\mathcal { T } _ { S }$ via feature representation $f _ { S }$ is $\textstyle { \frac { 1 } { r } }$ of the optimal error exponent for predicting the target label $Y _ { T }$ . This definition also implies $0 \leq \mathfrak { T } ( S , T ) \leq 1$ , which satisfies the data processing inequality if we consider the transferred feature $f _ { S } ( X )$ as post-processing of input $X$ for solving the target task. And it can not increase information about predicting the target task $\tau$ .
+
+A common technique in task transfer learning is fine-tuning, which adds before the target classifier additional free layers, whose parameters are optimized with respect to the target label. For the operational meaning of transferability to hold exactly, we require the fine tuning layers consist of only linear transformations, such as the model illustrated in Figure 2.a. It can be shown that under the local assumption, $\mathrm { H }$ -score is equivalent to the log-loss of the linear transfer model up to a constant offset (Appendix E). Nevertheless, later we will demonstrate empirically that this transferability metric can still be used for comparing the relative task transferability with fine-tuning.
+
+# 4.2 EFFICIENT COMPUTATION OF TRANSFERABILITY
+
+With a known $f$ , computing H-score from $m$ sample data only takes $O ( m k ^ { 2 } )$ time, where $k$ is the dimension of $f ( x )$ for $k < m$ . The majority of the computation time is spent on computing the sample covariance matrix $\operatorname { c o v } ( f ( X ) )$ .
+
+The remaining question is how to obtain $f _ { T _ { o p t } }$ efficiently. We use the fact that $\mathcal { H } _ { T } ( f _ { \mathrm { o p t } } ) = | | \tilde { B } _ { T } | | _ { F } ^ { 2 } =$ $\mathbb { E } [ f ( X ) ^ { \mathrm { T } } g ( Y ) ]$ , where $f$ and $g$ are the solutions of the HGR-Maximum Correlation problem. This problem can be solved efficiently using the ACE algorithm for discrete variable $X$ . For a continuous random variable $X$ , we can obtain $f _ { o p t }$ through a different formulation of the HGR maximal
+
+![](images/0144f59fae60eeff86e16163f2851f97ca1e916dd60f6f879555c33d12f1e03d.jpg)  
+Figure 2: a) Network topology of linear feature transfer. b) Architec- Figure 3: H-score and muture for the neural network implementation of the soft HGR problem tual information.
+
+correlation problem:
+
+$$
+\operatorname* { m a x } _ { f : \mathcal { X } \to \mathbb { R } ^ { k } , g : \mathcal { Y } \to \mathbb { R } ^ { k } } \mathbb { E } [ f ( X ) ^ { \mathrm { T } } g ( Y ) ] - \frac { 1 } { 2 } \mathrm { t r } ( \mathrm { c o v } ( f ( X ) ) \mathrm { c o v } ( g ( Y ) ) )
+$$
+
+This is also known as the soft HGR problem studied by Wang et al. (2019), who reformulated the original maximal HGR correlation objective to eliminate the whitening constraints while having theoretically equivalent solution. In practice, we can utilize neural network layers to model functions $f$ and $g$ , as shown in Figure 2.b. Given two branches of $k$ output units for both $f$ and $g$ , the loss function can be evaluated in $O ( m k ^ { 2 } )$ , where $m$ is the batch size. Makur et al. (2015) showed that the sample complexity of ACE is only $1 / k$ of the complexity of estimating $P _ { Y , X }$ directly. This result also applies to the soft HGR problem due to their theoretical equivalence. Hence transferability can be computed with much less samples than actually training the transfer network.
+
+It’s also worth noting that, when $\overline { f }$ is fixed, maximizing the objective in Equation 3 with respect to zero-mean function $g$ results in the definition of H-score. In many cases though, the computation of $H _ { T } ( f _ { o p t } )$ can even be skipped entirely, such as the problem below:
+
+Definition 4 (Source task selection). Given $N$ source tasks $\mathcal { T } _ { S _ { 1 } } , \dots , \mathcal { T } _ { S _ { N } }$ with labels $Y _ { S _ { 1 } } , \dots , Y _ { S _ { N } }$ and a target task $\mathcal { T } _ { T }$ with label $Y _ { T }$ . Let $f _ { S _ { 1 } } , \dots , f _ { S _ { N } }$ be the minimum error probability feature functions of the source tasks. Find the source task $\mathcal { T } _ { S _ { i } }$ that maximizes the testing accuracy of predicting $Y _ { T }$ with feature $f _ { S _ { i } }$ .
+
+We can solve this problem by selecting the source task with the largest transferability to $\mathcal { T } _ { T }$ . In fact, we only need to compute the numerator in the transferability definition since the denominator is the same for all source tasks, i.e. argmaxi $\mathfrak { T } ( S _ { i } , T ) = \mathrm { a r g m a x } _ { i } \overset { \cdot } { ( } \mathcal { H } _ { T } ( f _ { S _ { i , \mathrm { o p t } } } ) / \mathcal { H } _ { T } ( f _ { T _ { \mathrm { o p t } } } ) = \mathrm { a r g m a x } _ { i } \mathcal { H } ( f _ { S _ { i } } )$ .
+
+# 4.3 RELATIONSHIP WITH MUTUAL INFORMATION
+
+Under the local assumption that $P _ { X | Y } \in N _ { \epsilon } ( P _ { X } )$ , we can show that mutual information $I ( X ; Y ) =$ $\textstyle \frac { 1 } { 2 } | | B | | _ { F } ^ { 2 } + o ( \epsilon ^ { 2 } )$ . (See Appendix F for details.) Hence $_ \mathrm { H }$ -score is related to mutual information by $\bar { \mathcal { H } } ( f ( x ) ) \leq 2 I ( X ; Y )$ for any zero-mean features $f ( x )$ satisfying the aforementioned conditions.
+
+Figure 3 compares the optimal H-score of a synthesized task when $| y | = 6$ with the mutual information between input and output variables, when the feature dimension $k$ changes. The value of H-score increases as $k$ increases, but reaches the upper bound when $k \geq 6$ , since the rank of the joint probability between $X$ and $Y _ { T }$ , as well as the rank of its DTM is 6. As expected, the H-score values are below $2 I ( X ; Y )$ , with a gap due to the constant $o ( \epsilon ^ { 2 } )$ . This relationship shows that H-score is consistent with mutual information with a sufficiently large feature dimension $k$ .
+
+In practice, H-score is much easier to compute than mutual information when the input variable $X$ (or $f _ { S } ( X ) )$ is continous, as mutual information are either computed based on binning, which has extra bias due to bin size, or more sophisticated methods such as kernel density estimation or neural networks (Gabrie et al. (2018)). On the other hand,´ $_ \mathrm { H }$ -score only needs to estimate conditional expectations, which requires less samples.
+
+# 5 EXPERIMENTS
+
+In this section, we validate and analyze our transferability metric through experiments on real image data. 1 The tasks considered cover both object classification and non-classification tasks in computer vision, such as depth estimation and 3D (occlusion) edge detection.
+
+# 5.1 VALIDATION OF TRANSFER PERFORMANCE
+
+To demonstrate that our transferability metric is indeed a suitable measurement for task transfer performance, we compare it with the empirical performance of transfering features learned from ImageNet 1000-class classification (Krizhevsky et al. (2012)) to Cifar 100-class classification (Krizhevsky & Hinton (2009)), using a network similar to Figure 1. Comparing to ImageNet-1000, Cifar-100 has smaller sample size and its images have lower resolution. Therefore it is considered to be a more challenging task than ImageNet, making it a suitable case for transfer learning. In addition, we use a pretrained ResNet-50 as the source model due to its high performance and regular structure.
+
+Validation of H-score. The training data for the target task in this experiemnt consists of 20, 000 images randomly sampled from Cifar-100. It is further split 9:1 into a training set and a testing set. The transfer network was trained using stochastic gradient descent with batch size 20, 000 for 100 epochs.
+
+Figure 4.a compares the H-score of transferring from five different layers (4a-4f) in the source network with the target log-loss and test accuracy of the respective features. As H-score increases, log-loss of the target network decreases almost linearly while the training and testing accuracy increase. Such behavior is consistent with our expectation that H-score reflects the learning performance of the target task. We also demonstrated that target sample size does not affect the relationship between H-score and log-loss (Figure 4.b).
+
+This experiment also showed another potential application of H-score for selecting the most suitable layer for fine-tuning in transfer learning. In the example, transfer performance is better when an upper layer of the source networks is transferred. This could be because the target task and the source task are inherently similar such that the representation learned for one task can still be discriminative for the other.
+
+![](images/79b0d7e0f86bd979429fea61f7b40193807c2c184d200eff4762509ab33dd641.jpg)  
+Figure 4: H-score and transferability vs. the empirical transfer performance measured by log-loss, training and testing accuracy. a.) Performance of ImageNet-1000 features from layers 4a-4f for Cifar100 classification. b.) Effect of sample size (5K-50K) on H-score for Cifar 100. c.): Transferability from ImageNet-1000 to 4 different target tasks based on Cifar-100.
+
+Validation of Transferability. We further tested our transferability metric for selecting the best target task for a given source task. In particular, we constructed 4 target classification tasks with 3, 5, 10, and 20 object categories from the Cifar-100 dataset. We then computed the transferability from ImageNet-1000 (using the feature representation of layer 4f) to the target tasks. The results are compared to the empirical transfer performance trained with batch size 64 for 50 epochs in Figure4.c. We observe a similar behavior as the H-score in the case of a single target task in Figure 4.a, showing that transferability can directly predict the empirical transfer performance.
+
+# 5.2 TASK TRANSFER FOR 3D SCENE UNDERSTANDING
+
+In this experiment, we solve the source task selection problem for a collection of 3D sceneunderstanding tasks using the Taskonomy dataset from Zamir et al. (2018). In the following, we will introduce the experiment setting and explain how we adapt the transferability metric to pixel-to-pixel recognition tasks. Then we compare transferability with task affinity, an empirical transferability metric proposed by Zamir et al. (2018).
+
+Data and Tasks. The Taskonomy dataset contains 4,000,000 images of indoor scenes of 600 buildings. Every image has annotations for 26 computer vision tasks. We randomly sampled 20, 000 images as training data. Eight tasks were chosen for this experiment, covering both classifications and lower-level pixel-to-pixel tasks. Table 6 summaries the specifications of these tasks and sample outputs are shown in Figure 5.
+
+![](images/426a4c2513b88a9aa8747829b8895cfbc8ce260f22f5a93dc0875341e7af0387.jpg)  
+Figure 5: Ground truth of different tasks for a given query image.
+
+Feature Extraction and Data Preprocessing. For each task, Zamir et al. (2018) trained a fully supervised network with an encoder-decoder structure. When testing the transfer performance from $\tau _ { S }$ to $\mathcal { T } _ { T }$ , the encoder output of $\mathcal { T } _ { S }$ is used for training the decoder of $\mathcal { T } _ { T }$ . For a fair comparison, we use the same trained encoders to extract source features. The output dimension of all encoders are $1 6 \times 1 6 \times 8$ and we flatten the output into a vector of length 2048. To reduce the computational complexity, we also resize the ground truth images into $6 4 \times 6 4$ .
+
+For classification tasks, H-score can be easily calculated given the source features. But for pixel-topixel tasks such as Edges and Depth, their ground truths are represented as images, which can not be quantized easily. As a workaround, we cluster the pixel values in the ground truth images into a palette of 16 colors. Then compute the H-score of the source features with respect to each pixel, before aggregating them into a final score by averaging over the whole image.
+
+We ran the experiment on a workstation with $3 . 4 0 \mathrm { G H z } \times 8 $ CPU and $1 6 \mathrm { \ G B }$ memory. Each pairwise H-score computation finished in less than one hour including preprocessing. Then we rank the source tasks according to their H-scores of a given target task and compare the ranking with that in Zamir et al. (2018).
+
+<table><tr><td>Tasks</td><td>k</td><td>Output</td><td>Quantize -level</td></tr><tr><td>2D Edges</td><td>2048</td><td>images</td><td>16</td></tr><tr><td>3D Occlusion</td><td>2048</td><td>images</td><td>16</td></tr><tr><td>Edges 2D Keypoints</td><td>2048</td><td>images</td><td>16</td></tr><tr><td>3D Keypoints</td><td>2048</td><td>images</td><td>16</td></tr><tr><td>Reshading</td><td>2048</td><td>images</td><td>16</td></tr><tr><td>Depth</td><td>2048</td><td>images</td><td>16</td></tr><tr><td>Object Class.</td><td>2048</td><td>labels</td><td>none</td></tr><tr><td>Scene Class.</td><td>2048</td><td>labels</td><td>none</td></tr></table>
+
+![](images/d4e87d19dcf0f341562f3a1c38931fcac46c72e9861e3ad30e60524b94d1cec0.jpg)  
+Figure 6: Task descriptions   
+Figure 7: Ranking comparison between transferability and affinity score.
+
+Pairwise Transfer Results. Source task ranking results using transferability and affinity are visualized side by side in Figure 7, with columns representing source tasks and rows representing target tasks. For classification tasks (the bottom two rows in the transferability matrix), the top two transferable source tasks are identical for both methods. The best source task is the target task itself, as the encoder is trained on a task-specific network with much larger sample size. Scene Class. and Object Class. are ranked second for each other, as they are semantically related. Similar observations can be found in 2D pixel-to-pixel tasks (top two rows). The results on lower rankings are noisier.
+
+A slightly larger difference between the two rankings can be found in 3D pixel-to-pixel tasks, especially 3D Occlusion Edges and 3D Keypoints. Though the top four ranked tasks of both methods are exactly the four 3D tasks. It could indicate that these low level vision tasks are closely related to each other so that the transferability among them are inherently ambiguous. We also computed the ranking correlations between transferability and affinity using Spearman’s R and Discounted Cumulative Gain (DCG). Both criterion show positive correlations for all target tasks. The correlation is especially strong with DCG as higher ranking entities are given larger weights.
+
+The above observations inspire us to define a notion of task relatedness, as some tasks are frequently ranked high for each other. Specifically, we represent each task with a vector consisting of H-scores of all the source tasks, then apply agglomerative clustering over the task vectors. As shown in the dendrogram in Figure 7, 2D tasks and most 3D tasks are grouped into different clusters, but on a higher level, all pixel-to-pixel tasks are considered one category compared to the classifications tasks.
+
+![](images/438e7496076d4d1b76468bfb37dbd0e892e412a9eb5375bf4b07c87d6011e714.jpg)  
+Figure 8: Ranking of second order transferability for all recog- Figure 9: First and second order nition tasks pixel-wise transferability to Depth.
+
+Higher Order Transfer. Sometimes we need to combine features from two or more source tasks for better transfer performance. A common way to combine features from multiple models in deep neural networks is feature concatenation. For such problems, our transferability definition can be easily adapted to high order feature transfer, by computing the H-score of the concatenated features.
+
+Figure 8 shows the ranking results of all combinations of source task pairs for each target task. For all tasks except for 3D Occlusion Edges and Depth, the best seond-order source feature is the combination of the top two tasks of the first-order ranking. We examine the exception in Figure 9, by visualizing the pixel-by-pixel H-scores of first and second order transfers to Depth using a heatmap (lighter color implies a higher H-score). Note that different source tasks can be good at predicting different parts of the image. The top row shows the results of combining tasks with two different “transferability patterns” while the bottom row shows those with similar patterns. Combining tasks with different transferability patterns has a more significant improvement to the overall performance of the target task.
+
+# 6 RELATED WORKS
+
+Transfer learning. Transfer learning can be devided into two categories: domain adaptation, where knowledge transfer is achieved by making representations learned from one input domain work on a different input domain, e.g. adapt models for RGB images to infrared images (Wang & Deng (2018)); and task transfer learning, where knowledge is transferred between different tasks on the same input domain (Torrey & Shavlik (2010)). Our paper focus on the latter prolem.
+
+Empirical studies on transferability. Yosinski et al. (2014) compared the transfer accuracy of features from different layers in a neural network between image classification tasks. A similar study was performed for NLP tasks by Conneau et al. (2017). Zamir et al. (2018) determined the optimal transfer hierarchy over a collection of perceptual indoor scene understanidng tasks, while transferability was measured by a non-parameteric score called ”task affinity” derived from neural network transfer losses coupled with an ordinal normalization scheme.
+
+Task relatedness. One approach to define task relatedness is based on task generation. Generalization bounds have been derived for multi-task learning (Baxter (2000)), learning-to-learn (Maurer (2009)) and life-long learning (Pentina & Lampert (2014)). Although these studies show theoretical results on transferability, it is hard to infer from data whether the assumptions are satisfied. Another approach is estimating task relatedness from data, either explicitly (Bonilla et al. (2008); Zhang
+
+(2013)) or implicitly as a regularization term on the network weights (Xue et al. (2007); Jacob et al.   
+(2009)). Most works in this category are limited to shallow ones in terms of the model parameters.
+
+Representation learning and evaluation. Selecting optimal features for a given task is traditionally performed via feature subset selection or feature weight learning. Subset selection chooses features with maximal relevance and minimal redundancy according to information theoretic or statistical criteria (Peng et al. (2005); Hall (1999)). The feature weight approach learns the task while regularizing feature weights with sparsity constraints, which is common in multi-task learningLiao & Carin (2006); Argyriou et al. (2007). In a different perspective, Huang et al. (2017) consider the universal feature selection problem, which finds the most informative features from data when the exact inference problem is unknown. When the target task is given, the universal feature is equivalent to the minimum error probability feature used in this work.
+
+# 7 CONCLUSION
+
+In this paper, we presented H-score, an information theoretic approach to estimating the performance of features when transferred across classification tasks. Then we used it to define a notion of task transferability in multi-task transfer learning problems, that is both time and sample complexity efficient. The resulting transferability metric also has a strong operational meaning as the ratio between the best achievable error exponent of the transferred representation and the minium error exponent of the target task.
+
+Our transferability score successfully predicted the performance for transfering features from ImageNet-1000 classification task to Cifar-100 task. Moreover, we showed how the transferability metric can be applied to a set of diverse computer vision tasks using the Taskonomy dataset.
+
+In future works, we plan to extend our theoretical results to non-classification tasks, as well as relaxing the local assumptions on the conditional distributions of the tasks. We will also investigate properties of higher order transferability, developing more scalable algorithms that avoid computing the H-score of all task pairs. On the application side, as transferability tells us how different tasks are related, we hope to use this information to design better task hierarchies for transfer learning.
+
+# REFERENCES
+
+Andreas Argyriou, Theodoros Evgeniou, and Massimiliano Pontil. Multi-task feature learning. In Advances in neural information processing systems, pp. 41–48, 2007.   
+Jonathan Baxter. A model of inductive bias learning. Journal of artificial intelligence research, 12: 149–198, 2000.   
+Shai Ben-David, Reba Schuller, et al. Exploiting task relatedness for multiple task learning. Lecture notes in computer science, pp. 567–580, 2003.   
+Edwin V Bonilla, Kian M Chai, and Christopher Williams. Multi-task gaussian process prediction. In Advances in neural information processing systems, pp. 153–160, 2008.   
+Leo Breiman and Jerome H Friedman. Estimating optimal transformations for multiple regression and correlation. Journal of the American statistical Association, 80(391):580–598, 1985.   
+Alexis Conneau, Douwe Kiela, Holger Schwenk, Loic Barrault, and Antoine Bordes. Supervised learning of universal sentence representations from natural language inference data. arXiv preprint arXiv:1705.02364, 2017.   
+Thomas M. Cover and Joy A. Thomas. Elements of Information Theory. Wiley-Interscience, New York, NY, USA, 1991. ISBN 0-471-06259-6.   
+Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. Decaf: A deep convolutional activation feature for generic visual recognition. In International conference on machine learning, pp. 647–655, 2014.   
+Marylou Gabrie, Andre Manoel, Cl ´ ement Luneau, Jean Barbier, Nicolas Macris, Florent Krzakala, ´ and Lenka Zdeborova. Entropy and mutual information in models of deep neural networks. ´ CoRR, abs/1805.09785, 2018. URL http://arxiv.org/abs/1805.09785.
+
+Yuqing Gao and Khalid M Mosalam. Deep transfer learning for image-based structural damage recognition. Computer-Aided Civil and Infrastructure Engineering.
+
+Hans Gebelein. Das statistische problem der korrelation als variations-und eigenwertproblem und sein zusammenhang mit der ausgleichsrechnung. ZAMM-Journal of Applied Mathematics and Mechanics/Zeitschrift fur Angewandte Mathematik und Mechanik ¨ , 21(6):364–379, 1941.
+
+Mark Andrew Hall. Correlation-based feature selection for machine learning. 1999.
+
+Hermann O Hirschfeld. A connection between correlation and contingency. Mathematical Proceedings of the Cambridge Philosophical Society, 31(04):520–524, 1935.
+
+Shao-Lun Huang, Anuran Makur, Lizhong Zheng, and Gregory W Wornell. An information-theoretic approach to universal feature selection in high-dimensional inference. In Information Theory (ISIT), 2017 IEEE International Symposium on, pp. 1336–1340. IEEE, 2017.
+
+Laurent Jacob, Jean-philippe Vert, and Francis R Bach. Clustered multi-task learning: A convex formulation. In Advances in neural information processing systems, pp. 745–752, 2009.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Xuejun Liao and Lawrence Carin. Radial basis function network for multi-task learning. In Advances in Neural Information Processing Systems, pp. 792–802, 2006.
+
+Anuran Makur, Fabian Kozynski, Shao-Lun Huang, and Lizhong Zheng. An efficient algorithm for ´ information decomposition and extraction. In Communication, Control, and Computing (Allerton), 2015 53rd Annual Allerton Conference on, pp. 972–979. IEEE, 2015.
+
+Andreas Maurer. Transfer bounds for linear feature learning. Machine learning, 75(3):327–350, 2009.
+
+Hanchuan Peng, Fuhui Long, and Chris Ding. Feature selection based on mutual information criteria of max-dependency, max-relevance, and min-redundancy. IEEE Transactions on pattern analysis and machine intelligence, 27(8):1226–1238, 2005.
+
+Anastasia Pentina and Christoph H. Lampert. A pac-bayesian bound for lifelong learning. In International Conference on International Conference on Machine Learning, pp. II–991, 2014.
+
+Lorien Y Pratt. Discriminability-based transfer between neural networks. In Advances in neural information processing systems, pp. 204–211, 1993.
+
+Alfred R ´ enyi. On measures of dependence. ´ Acta mathematica hungarica, 10(3-4):441–451, 1959.
+
+C. K. Shie, C. H. Chuang, C. N. Chou, M. H. Wu, and E. Y. Chang. Transfer representation learning for medical image analysis. In 2015 37th Annual International Conference of the IEEE Engineering in Medicine and Biology Society (EMBC), pp. 711–714, Aug 2015. doi: 10.1109/EMBC.2015.7318461.
+
+Lisa Torrey and Jude Shavlik. Transfer learning. In Handbook of research on machine learning applications and trends: algorithms, methods, and techniques, pp. 242–264. IGI Global, 2010.
+
+Lichen Wang, Jiaxiang Wu, Shao-Lun Huang, Lizhong Zheng, Xiangxiang Xu, Lin Zhang, and Junzhou Huang. An efficient approach to informative feature extraction from multimodal data. AAAI, 2019. URL https://arxiv.org/abs/1811.08979.
+
+Mei Wang and Weihong Deng. Deep visual domain adaptation: A survey. Neurocomputing, 2018.
+
+Ya Xue, Xuejun Liao, Lawrence Carin, and Balaji Krishnapuram. Multi-task learning for classification with dirichlet process priors. Journal of Machine Learning Research, 8(Jan):35–63, 2007.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in neural information processing systems, pp. 3320–3328, 2014.
+
+Amir Zamir, Alexander Sax, William Shen, Leonidas Guibas, Jitendra Malik, and Silvio Savarese. Taskonomy: Disentangling task transfer learning. Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Yu Zhang. Heterogeneous-neighborhood-based multi-task local learning algorithms. In Advances in neural information processing systems, pp. 1896–1904, 2013.
+
+# APPENDIX A INFERENCE USING LOCAL INFORMATION GEOMETRY
+
+# A.1 A PRIMER ON ERROR EXPONENTS
+
+To begin with, consider the binary hypothesis testing problem over $m$ i.i.d. sampled observations $\{ x ^ { ( i ) } \} _ { i = 1 } ^ { m } \triangleq x ^ { m }$ with the following hypotheses: $H _ { 0 } : x ^ { m } \sim P _ { 1 }$ or $H _ { 1 } : x ^ { m } \sim P _ { 2 }$ . Let $P _ { x ^ { m } }$ be the empirical distribution of the samples. The optimal test, i.e., the log likelihood ratio test can be stated in terms of information-theoretic quantities as follows:
+
+$$
+\log { \frac { P _ { 1 } ( x ^ { m } ) } { P _ { 2 } ( x ^ { m } ) } } = m [ D ( P _ { x ^ { m } } | | P _ { 2 } ) - D ( P _ { x ^ { m } } | | P _ { 1 } ) ] \underset { H _ { 1 } } { \overset { H _ { 0 } } { \geq } } \log T
+$$
+
+![](images/bff89414773b021d18cfc47dceb1a8f755d50e43512f7d365655961e9fcbfea7.jpg)  
+Figure 10: The binary hypothesis testing problem. The blue curves shows the probility density functions for $P _ { 1 }$ and $P _ { 2 }$ . The rejection region and the acceptance region are highlighted in red and blue, respectively. The vertical line indicates the decision threshold.
+
+Further, using Sannov’s theorem, we have that asymptotically the probability of type I error
+
+$$
+\alpha = P _ { 1 } ( A ^ { c } ) \approx 2 ^ { - m D ( P _ { 1 } ^ { * } | | P _ { 1 } ) }
+$$
+
+where $\begin{array} { r } { P _ { 1 } ^ { * } = \operatorname * { a r g m i n } _ { P \in A ^ { c } } D ( P | | P _ { 1 } ) } \end{array}$ and $\begin{array} { r } { A ^ { c } ( T ) = \{ x ^ { m } : D ( P _ { x ^ { m } } | | P _ { 2 } ) - D ( P _ { x ^ { m } } | | P _ { 1 } ) < \frac { 1 } { m } \log T \} } \end{array}$ denotes the rejection region. Similarly, for type II error
+
+$$
+\beta = P _ { 2 } ( A ) \approx 2 ^ { - m D ( P _ { 2 } ^ { * } | | P _ { 2 } ) }
+$$
+
+where $\begin{array} { r } { P _ { 2 } ^ { * } = \operatorname * { a r g m i n } _ { P \in A } D ( P | | P _ { 2 } ) } \end{array}$ and $\begin{array} { r } { A \ = \ \{ x ^ { m } : \ D ( P _ { x ^ { m } } | | P _ { 2 } ) - D ( P _ { x ^ { m } } | | P _ { 1 } ) > \frac { 1 } { m } \log T \} } \end{array}$ represents the acceptance region. (See Figure 10) The overall probability of error is $P _ { e } ^ { ( m ) } =$ $\alpha \bar { P } r ( H _ { 0 } ) + \beta P r ( \bar { H } _ { 1 } )$ and the best achievable exponent in the Bayesian probability of error (a.k.a. Chernoff exponent) is defined as:
+
+$$
+E = \operatorname* { l i m } _ { m  \infty } \operatorname* { m i n } _ { A \subseteq \mathcal { X } ^ { m } } - \frac { 1 } { m } \log P _ { e } ^ { ( m ) }
+$$
+
+See Cover & Thomas (1991) for more background information on error exponents and its related theorems.
+
+Now consider the same binary hypothesis testing problem, but with the local constraint $P _ { 1 } , P _ { 2 } \in$ $\mathcal { N } _ { \epsilon } ( P _ { 0 } ^ { \mathcal { X } } )$ . Let Pi(x)−P X0 (x)√ X denote the information vectors corresponding to Pi for i = 1, 2.
+
+Makur et al. (2015) uses local information geometry to connect the error exponent in hypothesis testing to the length of certain information vectors, summarized in the following two lemmas.
+
+Lemma 1. Given zero-mean, unit variance feature function $f ( x ) : \mathcal { X }  \mathbb { R }$ , the optimal error exponent (a.k.a. Chernoff exponent) of this hypothesis testing problem is
+
+$$
+E = \frac { \epsilon ^ { 2 } } { 8 } \left\| \phi _ { 1 } - \phi _ { 2 } \right\| ^ { 2 } + o ( \epsilon ^ { 2 } )
+$$
+
+Lemma 2. Given zero-mean, unit variance feature function $f ( x ) : \mathcal { X }  \mathbb { R } ,$ , the error exponent of a mismatched decision function of the form $\begin{array} { r } { l = \frac { 1 } { m } \sum _ { i = 1 } ^ { m } ( f ( x ^ { ( i ) } ) ) } \end{array}$ is
+
+$$
+E _ { f } = \frac { \epsilon ^ { 2 } } { 8 } \langle \xi , \phi _ { 1 } - \phi _ { 2 } \rangle ^ { 2 } + o ( \epsilon ^ { 2 } )
+$$
+
+where $\xi ( x ) = \sqrt { P _ { 0 } ( x ) } f ( x )$ is the feature vector associated with $f ( x )$ .
+
+As our discussion of transferability mostly concerns with multi-dimensional features, we present the $k$ -dimensional generalization of Lemma 2 below: (Equation 1 in the main paper.)
+
+Lemma 3. Given $k$ normalized feature functions $f ( x ) = [ f _ { 1 } ( x ) , \ldots , f _ { k } ( x ) ]$ , such that $\mathbb { E } [ f _ { i } ( X ) ] = 0$ for all $i$ , and $\operatorname { c o v } ( f ( X ) ) ~ = ~ { \bar { I } }$ , we define a $k$ -d statistics of the form $l ^ { k } = ( l _ { 1 } , . . . , l _ { k } )$ where $\begin{array} { r } { l _ { i } = \frac { 1 } { m } \sum _ { l = 1 } ^ { m } f _ { i } ( x ^ { ( l ) } ) } \end{array}$ . Let $\Xi ( x ) = [ \xi _ { 1 } ( x ) , \ldots , \xi _ { k } ( x ) ]$ be the corresponding feature vectors with $\xi _ { i } ( x ) = \sqrt { P _ { X } ( x ) } f _ { i } ( x )$ .
+
+$$
+E _ { f } ^ { k } = \sum _ { i = 1 } ^ { k } E _ { f _ { i } } = \sum _ { i = l } ^ { k } \frac { \epsilon ^ { 2 } } { 8 } \left. \xi _ { i } , \phi _ { 1 } - \phi _ { 2 } \right. ^ { 2 } + o ( \epsilon ^ { 2 } )
+$$
+
+Proof. According to Cramer’s theorem, the error exponent under ´ $P _ { i }$ is
+
+$$
+E _ { i } ( \lambda ) = \operatorname* { m i n } _ { P \in \delta ( \lambda ) } D ( P | | P _ { i } )
+$$
+
+where $\delta \left( \lambda \right) \triangleq \left\{ P : \mathbb { E } _ { P } [ f ( X ) ^ { k } ] = \lambda \mathbb { E } _ { P _ { 1 } } [ f ( X ) ^ { k } ] + ( 1 - \lambda ) \mathbb { E } _ { P _ { 2 } } [ f ( X ) ^ { k } ] \right\}$ . With the techniques developed in local information geometry, the above above problem is equivalent to the following problem:
+
+$$
+E _ { i } ( \lambda ) = \operatorname* { m i n } _ { \tilde { \phi } _ { \theta ^ { k } } \in \sigma ( \lambda ) } \frac 1 2 \| \tilde { \phi } _ { \theta ^ { k } } - \phi _ { i } \| ^ { 2 }
+$$
+
+where $\sigma ( \lambda ) \triangleq \left\{ \tilde { \phi } _ { \theta ^ { k } } : \left. \tilde { \phi } _ { \theta ^ { k } } , \xi _ { l } \right. = \langle \lambda \phi _ { 1 } + ( 1 - \lambda ) \phi _ { 2 } , \xi _ { l } \rangle , l = 1 , . . . , k \right\}$ and $i = 1 , 2$ . Further, using the equation $\begin{array} { r } { \tilde { \phi } _ { \theta ^ { k } } ( x ) = \sum _ { l = 1 } ^ { k } \theta _ { l } \xi _ { l } ( x ) + \phi _ { i } ( x ) - \alpha ( \theta ^ { k } ) \sqrt { P _ { 0 } ( x ) } + o ( \epsilon ) } \end{array}$ and the equation $\alpha ( \theta ^ { k } ) = o ( \epsilon ^ { 2 } )$ , it is easy to show that $E _ { 1 } ( \lambda ) = E _ { 1 } ( \lambda )$ when $\begin{array} { r } { \lambda = \frac { 1 } { 2 } } \end{array}$ . Then the overall error probability has the exponent as shown in Equation (1). □
+
+# APPENDIX B HGR MAXIMAL CORRELATION AND THE ACE ALGORITHM
+
+Given random variables $X$ and $Y$ , the HGR maximal correlation $\rho ( X ; Y )$ defined in Equation 2 is a generalization of the Pearson’s correlation coefficient to capture non-linear dependence between random variables. According to Renyi (1959), it satisfies all seven natural postulates of a suitable ´ dependence measure. Some notable properties are listed below:
+
+1. $\rho ( X ; Y )$ is defined for any pair of random variables $X$ and $Y$   
+2. $0 \leq \rho ( X ; Y ) \leq 1$ ;   
+3. $\rho ( X ; Y ) = 0$ if and only if $X$ and $Y$ are independent   
+4. $\rho ( X ; Y ) = 1$ if and only if $X$ and $Y$ are strictly dependent.
+
+When the feature dimension is 1, the solution of the maximal HGR correlation is $\rho ( X ; Y ) = \sigma _ { 1 }$ , the largest singular value of the DTM matrix $\tilde { B }$ . For $k$ -dimensional features, $\textstyle \rho ( X ; Y ) = \sum _ { i } ^ { k } ( \sigma _ { i } )$ . However, computing $\tilde { B }$ requires estimating the joint probability $P _ { Y X }$ from data, which is inpractical in real applications. Breiman & Friedman (1985) proposed an efficient algorithm, alternating condition expectation (ACE), inspired by the power method for computing matrix singular values.
+
+# Algorithm 1 The ACE algorithm
+
+Require: training samples $\{ ( ( x ^ { ( i ) } , y ^ { ( i ) } ) : i = 1 , \ldots , m \}$
+
+1: Initialize $g ( y ) \in \mathbb { R } ^ { k } , \forall y \in \mathcal { V }$ randomly   
+2: Center $g ( y )  g ( y ) - \mathbb { E } [ g ( y ) ]$   
+3: repeat   
+4: $\bar { f } ( x )  \mathbb { E } [ g ( Y ) \mid X = x ] , \forall x \in \mathcal { X }$   
+5: $f ( x ) \gets f ( x ) \mathbb { E } [ f ( X ) f ( X ) ^ { T } ] ^ { - \frac { 1 } { 2 } } , \forall x \in \mathcal { X }$ {Normalize f(x)}   
+6: $g ( y )  \mathbb { E } [ f ( X ) \mid Y = y ] , \forall y \in y$   
+7: $g ( y )  g ( x ) \mathbb { E } [ g ( Y ) g ( Y ) ^ { T } ] ^ { - \frac { 1 } { 2 } } , \forall y \in \mathcal { Y }$ {Normalize g(y)}   
+8: until $\mathbb { E } [ f ( \dot { X } ) ^ { T } g \dot { ( Y ) } ]$ stops increasing
+
+In Algorithm 1, we first initialize $g$ as a random $k$ -dimensional zero-mean function. Then iteratively update $f ( x )$ and $g ( y )$ for all $x \in X$ and $y \in Y$ . The conditional distributions on Line 4 and 6 are computed as the empirical average over $m$ samples. The normalization steps on Lines 5 and 7 can also be implemented using the Gram-Schmidt process. Note that the ACE algorithm has several variations in previous works, including a kernel-smoothed version (Breiman & Friedman (1985)) and a parallel version with improved efficiency (Huang et al. (2017)). An alternative formulation that supports continuous $X$ and large feature dimension $k$ has also been proposed recently (Wang et al. (2019)).
+
+Next we look at the convergence property of the ACE algorithm. Let $f ( X ) , g ( Y )$ be the true maximal correlation functions, and let $\tilde { f } ( X ) , \tilde { g } ( Y )$ be estimations computed with Algorithm 1 from $m$ i.i.d. sampled training data. Similarly, denote by $\mathbb { E } [ f ( X ) g ( Y ) ]$ and $\hat { \mathbb { E } } _ { m } [ \tilde { f } ( X ) \tilde { g } ( Y ) ]$ the true and estimated maximal correlations, respectively. Using Sanov’s Theorem, we can show that for a small $\Delta > 0$ , the probability that the ratio between the true and estimated maximal correlation is within $1 \pm \Delta$ drops exponentially as the number of samples increases. Hence the ACE algorithm converges in exponential time. The following theorem gives the precise sampling complexity for $k = 1$ .
+
+Theorem 2. For any random variables $X$ and $Y$ with joint probability distribution $P _ { Y X }$ , if $X$ and $Y$ are not independent, then for any $f : \mathcal { X } \to \mathbb { R }$ and $g : \mathcal { V } \to \mathbb { R }$ such that $\mathbb { E } [ f ^ { 2 } ( X ) ] = \mathbb { E } [ g ^ { 2 } ( Y ) ] = 1$ , we have that
+
+$$
+- \operatorname* { l i m } _ { \Delta  0 ^ { + } } \frac { 1 } { \delta ^ { 2 } } \operatorname* { l i m } _ { m  \infty } \frac { 1 } { m } \log [ P \{ | \frac { \hat { \mathbb { E } } _ { m } [ \tilde { f } ( X ) \tilde { g } ( Y ) ] } { \mathbb { E } [ f ( X ) g ( Y ) ] } - 1 | \geq \Delta \} ] = \frac { 1 } { 2 } \frac { \mathbb { E } [ f ( X ) g ( Y ) ] ^ { 2 } } { v a r [ f ( X ) g ( Y ) ] }
+$$
+
+for any given $\Delta > 0$
+
+# APPENDIX C PROOF OF THEOREM 1
+
+To simplify the proof, we first consider the case when the feature function is 1-dimensional.i.e. $f : \mathcal { X } \to \mathbb { R }$ . We have the following lemma:
+
+Lemma 4. Let $f : X \to \mathbb { R }$ be an arbitrary feature function of $X$ such that $\mathbb { E } [ f ( X ) ] = 0$ and $\mathbb { E } [ f ( X ) ^ { 2 } ] = 1$ , then $| | \tilde { B } \xi | | _ { F } ^ { 2 } = \mathbb { E } _ { P _ { Y } } [ ( \mathbb { E } [ f ( X ) | Y ] ) ^ { 2 } ]$ where $\xi$ is the feature vector corresponding to $f$ .
+
+Proof. Since $\xi ( x ) = \sqrt { P _ { X } ( x ) } f ( x )$ , we have
+
+$$
+\begin{array} { r l } & { \| \hat { B } \xi \| _ { F } ^ { 2 } = \xi ^ { \mathsf { T } } \hat { B } ^ { \mathsf { T } } \hat { B } \xi } \\ & { \qquad = \displaystyle \sum _ { y \in \mathcal { V } } \left( \displaystyle \sum _ { x \in \mathcal { X } } \left( \frac { P _ { Y X } ( y , x ) } { \sqrt { P _ { X } ( x ) } \sqrt { P _ { Y } ( y ) } } - \sqrt { P _ { X } ( x ) } \sqrt { P _ { Y } ( y ) } \right) \cdot \sqrt { P _ { X } ( x ) } f ( x ) \right) ^ { 2 } } \\ & { \qquad = \displaystyle \sum _ { y \in \mathcal { Y } } \left( \displaystyle \sum _ { x \in \mathcal { X } } \frac { P _ { Y X } ( y , x ) } { P _ { Y } ( y ) } \cdot f ( x ) - \displaystyle \sum _ { x \in \mathcal { X } } f ( x ) P _ { X } ( x ) \right) ^ { 2 } \cdot P _ { Y } ( y ) } \\ & { \qquad = \displaystyle \sum _ { y \in \mathcal { Y } } ( \mathbb { E } [ f ( X ) | Y = y ] - \mathbb { E } [ f ( x ) ] ) ^ { 2 } \cdot P _ { Y } ( y ) } \\ & { \qquad = \mathbb { E } _ { P _ { X } } [ ( \mathbb { E } [ f ( X ) | Y ] ) ^ { 2 } ] } \end{array}
+$$
+
+The last equality uses the assumption that $\mathbb { E } [ f ( x ) ] = 0$ .
+
+Theorem 3 (1D version of Theorem 1). Given $P _ { X | Y = 0 } , P _ { X | Y = 1 } \in \mathcal { N } _ { \epsilon } ^ { \mathcal { X } } ( P _ { 0 , X } )$ and features $f :$ $X \to \mathbb { R }$ such that $\mathbb { E } \left[ f ( X ) \right] = 0$ and $\mathbb { E } [ f ( X ) ^ { 2 } ] = 1$ , then there exists some constant $c$ independent of $f$ such that
+
+$$
+\begin{array} { r } { E _ { f } = c \| \tilde { B } \xi \| _ { F } ^ { 2 } } \end{array}
+$$
+
+Proof. From $\begin{array} { r } { \mathbb { E } [ f ( X ) ] = P _ { Y } ( 0 ) \mathbb { E } [ f ( X ) | Y = 0 ] + P _ { Y } ( 1 ) \mathbb { E } [ f ( X ) | Y = 1 ] = 0 } \end{array}$ , we first derive the following properties of the conditional expectations of $f ( x )$ :
+
+$$
+\begin{array} { r l } & { \mathbb { E } [ f ( X ) | Y = 1 ] = - \left( \frac { P _ { Y } ( 0 ) } { P _ { Y } ( 1 ) } \right) \mathbb { E } [ f ( X ) | Y = 0 ] } \\ & { \mathbb { E } [ f ( X ) | Y = 0 ] = - \left( \frac { P _ { Y } ( 1 ) } { P _ { Y } ( 0 ) } \right) \mathbb { E } [ f ( X ) | Y = 1 ] } \end{array}
+$$
+
+On the R.H.S. of Equation 5, we apply Lemma 4 to write
+
+$$
+\begin{array} { r l } & { \| \tilde { B } \xi \| _ { F } ^ { 2 } = \mathbb { E } _ { P _ { Y } } \left[ ( \mathbb { E } \left[ f ( X ) | Y \right] ) ^ { 2 } \right] } \\ & { \qquad = \frac { P _ { Y } ( 0 ) P _ { Y } ( 1 ) + P _ { Y } ( 1 ) ^ { 2 } } { P _ { Y } ( 0 ) } ( \mathbb { E } \left[ f ( X ) | Y = 1 \right] ) ^ { 2 } } \end{array}
+$$
+
+Next consider the L.H.S. of the equation, by Lemma 2, we have $\begin{array} { r } { E ( h ) = \frac { \epsilon ^ { 2 } } { 8 } \langle \xi , \phi _ { 1 } - \phi _ { 2 } \rangle ^ { 2 } + o ( \epsilon ^ { 2 } ) = } \end{array}$ $c _ { 0 } \langle \xi , \phi _ { 1 } - \phi _ { 2 } \rangle ^ { 2 }$ for some constant $c _ { 0 }$ .
+
+$$
+\begin{array} { r l } & { \quad c _ { 0 } ( \xi , \dot { \phi } T _ { 1 } - \phi _ { T _ { 2 } } ) ^ { 2 } } \\ & { = - c _ { 0 } ( \displaystyle \sum _ { \ell \in \mathcal { X } } \frac { P _ { X } [ Y - ( X ) - ( P _ { X } ) ] ( Y - 1 ) } { \sqrt { P _ { X } ( X ) } } \cdot \sqrt { P _ { X } ( x ) } f ( x ) ) ^ { 2 } } \\ & { = c _ { 0 } ( | \mathbb { S } [ f ( X ) | Y = 0 ] - \mathbb { E } [ f ( X ) | Y = 1 ] ) ^ { 2 } } \\ & { = c _ { 0 } - \frac { ( P _ { Y } ( 0 ) + P _ { Y } ( 1 ) ) ^ { 2 } } { P _ { Y } ( 0 ) P _ { Y } ( 1 ) } \cdot ( \mathbb { E } [ f ( X ) | Y - 1 ] ) ( \mathbb { E } [ f ( X ) | Y = 0 ] ) } \\ & { = c _ { 0 } ( \frac { P _ { Y } ( 0 ) + P _ { Y } ( 1 ) } { P _ { Y } ( 0 ) } ) ^ { 2 } \cdot ( \mathbb { E } [ f ( X ) | Y - 1 ] ) ^ { 2 } } \\ & { = c _ { 0 } \frac { P _ { Y } ( 0 ) + P _ { Y } ( 1 ) } { P _ { Y } ( 0 ) P _ { Y } ( 1 ) } ( \frac { P _ { Y } ( 0 ) P _ { Y } ( 1 ) + P _ { Y } ( 1 ) ^ { 2 } } { P _ { Y } ( 0 ) } ) \cdot ( \mathbb { E } [ f ( X ) | Y - 1 ] ) ^ { 2 } } \\ & { = c _ { 0 } \frac { P _ { Y } ( 0 ) + P _ { Y } ( 1 ) } { P _ { Y } ( 0 ) P _ { Y } ( 1 ) } ( \frac { P _ { Y } ( 0 ) P _ { Y } ( 1 ) + P _ { Y } ( 1 ) ^ { 2 } } { P _ { Y } ( 0 ) } ) \cdot ( \mathbb { E } [ f ( X ) | Y - 1 ] ) ^ { 2 } } \\ & { = c _ { 1 } \| \mathbb { S } \xi | ^ { 2 } } \end{array}
+$$
+
+For $k \geq 2$ , Lemma 4 can be restated as follows:
+
+Lemma 5. Let $f ~ : ~ {  { \cal { X } } } ~ \to ~ \mathbb { R } ^ { k }$ be a $k$ -dimensional feature function of $X$ , where $f ( x ) \ =$ $[ f _ { 1 } ( x ) , \ldots , f _ { k } ( x ) ]$ . Further we assume that $\mathbb { E } [ f ( X ) ] = { \dot { 0 } }$ and $\operatorname { c o v } ( f ( X ) ) = \mathbb { E } [ f ( X ) ^ { \mathrm { T } } f ( X ) ] = I$ . Then $| | \hat { B } \Xi | | _ { F } ^ { 2 } = \operatorname { t r } ( \operatorname { c o v } ( \mathbb { E } [ f ( X ) | Y ] ) )$ where columns of $\Xi$ are the information vectors corresponding to $f _ { 1 } ( x ) , \dots , f _ { k } ( x )$ .
+
+Proof. First, note that
+
+$$
+\begin{array} { r l } & { \tilde { B } \Xi = \left( \left[ \sqrt { \mathrm { P } _ { Y } } \right] ^ { - 1 } \mathrm { P } _ { Y X } \left[ \sqrt { \mathrm { P } _ { X } } \right] ^ { - 1 } - \sqrt { \mathrm { P } _ { Y } } \sqrt { \mathrm { P } _ { X } } ^ { \mathrm { T } } \right) \left[ \sqrt { \mathrm { P } _ { X } } \right] \mathrm { f } ( X ) } \\ & { \qquad = \left[ \sqrt { \mathrm { P } _ { Y } } \right] \left( \left[ \mathrm { P } _ { Y } \right] ^ { - 1 } \mathrm { P } _ { Y X } \mathrm { f } ( X ) - \mathbf { 1 } \cdot \mathbb { E } [ f ( X ) ] ^ { \mathrm { T } } \right) } \end{array}
+$$
+
+where $\mathbf { 1 }$ is a column vector with all entries 1 and length $| \mathcal { D } |$ . Since $\mathbb { E } [ f ( X ) ] = 0$ , we have
+
+$$
+\tilde { B } \Xi = \left[ \sqrt { \mathrm { P } _ { Y } } \right] \left( \left[ \mathrm { P } _ { Y } \right] ^ { - 1 } \mathrm { P } _ { Y X } \mathrm { f } ( X ) \right)
+$$
+
+It follows that
+
+$$
+\begin{array} { r l } & { | | \tilde { B } \Xi | | _ { F } ^ { 2 } = \mathrm { t r } ( \Xi ^ { \mathrm { T } } \tilde { B } ^ { \mathrm { T } } \tilde { B } \Xi ) } \\ & { \qquad = \mathrm { t r } ( ( [ \operatorname { P } _ { Y } ] ^ { - 1 } \operatorname { P } _ { Y X } \mathrm { f } ( X ) ) ^ { \mathrm { T } } [ \operatorname { P } _ { Y } ] ( [ \operatorname { P } _ { Y } ] ^ { - 1 } \operatorname { P } _ { Y X } \mathrm { f } ( X ) ) ) } \\ & { \qquad = \mathrm { t r } ( \mathbb { E } _ { P _ { Y } } [ ( \mathbb { E } [ f ( X ) | Y ] ] ^ { \mathrm { T } } ) ^ { \mathrm { T } } ( \mathbb { E } [ f ( X ) | Y ] ] ^ { \mathrm { T } } ) ] ) } \\ & { \qquad = \mathrm { t r } ( \mathrm { c o v } ( \mathbb { E } [ f ( X ) | Y ] ) ) } \end{array}
+$$
+
+Finally, we derive the multi-dimensional case for Theorem 1.
+
+Proof of Theorem 1. Using Lemma 5 and a similar argument as in the simplified proof, the R.H.S of the equation becomes
+
+$$
+\begin{array} { r l } & { | | \tilde { B } \Xi | | _ { F } ^ { 2 } = \operatorname { t r } ( \operatorname { c o v } ( \mathbb { E } [ f ( X ) | Y ] ) ) } \\ & { \qquad = \operatorname { t r } ( \mathbb { E } _ { P _ { Y } } [ ( \mathbb { E } [ f ( X ) | Y ] ) ^ { \mathrm { T } } ) ^ { \mathrm { T } } ( \mathbb { E } [ f ( X ) | Y ] ^ { \mathrm { T } } ) ] ) } \\ & { \qquad = P _ { Y } ( 0 ) \mathbb { E } [ f ( X ) | Y = 0 ] ] ^ { \mathrm { T } } \mathbb { E } [ f ( X ) | Y = 0 ] ] + P _ { Y } ( 1 ) \mathbb { E } [ f ( X ) | Y = 1 ] ^ { \mathrm { T } } \mathbb { E } [ f ( X ) | Y = 1 ] } \\ & { \qquad = \frac { P _ { Y } ( 0 ) P _ { Y } ( 1 ) + P _ { Y } ( 1 ) ^ { 2 } } { P _ { Y } ( 0 ) } ( \mathbb { E } [ f ( X ) | Y = 1 ] ) ^ { \mathrm { T } } ( \mathbb { E } [ f ( X ) | Y = 1 ] ) } \end{array}
+$$
+
+By Lemma 3, the L.H.S. of the equation can be written as $\begin{array} { r } { E _ { f } ^ { k } = c _ { 0 } \sum _ { i = l } ^ { k } \left. \xi _ { i } , \phi _ { 1 } - \phi _ { 2 } \right. ^ { 2 } } \end{array}$ for some constant $c _ { 0 }$ . It follows that
+
+$$
+\begin{array} { r l } & { c _ { 0 } \displaystyle \sum _ { i = l } ^ { k } \left. \xi _ { i } , \phi _ { 1 } - \phi _ { 2 } \right. ^ { 2 } } \\ & { = c _ { 0 } \left( \left( \left( \mathbf { P } _ { X | Y = 0 } - \mathbf { P } _ { X | Y = 1 } \right) \right) ^ { \mathrm { { T } } } \mathbf { f } ( X ) \right) \left( \left( \left( \mathbf { P } _ { X | Y = 0 } - \mathbf { P } _ { X | Y = 1 } \right) \right) ^ { \mathrm { { T } } } \mathbf { f } ( X ) \right) ^ { \mathrm { { T } } } } \\ & { = c _ { 0 } \left( \mathbb { E } [ f ( X ) | Y = 0 ] - \mathbb { E } [ f ( X ) | Y = 1 ] \right) ^ { \mathrm { { T } } } \left( \mathbb { E } [ f ( X ) | Y = 0 ] - \mathbb { E } [ f ( X ) | Y = 1 ] \right) } \\ & { = c _ { 0 } \frac { P _ { Y } \left( 0 \right) + P _ { Y } \left( 1 \right) } { P _ { Y } \left( 0 \right) P _ { Y } \left( 1 \right) } \left( \frac { P _ { Y } \left( 0 \right) P _ { Y } \left( 1 \right) + P _ { Y } \left( 1 \right) ^ { 2 } } { P _ { Y } \left( 0 \right) } \right) \cdot \mathbb { E } \left[ f ( X ) | Y = 1 \right] ^ { \mathrm { { T } } } \mathbb { E } \left[ f ( X ) | Y = 1 \right] } \\ & { = c _ { 1 } \left. \tilde { B } \equiv \right. _ { L } ^ { 2 } } \end{array}
+$$
+
+# APPENDIX D GENERALIZATION OF H-SCORE FOR ARBITRARY FEATURE SET
+
+Since $\Xi = \left[ \sqrt { \mathrm { P } _ { X } } \right] \mathrm { f } ( X )$ and $\mathbb { E } [ f ( X ) ] = 0$ , we have
+
+$$
+\Xi ^ { \mathrm { T } } \Xi = \left( \left[ { \sqrt { \operatorname { P } _ { X } } } \right] \operatorname { f } ( X ) \right) ^ { \mathrm { T } } \left( \left[ { \sqrt { \operatorname { P } _ { X } } } \right] \operatorname { f } ( X ) \right) = \mathbb { E } [ f ( X ) ^ { \mathrm { T } } f ( X ) ] = \operatorname { c o v } ( f ( X ) )
+$$
+
+Equation (6) gives a more understandable expression of the normalization term. We can also write $\tilde { B } \Xi$ as follows:
+
+$$
+\begin{array} { r l } & { \tilde { B } \Xi = \left( \left[ \sqrt { \mathrm { P } _ { Y } } \right] ^ { - 1 } \mathrm { P } _ { Y X } \left[ \sqrt { \mathrm { P } _ { X } } \right] ^ { - 1 } - \sqrt { \mathrm { P } _ { Y } } \sqrt { \mathrm { P } _ { X } } ^ { \mathrm { T } } \right) \left[ \sqrt { \mathrm { P } _ { X } } \right] \mathrm { f } ( X ) } \\ & { \qquad = \left[ \sqrt { \mathrm { P } _ { Y } } \right] \left( \left[ \mathrm { P } _ { Y } \right] ^ { - 1 } \mathrm { P } _ { Y X } \mathrm { f } ( X ) - \mathbf { 1 } \cdot \mathbb { E } [ f ( X ) ] ^ { \mathrm { T } } \right) } \end{array}
+$$
+
+where 1 is a column vector with all entries 1 and length $| \mathcal { D } |$ , we have
+
+$$
+\begin{array} { r l } & { \Xi ^ { \mathrm { T } } \tilde { B } ^ { \mathrm { T } } \tilde { B } \Xi = \left( [ \mathrm { P } _ { Y } ] ^ { - 1 } \operatorname* { P } _ { Y X } \mathrm { f } ( X ) - \mathbf { 1 } \cdot \mathbb { E } [ f ( X ) ] ^ { \mathrm { T } } \right) ^ { \mathrm { T } } [ \operatorname* { P } _ { Y } ] \left( [ \operatorname* { P } _ { Y } ] ^ { - 1 } \operatorname* { P } _ { Y X } \mathrm { f } ( X ) - \mathbf { 1 } \cdot \mathbb { E } [ f ( X ) ] ^ { \mathrm { T } } \right) } \\ & { \qquad = \mathbb { E } _ { P _ { Y } } \left[ ( \mathbb { E } [ f ( X ) | Y ] - \mathbf { 1 } \cdot \mathbb { E } [ f ( X ) ] ^ { \mathrm { T } } ) ^ { \mathrm { T } } ( \mathbb { E } [ f ( X ) | Y ] - \mathbf { 1 } \cdot \mathbb { E } [ f ( X ) ] ^ { \mathrm { T } } ) \right] } \\ & { \qquad = \mathrm { c o v } \left( \mathbb { E } [ f ( X ) | Y ] \right) \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \end{array}
+$$
+
+On the other hand,
+
+$$
+\begin{array} { r l } & { \lvert | \tilde { B } \Xi ( \Xi ^ { \mathrm { T } } \Xi ) ^ { - \frac { 1 } { 2 } } | | _ { F } ^ { 2 } = \mathrm { t r } \left( ( \Xi ^ { \mathrm { T } } \Xi ) ^ { - \frac { 1 } { 2 } } \Xi ^ { \mathrm { T } } \tilde { B } ^ { \mathrm { T } } \tilde { B } \Xi ( \Xi ^ { \mathrm { T } } \Xi ) ^ { - \frac { 1 } { 2 } } \right) } \\ & { \qquad = \mathrm { t r } \left( ( \Xi ^ { \mathrm { T } } \Xi ) ^ { - 1 } \Xi ^ { \mathrm { T } } \tilde { B } ^ { \mathrm { T } } \tilde { B } \Xi \right) } \\ & { \qquad = \mathrm { t r } \left( \mathrm { c o v } ( f ( X ) ) ^ { - 1 } \mathrm { c o v } ( \mathbb { E } [ f ( X ) | Y ] ) \right) } \end{array}
+$$
+
+The last equality is derived by substituting (6) and (7) into (8).
+
+# APPENDIX E H-SCORE AND SOFTMAX REGRESSION
+
+In softmax regression, given $m$ training examples $\{ ( \boldsymbol { x } ^ { ( i ) } , \boldsymbol { y } ^ { ( i ) } ) \} _ { i = 1 } ^ { m }$ , the cross-entropy loss of the model is
+
+$$
+\begin{array} { r l } & { \ell ( \boldsymbol { f } , \boldsymbol { \theta } ) = - \displaystyle \sum _ { i = 1 } ^ { m } \sum _ { k = 1 } ^ { | \mathcal { Y } | } \boldsymbol { 1 } \{ \boldsymbol { y } ^ { ( i ) } = k \} \log \frac { e ^ { - \theta _ { k } ^ { T } f ( \boldsymbol { x } ^ { ( i ) } ) } } { \sum _ { j = 1 } ^ { C } e ^ { - \theta _ { j } ^ { T } f ( \boldsymbol { x } ^ { ( i ) } ) } } } \\ & { \triangleq - \displaystyle \sum _ { i = 1 } ^ { m } \log Q _ { Y | \boldsymbol { X } } ( \boldsymbol { y } ^ { ( i ) } | \boldsymbol { x } ^ { ( i ) } ) } \\ & { = - \mathbb { E } _ { P _ { Y } } [ \log Q _ { Y | \boldsymbol { X } } ( Y | \boldsymbol { X } ) ] } \end{array}
+$$
+
+Minimizing $\ell$ is equivalent to minimizing $D \left( P _ { Y X } | | P _ { X } Q _ { Y | X } \right)$ where $P _ { Y X }$ is the joint empirical distribution of $( X , Y )$ .
+
+Using information geometry, it can be shown that under a local assumption
+
+$$
+\underset { f , \theta } { \arg \operatorname* { m i n } } D \left( P _ { Y X } | | P _ { X } Q _ { Y | X } \right) = \underset { \Psi , \Phi } { \arg \operatorname* { m i n } } \frac { 1 } { 2 } | | \tilde { B } - \Psi \Phi ^ { \mathrm { T } } | | _ { F } ^ { 2 } + o ( \epsilon ^ { 2 } )
+$$
+
+which reveals a close connection between log loss and the modal decomposition of $\tilde { B }$ . In consequence, it is reasonable to measure the classification performance with $\lVert \tilde { B } - \Psi \Phi ^ { \mathrm { T } } \rVert _ { F } ^ { 2 }$ given a pair of $( f , \theta )$ associated with $( \Psi , \Phi )$ .
+
+In the context of estimating transferability, we are interested in a one-sided problem, where $\Phi _ { S }$ is given by the source feature and $\Psi$ becomes the only variable.
+
+$$
+\operatorname* { m i n } _ { \Psi } \| \tilde { B } _ { T } - \Psi \Phi _ { S } ^ { \mathrm { T } } \|
+$$
+
+![](images/0e4b7276795528c21e55cbe5e9d0a6b5680711960dcfcb4e18b0162807f06214.jpg)  
+Figure 11: Comparing task transferability (H-score) and transfer log-loss on synthesized tasks.
+
+Training the network is equivalent to finding the optimal weight $\Psi ^ { * }$ that minimizes the log-loss. By taking the derivative of the Objective function with respect to $\Psi$ , we get
+
+$$
+\Psi ^ { * } = \tilde { B } _ { T } \Phi _ { S } ( \Phi _ { S } ^ { \mathrm { T } } \Phi _ { S } ) ^ { - 1 }
+$$
+
+Substituting (14) in the Objective of (13), we can derive the following close-form solution for the log loss.
+
+$$
+\| \tilde { B } _ { T } ^ { \mathrm { T } } \tilde { B } _ { T } \| _ { F } ^ { 2 } - \| \tilde { B } _ { T } \Phi _ { S } ( \Phi _ { S } ^ { \mathrm { T } } \Phi _ { S } ) ^ { - \frac { 1 } { 2 } } \| _ { F } ^ { 2 }
+$$
+
+The first term in (15) is fixed given $\mathcal { T } _ { T }$ while the second term has exactly the form of $_ \mathrm { H }$ -score. This implies that log loss is negatively linearly related to $_ \mathrm { H }$ -score.
+
+We demonstrates this relationship experimentally, using a collection of synthesized tasks (Figure 11). In particular, the target task is generated based on a random stochastic matrix $\mathrm { P } _ { Y _ { 0 } | X }$ , and 20 source tasks are generated with the conditional probability matrix $\mathrm { P } _ { Y _ { i } | X } = \mathrm { P } _ { Y _ { 0 } | X } + i \lambda \bar { I }$ for some positive constant $\lambda$ .
+
+The universal minimum error probability features for each source task are used as the source features $f _ { S _ { i } } ( x )$ , while the respective log-loss are obtained through training a simple neural network in Figure 2 with cross-entropy loss. The relationship is clearly linear with a constant offset.
+
+# APPENDIX F DTM AND MUTUAL INFORMATION
+
+Proposition 1. Under the local assumption that $P _ { X | Y } \in N _ { \epsilon } ( P _ { X } )$ , mutual information $I ( X ; Y ) =$ $\frac { 1 } { 2 } | | \tilde { B } | | _ { F } ^ { 2 } + o ( \epsilon ^ { 2 } )$ , where $\tilde { B }$ of the DTM matrix of $X$ and $Y$ .
+
+Proof. First, we define φX|Yy (x) = PX|Y (x|y)−PX(x)√ and let $\Phi ^ { X | Y } \in \mathbb { R } ^ { | \mathcal { X } | \times | y | }$ denote its matrix version. Then we have
+
+$$
+\epsilon \Phi ^ { X | Y } [ \sqrt { P _ { Y } } ] = [ \sqrt { P _ { X } } ] ^ { - 1 } ( P _ { X Y } - P _ { X } ) [ \sqrt { P _ { Y } } ] = \tilde { B } ^ { T }
+$$
+
+Next, we express the mutual information in terms of information vector $\phi ^ { X | Y }$ ,
+
+$$
+\begin{array} { l } { { I ( X ; Y ) = I ( Y ; X ) = \displaystyle \sum _ { y \in \mathcal { Y } } P _ { Y } ( y ) D _ { K L } ( P _ { X | Y } | | P _ { X } ) } } \\ { { \displaystyle ~ = \frac { \epsilon ^ { 2 } } { 2 } \sum _ { y \in \mathcal { Y } } P _ { Y } ( y ) \| \phi _ { y } ^ { X | Y } | ^ { 2 } + o ( \epsilon ^ { 2 } ) } } \\ { { \displaystyle ~ = \frac { 1 } { 2 } | | \epsilon \Phi ^ { X | Y } [ \sqrt { P _ { Y } } ] | _ { F } ^ { 2 } + o ( \epsilon ^ { 2 } ) } } \\ { { \displaystyle ~ = \frac { 1 } { 2 } | | \tilde { B } | | _ { F } ^ { 2 } + o ( \epsilon ^ { 2 } ) } } \end{array}
+$$
+
+# APPENDIX G SUPPLEMENTARY RESULTS ON EXPERIMENT 5.2
+
+# G.1 COMPARISON OF H-SCORES AND AFFINITIES
+
+Table 1, with columns representing source tasks and rows representing target tasks. For each target task, the upper row shows our results while the lower one shows the results in Zamir et al. (2018). Score values are included in parenteses.
+
+Table 1: Transferability ranking comparison, between H-score’s estimation and task affinity   
+
+<table><tr><td>Tasks</td><td>2D Edges</td><td>2D Keypoints</td><td>3D Edges</td><td>3D Keypoints</td><td>Reshading</td><td>Depth</td><td>Object Class.</td><td>Scene Class.</td></tr><tr><td rowspan="2">2D Edges</td><td>1 (1.8216)</td><td>2(1.7334)</td><td>5 (1.5704)</td><td>6(1.5696)</td><td>4 (1.6146)</td><td>3 (1.6201)</td><td>7(1.5097)</td><td>8(1.4402)</td></tr><tr><td>1 (0.0389)</td><td>2 (0.0117)</td><td>4 (5.8920e-5)</td><td>3 (8.8011e-5)</td><td>7(2.9001e-5)</td><td>8 (2.2110e-5)</td><td>5 (4.9141e-5)</td><td>6(4.8720e-5)</td></tr><tr><td rowspan="2">2D Keypoints</td><td>2 (1.6698)</td><td>1 (1.7859)</td><td>7 (1.5248)</td><td>5 (1.5287)</td><td>4 (1.5481)</td><td>3 (1.5632)</td><td>6(1.5253)</td><td>8 (1.4725)</td></tr><tr><td>2 (0.0002)</td><td>1 (0.0542)</td><td>7 (7.7797e-5)</td><td>5 (8.1029e-5)</td><td>6 (7.8464e-5)</td><td>8 (7.2724e-5)</td><td>3 (0.0002)</td><td>4(0.0001)</td></tr><tr><td rowspan="2"> 3D Edges</td><td>5(1.4828)</td><td>4(1.4910)</td><td>3 (1.5167)</td><td>7 (1.4701)</td><td>2 (1.5405)</td><td>1 (1.6739)</td><td>8 (1.4644)</td><td>6 (1.4730)</td></tr><tr><td>6(0.0117)</td><td>7(0.0108)</td><td>1 (0.1179)</td><td>2 (0.0734)</td><td>4 (0.0622)</td><td>3(0.0636)</td><td>8(0.0094)</td><td>5(0.0151)</td></tr><tr><td rowspan="2">3DKeypoints</td><td>6(1.5375)</td><td>5 (1.5466)</td><td>4 (1.5910)</td><td>3 (1.6456)</td><td>1 (1.7198)</td><td>2 (1.7122)</td><td>7(1.4709)</td><td>8 (1.4121)</td></tr><tr><td>5(0.0141)</td><td>6(0.0136)</td><td>2 (0.0531)</td><td>1(0.1275)</td><td>3 (0.0400)</td><td>4 (0.0247)</td><td>7(0.0132)</td><td>8(0.0121)</td></tr><tr><td rowspan="2">Reshading</td><td>5 (1.5504)</td><td>6 (1.5426)</td><td>3 (1.8174)</td><td>4 (1.7990)</td><td>1 (2.2339)</td><td>2 (2.1200)</td><td>7 (1.4774)</td><td>8 (1.3804)</td></tr><tr><td>6(0.0147)</td><td>8 (0.0143)</td><td>2 (0.0781)</td><td>4(0.0545)</td><td>1(0.1121)</td><td>3(0.0765)</td><td>7(0.0144)</td><td>5(0.0174)</td></tr><tr><td rowspan="2">Depth</td><td>6(1.6542)</td><td>5(1.6870)</td><td>3 (1.8504)</td><td>4 (1.8176)</td><td>2 (2.1700)</td><td>1 (2.2441)</td><td>7(1.6008)</td><td>8 (1.5099)</td></tr><tr><td>7(0.0175)</td><td>8 (0.0154)</td><td>3(0.0595)</td><td>4(0.0617)</td><td>2 (0.0867)</td><td>1 (0.0989)</td><td>6(0.0217)</td><td>5 (0.0237)</td></tr><tr><td rowspan="2">Object Class.</td><td>5 (22.866)</td><td>4 (23.627)</td><td>7 (22.371)</td><td>8 (21.950)</td><td>6 (22.452)</td><td>3(23.697)</td><td>1 (33.468)</td><td>2 (28.013)</td></tr><tr><td>7(0.0205)</td><td>6(0.0217)</td><td>3 (0.0350)</td><td>4(0.0318)</td><td>5 (0.0286)</td><td>8(0.0147)</td><td>1 (0.0959)</td><td>2 (0.0774)</td></tr><tr><td rowspan="2">Scene Class.</td><td>5 (14.575)</td><td>4 (15.074)</td><td>7 (14.206)</td><td>8 (13.801)</td><td>6(14.332)</td><td>3 (15.474)</td><td>2 (25.750)</td><td>1 (25.962)</td></tr><tr><td>8(0.0149)</td><td>7(0.0165)</td><td>3(0.0335)</td><td>4(0.0305)</td><td>5(0.0263)</td><td>6(0.0198)</td><td>2 (0.0504)</td><td>1 (0.1474)</td></tr></table>
+
+Here we present some detailed results on the comparison between H-score and the affinity score in Zamir et al. (2018) for pairwise transfer.
+
+The results of the classification tasks are shown in Figure 12 and the results of Depth is shown in 13. We can see in general, although affinity and transferability have totally different value ranges, they tend to agree on the top few ranked tasks.
+
+![](images/0a480e5ce016598e3ccffc9e00807952d9a7b6d31f769187d9e26b4092eaed62.jpg)  
+Figure 12: Source task transferability ranking for classification tasks. For each target task, the left figure shows H-score results, and the right figure shows task affinity results.
+
+# G.2 LABEL QUANTIZATION
+
+During the quantization process of the pixel-to-pixel task labels (ground truth images), we are primarily concerned with two factors: computational complexity and information loss. Too much information loss will lead to bad approximation of the original problems. On the other hand, having little information loss requires larger cluster size and computation cost.
+
+Figure (14) shows that even after quantization, much of the information in the images are retained.
+
+To test the sensitivity of the cluster size, we used cluster centroids to recover the ground truth image pixel-by-pixel. The 3D occlusion Edge detection results on a sample image is shown in Figure 15. When the cluster number is set to $N = 5$ (right), most detected Edges in the ground truth image (left) are lost. We found that $N = 1 6$ strikes a good balance between recoverability and computation cost.
+
+![](images/1b9986a759c3c685656ed26b91db1869901d67b0ca18645f7abcf60442270076.jpg)  
+transfer to Depth from the other tasks   
+Figure 13: Comparison between source task rankings for Depth. with H-score results on the left and affinity scores Zamir et al. (2018) on the right. The Top 3 transferable source tasks in both methods are the same: Depth, Image Reshading and 3D Occlusion Edges.
+
+![](images/3d40d4047c298336c267d6b3e4b68148efe543b4507868235f22daced2d5ac52.jpg)  
+Figure 14: Quantization. Recover is done with the centroid of corresponding cluster of each pixel.
+
+![](images/9e2f4c8681307086a7193863887037ad45290f19afa980ca505ae5e8bf252359.jpg)  
+Figure 15: Effect of quantization cluster size for 3D occlusion Edge detection.

parse/train/S1gfu3EtDr/S1gfu3EtDr.md

@@ -0,0 +1,315 @@
+# EGOMAP: PROJECTIVE MAPPING AND STRUCTURED EGOCENTRIC MEMORY FOR DEEP RL
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Tasks involving localization, memorization and planning in partially observable 3D environments are an ongoing challenge in Deep Reinforcement Learning. We present EgoMap, a spatially structured neural memory architecture. EgoMap augments a deep reinforcement learning agent’s performance in 3D environments on challenging tasks with multi-step objectives. The EgoMap architecture incorporates several inductive biases including a differentiable inverse projection of CNN feature vectors onto a top-down spatially structured map. The map is updated with ego-motion measurements through a differentiable affine transform. We show this architecture outperforms both standard recurrent agents and state of the art agents with structured memory. We demonstrate that incorporating these inductive biases into an agent’s architecture allows for stable training with reward alone, circumventing the expense of acquiring and labelling expert trajectories. A detailed ablation study demonstrates the impact of key aspects of the architecture and through extensive qualitative analysis, we show how the agent exploits its structured internal memory to achieve higher performance.
+
+# 1 INTRODUCTION
+
+A critical part of intelligence is navigation, memory and planning. An animal that is able to store and recall pertinent information about their environment is likely to exceed the performance of an animal whose behavior is purely reactive. Many control problems in partially observed 3D environments involve long term dependencies and planning. Solving these problems requires agents to learn several key capacities: spatial reasoning — to explore the environment in an efficient manner and to learn spatio-temporal regularities and affordances. The agent needs to autonomously navigate, discover relevant objects, store their positions for later use, their possible interactions and the eventual relationships between the objects and the task at hand. Semantic mapping is a key feature in these tasks. A second feature is discovering semantics from interactions — while solutions exist for semantic mapping and semantic SLAM Civera et al. (2011); Tateno et al. (2017), a more interesting problem arises when the semantics of objects and their affordances are not supervised, but defined through the task and thus learned from reward.
+
+A typical approach for these types of problems are agents based on deep neural networks including recurrent hidden states, which encode the relevant information of the history of observations Mirowski et al. (2017); Jaderberg et al. (2017). If the task requires navigation, the hidden state will naturally be required to store spatially structured information. It has been recently reported that spatial structure as inductive bias can improve the performance on these tasks. In Parisotto & Salakhutdinov (2018), for instance, different cells in a neural map correspond to different positions of the agent.
+
+In our work, we go beyond structuring the agent’s memory with respect to the agent’s position. We use projective geometry as an inductive bias to neural networks, allowing the agent to structure its memory with respect to the locations of objects it perceives, as illustrated in Figure 1b. The model performs an inverse projection of CNN feature vectors in order to map and store observations in an egocentric (bird’s eye view) spatially structured memory. The EgoMap is complementary to the hidden state vector of the agent and is read with a combination of a global convolutional read operation and an attention model allowing the agent to query the presence of specific content. We show that incorporating projective spatial memory enables the agent to learn policies that exceed the performance of a standard recurrent agent. Two different objects visible in the same input image
+
+![](images/a64fdae609fefa519a3b39e01173436a63b8116513c90e5f83e9759c47efcb4d.jpg)
+
+(a) Visual features are mapped to the top-down egocentric map. Observations from a first-person viewpoint are passed through a perception module, extracted features are projected with the inverse camera matrix and depth buffer to their 3D coordinates. The operations are implemented in a differentiable manner, so error derivatives can be back-propagated to update the weights of the perception module. Different objects in the same image are mapped to different locations in the map.
+
+![](images/b66b4754cb099da956908c73383ed827cabb9faacdeb4da46e20f01f8745c005.jpg)
+
+(b) An agent exploring in a 3D environment perceives from a projective egocentric viewpoint. Our model learns to unproject learned task-oriented semantic embeddings of observations and to map the positions of relevant objects in a spatially structured (bird’s eye view) neural memory, where different objects in the same input image are stored in different map locations. Using the ego-motion of the agent, the map is updated by differentiable affine resampling at each step in the environment.
+
+Figure 1: Overview of the perception and mapping module (a) and EgoMap agent architecture (b).
+
+could be at very different places in the environment. In contrast to Parisotto & Salakhutdinov (2018), our model will map these observations to their respective locations, and not to cells corresponding to the agent’s position, as shown in Figure 1a.
+
+The model bears a certain structural resemblance with Bayesian occupancy grids (BOG), which have been used in mobile robotics for many years Moravec (1988); Rummelhard et al. (2015). As in BOGs, we perform inverse projections of observations and dynamically resample the map to take into account ego-motion. However, in contrast to BOGs, our model does not require a handcrafted observation model and it learns semantics directly from interactions with the environment through reward. It is fully differentiable and trained end-to-end with backpropagation of derivatives calculated with policy gradient methods. Our contributions are as follows:
+
+• To our knowledge, we present the first method using a differentiable SLAM-like mapping of visual features into a top-down egocentric feature map using projective geometry while at the same time training this representation using RL from reward.   
+• Our spatial map can be translated and rotated through a differentiable affine transform and read globally and through self-attention.   
+We show that the mapping, spatial memory and self-attention can be learned end-to-end with RL, avoiding the cost of labelling trajectories from domain experts, auxiliary supervision or pre-training specific parts of the architecture.   
+• We demonstrate the improvement in performance over recurrent and spatial structured baselines without projective geometry.   
+• We illustrate the reasoning abilities of the agent by visualizing the content of the spatial memory and the self-attention process, tying it to the different objects and affordances related to the task.   
+• Experiments with noisy actions demonstrate the agent is robust to actions tolerances of up to $10 \%$ .
+
+The code will be made publicly available on acceptance.
+
+# 2 RELATED WORK
+
+Reinforcement learning — In recent years the field of Deep Reinforcement Learning (RL) has gained attention with successes on board games Silver et al. (2018) and Atari games Mnih et al. (2015). One key component was the application of deep neural networks Lecun et al. (1998) to frames from the environment or game board states. Recent works that have applied Deep RL for the control of an agent in 3D environments such as maze navigation are Mirowski et al. (2017) and Jaderberg et al. (2017) which explored the use of auxiliary tasks such as depth prediction, loop detection and reward prediction to accelerate learning. Meta RL approaches for 3D navigation have been applied by Wang et al. (2016) and Lample & Chaplot (2017) also accelerated the learning process in 3D environments by prediction of tailored game features. There has also been recent work in the use of street-view scenes to train an agent to navigate in city environments Mirowski et al. (2018). In order to infer long term dependencies and store pertinent information about the partially observable environment; network architectures typically incorporate recurrent memory such as Gated Recurrent Units Chung et al. (2015) or Long Short-Term Memory Hochreiter & Schmidhuber (1997).
+
+Differentiable memory — Differentiable memory such as Neural Turing Machines Graves et al. (2014) and Differential Neural Computers Graves et al. (2016) have shown promise where long term dependencies and storage are required. Neural Networks augmented with these memory structures have been shown to learn tasks such as copying, repeating and sorting. Some recent works for control in 2D and 3D environments have included structured memory-based architectures and mapping of observations. Neural SLAM Zhang et al. (2017) aims to incorporate a SLAM-like mapping module as part of the network architecture, but uses simulated sensor data rather than RGB observations from the environment, so the agent is unable to extract semantic meaning from its observations. The experimental results focus on 2D environments and the 3D results are limited. Playing Doom with SLAM augmented memory Bhatti et al. (2016) implements a non-differentiable inverse projective mapping with a fixed feature extractor based on Faster-RCNN Ren et al. (2015), pre-trained in a supervised manner. A downside of this approach is that the network does not learn to extract features pertinent to the task at hand as it is not trained end-to-end with RL. Fang et al. (2019) replace recurrent memory with a transformer (Vaswani et al. (2017)) attention distribution over previous observation embeddings, to highlight that recurrent architectures can struggle to capture long term dependencies. The downside is the storage of previous observations grows linearly with each step in the environment and the agent cannot chose to discard redundant information.
+
+Grid cells — there is evidence that biological agents learn to encode spatial structure. Rats develop grid cells/neurons, which fire at different locations with different frequencies and phases, a discovery that led to the 2014 Nobel prize in medicine O’Keefe & Dostrovsky (1971); Hafting et al. (2005). A similar structure seems to emerge in artificial neural networks trained to localize themselves in a maze, discovered independently in 2018 by two different research groups Cueva & Wei (2018); Banino et al. (2018).
+
+Projective geometry and spatial memory — Our work encodes spatial structure directly into the agent as additional inductive bias. We argue that projective geometry is a strong law imposed on any vision system working from egocentric observations, justifying a fully differentiable model of perception. To our knowledge, we present the first method which uses projective geometry as inductive bias while at the same time learning spatial semantic features with RL from reward.
+
+The past decade has seen an influx of affordable depth sensors. This has led to a many works in the domain reconstruction of 3D environments, which can be incorporated into robotic systems. Seminal works in this field include Izadi et al. (2011) who performed 3D reconstruction scenes using a moving Kinect sensor and Henry et al. (2014) who created dense 3D maps using RGB-D cameras.
+
+Neural Map Parisotto & Salakhutdinov (2018) implements a structured 2D differentiable memory which was tested in both egocentric and world reference frames, but does not map observations in a SLAM-like manner and instead stores a single feature vector at the agent’s current location. The agent’s position is also discretized to fixed cells and orientation quantized to four angles (North, South, East, West). A further downside is that the movement of the memory is fixed to discrete translations and the map is not rotated to the agent’s current viewpoint.
+
+MapNet Henriques & Vedaldi (2018) includes an inverse mapping of CNN features, is trained in a supervised manner to predict x,y position and rotation from human trajectories, but does not use the map for control in an environment. Visual Question Answering in Interactive Environments Gordon et al. (2018) creates semantic maps from 3D observations for planning and question answering and is applied in a discrete state space.
+
+Table 1: Comparison of key features of related works   
+
+<table><tr><td rowspan=10 colspan=4>Semantic mapping Civera et al. (2011)         √Playing Doom with SLAM Bhati et al. (2016)  √Neural SLAM Zhang et al. (2017)Cog.Map Gupta et al. (2017)Semantic SLAM Tateno et al. (2017)IQA Gordon et al. (2018)MapNet Henriques &amp; Vedaldi (2018)           √Neural Map Parisotto &amp; Salakhutdinov (2018)MERLIN Wayne et al. (2018)Learning exploration policies Chen et al. (2019) √</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=2>v</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=2></td></tr><tr><td rowspan=1 colspan=3>Playing Doom with SLAM Bhati et al. (2016)  √</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-   √</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=2></td></tr><tr><td rowspan=2 colspan=2>Neural SLAM Zhang et al. (2017)Cog.Map Gupta et al. (2017)Semantic SLAM Tateno et al. (2017)</td><td rowspan=1 colspan=1>Neural SLAM Zhang et al. (2017)</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√  -</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=2 colspan=1>√</td><td rowspan=2 colspan=1></td><td rowspan=2 colspan=1>√</td><td rowspan=2 colspan=1>：</td><td rowspan=2 colspan=1>：</td><td rowspan=2 colspan=1></td></tr><tr><td rowspan=1 colspan=1>，√</td><td rowspan=1 colspan=1>√√</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1>√  √</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=2>√-</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>v</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√  √</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1>=   √</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=4>EgoMap                                  √</td><td rowspan=1 colspan=1>√   √</td><td rowspan=1 colspan=1>-   √</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1>√   √</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr></table>
+
+Unsupervised Predictive Memory in a Goal-Directed Agent Wayne et al. (2018) incorporates a Differential Neural Computer in an RL agent’s architecture and was applied to simulated memorybased tasks. The architecture achieves improved performance over a typical LSTM Hochreiter & Schmidhuber (1997) based RL agent, but does not include spatial structure or projective mapping. In addition, visual features and neural memory are learned through the reconstruction of observations and actions, rather than for a specific task.
+
+Cognitive Mapping and Planning for Visual Navigation Gupta et al. (2017) applies a differentiable mapping process on 3D viewpoints in a discrete grid-world, trained with imitation learning which provides supervision on expert trajectories. The downside of discretization is that affine sampling is trivial for rotations of 90-degree increments, and this motion is not representative of the real world. Their tasks are simple point-goal problems of up to 32 time-steps, whereas our work focused on complex multi-step objectives in a continuous state space. Their reliance on imitation learning highlights the challenge of training complex neural architectures with reward alone, particular on tasks with sparse reward such as the ones presented in this paper.
+
+Learning Exploration Policies for Navigation Chen et al. (2019), do not learn a perception module but instead map the depth buffer to a 2D map to provide a map-based exploration reward. Our work learns the features that can be mapped so the agent can query not only occupancy, but task-related semantic content.
+
+Our work greatly exceeds the performance of Neural Map Parisotto & Salakhutdinov (2018), by embedding a differentiable inverse projective transform and a continuous egocentric map into the agent’s network architecture. The mapping of the environment is in the agent’s reference frame, including translation and rotation with a differentiable affine transform. We demonstrate stable training with reinforcement learning alone, over several challenging tasks and random initializations, and do not require the expense of acquiring expert trajectories. We detail the key similarities and differences with related work in table 1.
+
+# 3 EGOMAP
+
+We consider partially observable Markov decision processes (POMDPs) Kaelbling et al. (1998) in 3D environments and extend recent Deep-RL models, which include a recurrent hidden layer to store pertinent long term information Mirowski et al. (2017); Jaderberg et al. (2017). In particular, RGBD observations $I _ { t }$ at time step $t$ are passed through a perception module extracting features $s _ { t }$ , which are used to update the recurrent state:
+
+$$
+s _ { t } = f _ { p } ( I _ { t } ; \theta _ { p } ) \qquad h _ { t } = f _ { r } ( h _ { t - 1 } , s _ { t } ; \theta _ { r } )
+$$
+
+where $f _ { p }$ is a convolutional neural network and $f _ { r }$ is a recurrent neural network in the Gated Recurrent Unit variant Chung et al. (2015). Gates and their equations have been omitted for simplicity. Above and in the rest of this paper, $\theta _ { * }$ are trainable parameters, exact architectures are provided in the appendix. The controller outputs an estimate of the policy (the action distribution) and the value function given its hidden state:
+
+$$
+\begin{array} { r l r } { \pi _ { t } = f _ { \pi } ( h _ { t } ; \theta _ { \pi } ) } & { { } } & { v _ { t } = f _ { v } ( h _ { t } ; \theta _ { v } ) } \end{array}
+$$
+
+The proposed model is motivated by the regularities which govern 3D physical environments. When an agent perceives an observation of the 3D world, it observes a 2D planar perspective projection of the world based on its current viewpoint. This projection is a well understood physical process, we aim to imbue the agent’s architecture with an inductive bias based on inverting the 3D to 2D planar projective process. This inverse mapping operation appears to be second nature to many organisms, with the initial step of depth estimation being well studied in the field of Physiology Frégnac et al. (2004). We believe that providing this mechanism implicitly in the agent’s architecture will improve its reasoning capabilities in new environments bypass a large part of the learning process.
+
+The overall concept is that as the agent explores the environment, the perception module $f _ { p }$ produces a 2D feature map $s _ { t }$ , in which each feature vector represents a learned semantic representation of a small receptive field from the agent’s egocentric observation. While they are integrated into the flat (not spatially structured) recurrent hidden state $h _ { t }$ through function $f _ { r }$ (Equation 1), we propose its integration into a second tensor $M _ { t }$ , a top-down egocentric memory, which we call EgoMap. The feature vectors are mapped to their egocentric positions using the inverse projection matrix and depth estimates. This requires an agent with a calibrated camera (known intrinsic parameters), which is a soft constraint easily satisfied. The map can then be read by the agent in two ways: a global convolutional read operation and a self-attention operation.
+
+Formally, let the agent’s position and angle at time $t$ be $( x _ { t } , y _ { t } )$ and $\phi _ { t }$ respectively, $M _ { t }$ is the current EgoMap. $s _ { t }$ are the feature vectors extracted by the perception module, $D _ { t }$ are the depth buffer values. The change in agent position and orientation in the agent’s frame of reference between time-step $t$ and $t - 1$ are $( d x _ { t } , d y _ { t } , d \phi _ { t } )$ .
+
+There are three key steps to the operation of the EgoMap:
+
+1. Transform the map to the agent’s egocentric frame of reference:
+
+$$
+\hat { M } _ { t } = \mathrm { A f f i n e } ( M _ { t - 1 } , d x _ { t } , d y _ { t } , d \phi _ { t } )
+$$
+
+2. Update the map to include new observations:
+
+$$
+\begin{array} { r } { \tilde { M } _ { t } = \mathrm { I n v e r s e P r o j e c t } ( s _ { t } , D _ { t } ) \qquad M _ { t } ^ { \prime } = \mathrm { C o m b i n e } ( \hat { M } _ { t } , \tilde { M } _ { t } ) } \end{array}
+$$
+
+3. Perform a global read and attention based read, the outputs of which are fed into the policy and value heads:
+
+$$
+r _ { t } = { \mathrm { R e a d } } ( M _ { t } ^ { \prime } ) \qquad c _ { t } = { \mathrm { C o n t e x t } } ( M _ { t } ^ { \prime } , s _ { t } , r _ { t } )
+$$
+
+These three operations will be further detailed below in individual subsections. Projective mapping and spatially structured memory should augment the agent’s performance where spatial reasoning and long term recollection are required. On simpler tasks the network can still perform as well as the baseline, assuming the extra parameters do not cause further instability in the RL training process.
+
+Affine transform — At each time-step we wish to translate and rotate the map into the agent’s frame of reference, this is achieved with a differentiable affine transform, popularized by the well known Spatial Transformer Networks Jaderberg et al. (2015). Relying on the simulator to be an oracle and provide the change in position $( d x , d y )$ and orientation $d \phi$ , we convert the deltas to the agent’s egocentric frame of reference and transform the map with a differentiable affine transform. The effect of noise on the change in position on the agent’s performance is analysed in the experimental section.
+
+Inverse projective mapping — We take the agent’s current observation, extract relevant semantic embeddings and map them from a 2D planar projection to their 3D positions in an egocentric frame of reference. At each time-step, the agent’s egocentric observation is encoded by the perception module (a convolutional neural network) to produce feature vectors, this step is a mapping from $R ^ { 4 \times 6 4 \times 1 1 2 }  R ^ { 1 6 \times 4 \times 1 0 }$ . Given the inverse camera projection matrix and the depth buffer provided by the simulator, we can compute the approximate location of the features in the agent’s egocentric frame of reference. As the mapping is a many to one operation, several features can be mapped to the same location. Features that share the same spatial location are averaged element-wise.
+
+The newly mapped features must then be combined with the translated map from the previous time-step. We found that the use of a momentum hyper-parameter, $\alpha$ , enabled a smooth blending of new and previously observed features. We use an $\alpha$ value of 0.9 for the tests presented in the paper. We ensured that the blending only occurs where the locations of new projected features and the map from the previous time-step are co-located, this criterion is detailed in Equation 6.
+
+$$
+\begin{array} { r } { M _ { t } ^ { \prime ( x , y ) } = \eta \hat { M _ { t } } ^ { ( x , y ) } + ( 1 - \eta ) \tilde { M } _ { t } ^ { ( x , y ) } } \\ { \eta = \left\{ \begin{array} { l l } { 1 . 0 , } & { \mathrm { i f ~ } \tilde { M } _ { t } ^ { ( x , y ) } = 0 \& \hat { M _ { t } } ^ { ( x , y ) } \neq 0 } \\ { 0 . 0 , } & { \mathrm { i f ~ } \tilde { M _ { t } } ^ { ( x , y ) } \neq 0 \& \hat { M } _ { t } ^ { ( x , y ) } = 0 } \\ { \alpha , } & { \mathrm { o t h e r w i s e } } \end{array} \right. } \end{array}
+$$
+
+Sampling from a global map — A naive approach to the storage and transformation of the egocentric feature map would be to apply an affine transformation to the map at each time-step. A fundamental downside of applying repeated affine transforms is that at each step a bilinear interpolation operation is applied, which causes smearing and degradation of the features in the map. We mitigated this issue by storing the map in a global reference frame and mapping the agent’s observations to the global reference frame. For the read operation an offline affine transform is applied. For further details see the appendix B
+
+Read operations — We wanted the agent to be able to summarize the whole spatial map and also selectively query for pertinent information. This was achieved by incorporating two types of read operation into the agent’s architecture, a Global Read operation and a Self-attention Read.
+
+The global read operation is a CNN that takes as input the egocentric map and outputs a 32- dimensional feature vector that summarizes the map’s contents. The output of the global read is concatenated with the visual CNN output.
+
+To query for relevant features in the map, the agent’s controller network can output a query vector $q _ { t }$ , the network then compares this vector to each location in the map with a cosine similarity function in order to produce scores, which are the same width and height as the map. The scores are normalized with a softmax operation to produce a soft-attention in the lines of Bahdanau et al. (2014) and used to compute a weighted average of the map, allowing the agent to selectively query and focus on parts of the map. This querying mechanism was used in both the Neural Map Parisotto & Salakhutdinov (2018) and MERLIN Wayne et al. (2018) RL agents. We made the following improvements: Attention Temperature and Query Position.
+
+$$
+\sigma ( x ) _ { i } = \frac { e ^ { \beta x _ { i } } } { \sum e ^ { \beta x _ { j } } }
+$$
+
+Query Position: A limitation of self-attention is that the agent can query what it has observed but not where it had observed it. To improve the spatial reasoning performance of the agent we augmented the neural memory with two fixed additional coordinate planes representing the x,y egocentric coordinate system normalized to $( - 1 . 0 , 1 . 0 )$ , as introduced for segmentation in Liang et al. (2018). The agent still queries based on the features in the map, but the returned context vector includes two extra scalar quantities which are the weighted averages of the x,y planes. The impacts of these additions are discussed and quantified in the ablation study, in Section 4.
+
+Attention Temperature: To provide the agent with the ability to learn to modify the attention distribution, the query includes an additional learnable temperature parameter, $\beta$ , which can adjust the softmax distribution detailed in Equation 7. This parameter can vary query by query and is constrained to be one or greater by a Oneplus function. The use of temperature in neural memory architectures was first introduced in Neural Turing Machines Graves et al. (2014).
+
+# 4 EXPERIMENTS
+
+The EgoMap and baseline architectures were evaluated on four challenging 3D scenarios, which require navigation and different levels of spatial memory. The scenarios are taken from Beeching et al. (2019) who extended the 3D ViZDoom environment Kempka et al. (2017) with various scenarios that are partially observable, require memory, spatial understanding, have long horizons and sparse rewards. Whilst more visually realistic simulators are available such as Gibson Xia et al. (2018), Matterport Anderson et al. (2018), Home Brodeur et al. (2018) and Habitat Manolis Savva\* et al.
+
+<table><tr><td rowspan="2"></td><td colspan="8">Scenario</td></tr><tr><td colspan="2">4 item</td><td colspan="2">6item</td><td colspan="2">Find and Return</td><td colspan="2">Labyrinth</td></tr><tr><td>Agent</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>Random</td><td>-0.179</td><td>-0.206</td><td>-0.21</td><td>-0.21</td><td>-0.21</td><td>-0.21</td><td>-0.115</td><td>-0.086</td></tr><tr><td>Baseline</td><td>2.341 ± 0.026</td><td>2.266 ± 0.035</td><td>2.855 ± 0.164</td><td>2.545 ± 0.226</td><td>0.661± 0.003</td><td>0.633 ± 0.027</td><td>0.73 ±0.02</td><td>0.694 ± 0.009</td></tr><tr><td>Neural Map</td><td>2.339 ±0.038</td><td>2.223 ± 0.040</td><td>2.750 ± 0.062</td><td>2.465 ± 0.034</td><td>0.825 ± 0.070</td><td>0.723 ± 0.026</td><td>0.769 ± 0.042</td><td>0.706 ± 0.018</td></tr><tr><td>EgoMap</td><td>2.398 ± 0.014</td><td>2.291 ± 0.021</td><td>3.214 ± 0.007</td><td>2.801 ± 0.048</td><td>0.893 ±0.007</td><td>0.848 ± 0.017</td><td>0.753 ± 0.002</td><td>0.732 ± 0.016</td></tr><tr><td>Optimum (Upper Bound)</td><td>2.5</td><td>2.5</td><td>3.5</td><td>3.5</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr></table>
+
+Table 2: Results of the baseline and EgoMap architectures trained on four scenarios for $1 . 2 \mathrm { ~ B ~ }$ environment steps. We show the mean and std. of the final agent performance, evaluated for three independent experiments on a held-out testing set of scenario configurations.
+
+(2019), the tasks available are simple point-goal tasks which do not require long term memory and recollection. We target the following three tasks:
+
+Labyrinth: The agent must find the exit in the fastest time possible, the reward is a sparse positive reward for finding the exit. This tests an agent’s ability to explore in an efficient manner.
+
+Ordered k-item: An agent must find $k$ objects in a fixed order. It tests three aspects of an agent: its ability to explore the environment efficiently, the ability to learn to collect items in a predefined order and its ability to store as part of its hidden state where items were located so they can be retrieved in the correct order. We tested two versions of this scenario with 4-items or 6-items.
+
+Find and return: The agent starts next to a green totem, must explore the environment to find a red totem and then return to the starting point. This is our implementation of “Minotaur" scenario from Parisotto & Salakhutdinov (2018). The scenario tests an agent’s ability to navigate and retain information over long time periods.
+
+All the tasks require different levels of spatial memory and reasoning. For example, if an agent observes an item out of order it can store the item’s location in its spatial memory and navigate back to it later. We observe that scenarios that require more spatial reasoning, long term planning and recollection are where the agent achieves the greatest improvement in performance. In all scenarios there is a small negative reward for each time-step to encourage the agent to complete the task quickly.
+
+Experimental strategy and generalization to unseen environments — Many configurations of each scenario were created through procedural generation and partitioned into separated training and testing sets of size 256 and 64 respectively for each scenario type. Although the task in a scenario is fixed, we vary the locations of the walls, item locations, and start and end points; thus we ensure a diverse range of possible scenario configurations. A limited hyper-parameter sweep was undertaken with the baseline architecture to select the hyper-parameters, which were fixed for both the baseline, Neural Map and EgoMap agents. Three independent experiments were conducted per task to evaluate the algorithmic stability of the training process. To avoid information asymmetry, we provide the baseline agent with $d x , d y , s i n ( d \theta ) , c o s ( d \theta )$ concatenated with its visual features.
+
+Training Details — The model parameters were optimized with an on-policy, policy gradient algorithm; batched Advantage Actor Critic (A2C) Mnih et al. (2016), we used the popular PyTorch Paszke et al. (2017) implementation of A2C Kostrikov (2018). We sampled trajectories from 16 parallel agents and updated every 128 steps in the environment with discounted returns bootstrapped from value estimates for non-terminal states. The gamma factor was 0.99, the entropy weight was 0.001, the RMSProp Tieleman & Hinton (2012) optimizer was used with a learning rate of 7e-4. The EgoMap agent map size was $1 6 \times 2 4 \times 2 4$ with a grid sampling chosen to cover the environment size with a $20 \%$ padding. The agent’s policy was updated over 1.2B environment steps, with a frame skip of 4. Training took 36 hours for the baseline and 8 days for the EgoMap, on 4 Xeon E5-2640v3 CPUs, with 32GB of memory and one NVIDIA GK210 GPU.
+
+Results — Results from the baseline and EgoMap policies evaluated on the 4 scenarios are shown in table 2, all tasks benefit from the inclusion of inverse projective mapping and spatial memory in the agent’s network architecture, with the largest improvement on the Find and Return scenario. We postulate that the greater improvement in performance is due to two factors; firstly this scenario always requires spatial memory as the agent must return to its starting point and secondly the objects in this scenario are larger and occupy more space in the map. We also compared to the state of the art in spatially structured neural memory, Neural Map Parisotto & Salakhutdinov (2018). Figure 2 shows agent training curves for the recurrent baseline, Neural Map and EgoMap, on the Find and Return test set configurations.
+
+![](images/f36aba87008ce43fdbf7d8e5295e4684e09a6d0c4afa3227be420a4caea2e29d.jpg)  
+Figure 2: Left: Agent performance on unseen test configurations of the Find and Return scenario. Right: Ablation study on the Find and Return scenario conducted after 800M environment steps.
+
+<table><tr><td>Ablation</td><td>Train</td><td>Test</td></tr><tr><td>Baseline</td><td>0.668 ± 0.028</td><td>0.662 ± 0.036</td></tr><tr><td>No global read</td><td>0.787 ± 0.007</td><td>0.771 ± 0.029</td></tr><tr><td>No query</td><td>0.838 ± 0.003</td><td>0.811 ± 0.013</td></tr><tr><td>No query temperature</td><td>0.845 ± 0.014</td><td>0.815 ± 0.019</td></tr><tr><td>No query position</td><td>0.839 ± 0.007</td><td>0.814 ± 0.008</td></tr><tr><td>EgoMap</td><td>0.847 ± 0.011</td><td>0.814 ± 0.017</td></tr><tr><td>EgoMap (L1 query)</td><td>0.851 ± 0.014</td><td>0.828 ± 0.011</td></tr></table>
+
+Ablation study — An ablation study was carried out on the improvements made by the EgoMap architecture. We were interested to see the influence of key options such as the global and attentionbased reads, the similarity function used when querying the map, the learnable temperature parameter and the incorporation of location-based querying. The Cartesian product of these options is large and it was not feasible to test them all, we therefore decided to selectively switch off key options to understand which aspects contribute to the improvement in performance. The results of the ablation study are shown in Table 2. Both the global and self-attention reads provide large improvements in performance over the baseline recurrent agent. The position-based query provides a small improvement. A comparison of the similarity metric of the attention mechanism highlights the L1-similarity achieved higher performance than cosine. A qualitative analysis of the self-attention mechanism is shown in the next section.
+
+# 5 ANALYSIS
+
+Noisy Actions — One common criticism of agents trained in simulation is that the agent can query its environment for information that would not be readily available in the real world. In the case of EgoMap, the agent is trained with ground truth ego-motion measurements. Real-world robots have noisy estimates of ego-motion due to the tolerances of available hardware. We performed an analysis of the EgoMap agent trained in the presence of a noisy oracle, which adds noise to the ego-motion measurement. Noise is drawn from a normal distribution centred at one and is multiplied by the agent’s ground-truth motion, the effect of the noise is cumulative but unbiased. Tests were conducted with standard deviations of up to 0.2 which is a tolerance of more than $20 \%$ on the agent’s ego-motion measurements, results are shown in Figure 3. We observed retain the performance increase over the baseline for up to $10 \%$ of noisy actions, the performance degrades to that of the baseline agent.
+
+<table><tr><td>Noise std.</td><td>Averagereturn</td></tr><tr><td>0.00</td><td>0.702 ± 0.026</td></tr><tr><td>0.02</td><td>0.686 ± 0.027</td></tr><tr><td>0.04</td><td>0.669 ± 0.031</td></tr><tr><td>0.06</td><td>0.623 ± 0.018</td></tr><tr><td>0.08</td><td>0.585 ± 0.017</td></tr><tr><td>0.10</td><td>0.568 ± 0.023</td></tr><tr><td>0.12</td><td>0.575 ± 0.020</td></tr><tr><td>0.14</td><td>0.578 ± 0.023</td></tr><tr><td>0.16</td><td>0.546 ± 0.017</td></tr><tr><td>0.20</td><td>0.537 ± 0.031</td></tr><tr><td>Baseline</td><td>0.527 士 0.047</td></tr></table>
+
+![](images/f32d64eb6182acaadf8d81589d85850e9d6e48f7bc3b60dd83338f1e14d0dd41.jpg)  
+Figure 3: Test set performance of the EgoMap agent during training with noisy ego-motion measurements, conducted for $3 2 0 \mathbf { M }$ environment frames. Shown are test set performance during training (left), final performance for a range of noise values (centre) which are tabulated (right). We retain an improvement in performance over the baseline agent for noisy actions of up to $10 \%$ .
+
+![](images/070e430f145b92900914e37bc2f254e40aa1e7fec6508fa31ac0cfc7b18f3e6e.jpg)  
+Figure 4: Analysis of the EgoMap for key steps (different rows) during an episode from the Ordered 6-item and Find and Return scenarios. Within each sub-figure: Left column - RGB observations, central column - the three largest PCA components of features mapped in the spatially structured memory, right - attention heat map (result of the query) and x,y query position vector. We observe that the agent maps and stores features from key objects and attends to them when they are pertinent to the current stage of the task. For example, for the left figure on the first row at time-step 5 the blue spherical object, which is ordered 4 of 6, is mapped into the agent’s spatial memory. The agent explores the environment collecting the items in order, it collects item 3 of 6 between time-step 105 and 108, shown on rows 2 and 3. As soon as the agent has collected item 3 it queries its internal memory for the presence of item 4, which is shown by the attention distribution on rows 3 and 4. On the last row, time-step 140, the agent observes the item and no longer attempts to query for it, as the item is in the agent’s field of view.
+
+Visualization — The EgoMap architecture is highly interpretable and provides insights about how the agent reasons in 3D environments. In Figures 4a and 4b we show analysis of the spatially structured memory and how the agent has learned to query and self-attend to recall pertinent information. The Figures show key steps during an episode in the Ordered 6-item and Find and Return scenarios, including the first three principal components of a dimensionality reduction of the 16-dimensional EgoMap, the attention distribution and the vector returned from position queries. Refer to the caption for further details. The agent is seen to attend to key objects at certain phases of the task, in the Ordered $6$ -item scenario the agent attends the next item in the sequence and in the Find and Return scenario the agent attends to the green totem located at the start/return point once it has found the intermediate goal.
+
+# 6 CONCLUSION
+
+We have presented EgoMap, an egocentric spatially structured neural memory that augments an RL agent’s performance in 3D navigation, spatial reasoning and control tasks. EgoMap includes a differentiable inverse projective transform that maps learned task-specific semantic embeddings of agent observations to their world positions. We have shown that through the use of global and self-attentive read mechanisms an agent can learn to focus on important features from the environment. We demonstrate that an RL agent can benefit from spatial memory, particularly in 3D scenarios with sparse rewards that require localization and memorization of objects. EgoMap out-performs existing state of the art baselines, including Neural Map, a spatial memory architecture. The increase in performance compared to Neural Map is due to two aspects. 1) The differential projective transform maps what the objects are to where they are in the map, which allows for direct localization with attention queries and global reads. In comparison, Neural Map writes what the agent observes to where the agent is on the map, this means that the same object viewed from two different directions will be written to two different locations on the map, which leads to poorer localization of the object. 2) Neural Map splits the map to four 90-degree angles, which alleviates the blurring highlighted in the appendix, our novel solution to this issue stores a single unified map in an allocentric frame of reference and performs an offline egocentric read, which allows an agent to act in states spaces where the angle is continuous, without the need to quantize the agent’s angle to 90-degree increments.
+
+We have shown, with detailed analysis, how the agent has learned to interact with its structured internal memory with self-attention. The ablation study has shown that the agent benefits from both the global and self-attention operations and that these can be augmented with temperature, position querying and other similarity metrics. We have demonstrated that the EgoMap architecture is robust to actions with tolerances of up to $10 \%$ . Future work in this area of research would be to apply the mapping and memory architecture in more realistic-looking domains and aim to incorporate both dynamic and static objects into the agent’s network architecture and update mechanisms.
+
+# REFERENCES
+
+Peter Anderson, Qi Wu, Damien Teney, Jake Bruce, Mark Johnson, Niko Sünderhauf, Ian Reid, Stephen Gould, and Anton den Hengel. Vision-and-language navigation: Interpreting visuallygrounded navigation instructions in real environments. In CVPR, 2018.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
+
+A. Banino, C. Barry, B. Uria, C. Blundell, T. Lillicrap, P. Mirowski, A. Pritzel, M.J. Chadwick, T. Degris, J. Modayil, G. Wayne, H. Soyer, F. Viola, B. Zhang, R. Goroshin, N. Rabinowitz, R. Pascanu, C. Beattie, S. Petersen, A. Sadik, S. Gaffney, H. King, K. Kavukcuoglu, D. Hassabis, R. Hadsell, and D. Kumaran. Vector-based navigation using grid-like representations in artificial agents. Nature, 557, 2018.
+
+Edward Beeching, Christian Wolf, Jilles Dibangoye, and Olivier Simonin. Deep reinforcement learning on a budget: 3d control and reasoning without a supercomputer. CoRR, abs/1904.01806, 2019. URL http://arxiv.org/abs/1904.01806.
+
+Shehroze Bhatti, Alban Desmaison, Ondrej Miksik, Nantas Nardelli, N. Siddharth, and Philip H. S. Torr. Playing doom with slam-augmented deep reinforcement learning. arxiv preprint 1612.00380, 2016.
+
+Simon Brodeur, Ethan Perez, Ankesh Anand, Florian Golemo, Luca Celotti, Florian Strub, Jean Rouat, Hugo Larochelle, and Aaron Courville. HoME: a Household Multimodal Environment. In ICLR, 2018.
+
+Tao Chen, Saurabh Gupta, and Abhinav Gupta. Learning exploration policies for navigation. In ICLR, 03 2019.
+
+Junyoung Chung, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio. Gated Feedback Recurrent Neural Networks. In ICML, 2015.
+
+J. Civera, D. Galvez-Lopez, L. Riazuelo, J. D. Tardós, and J. M. M. Montiel. Towards semantic SLAM using a monocular camera. In IROS, 2011.
+
+C.J. Cueva and X.-X. Wei. Emergence of grid-like representations by training recurrent neural networks to perform spatial localization. In ICLR, 2018.
+
+Kuan Fang, Alexander Toshev, Li Fei-Fei, and Silvio Savarese. Scene memory transformer for embodied agents in long-horizon tasks. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+Yves Frégnac, Alice René, Jean Baptiste Durand, and Yves Trotter. Brain encoding and representation of 3d-space using different senses, in different species. Journal of physiology, Paris, 98(1-3):1, 2004.
+
+Daniel Gordon, Aniruddha Kembhavi, Mohammad Rastegari, Joseph Redmon, Dieter Fox, and Ali Farhadi. Iqa: Visual question answering in interactive environments. In CVPR. IEEE, 2018.
+
+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 GrabskaBarwinska, Sergio Gómez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, et al. ´ Hybrid computing using a neural network with dynamic external memory. Nature, 538(7626):471, 2016.
+
+S. Gupta, J. Davidson, S. Levine, R. Sukthankar, and J. Malik. Cognitive mapping and planning for visual navigation. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7272–7281, July 2017. doi: 10.1109/CVPR.2017.769.
+
+Torkel Hafting, Marianne Fyhn, Sturla Molden, May-Britt Moser, and Edvard Moser. Microstructure of a spatial map in the entorhinal cortex. Nature, 436:801–6, 09 2005. doi: 10.1038/nature03721.
+
+J. Henriques and A. Vedaldi. Mapnet: An allocentric spatial memory for mapping environments. In CVPR, 2018.
+
+Peter Henry, Michael Krainin, Evan Herbst, Xiaofeng Ren, and Dieter Fox. Rgb-d mapping: Using depth cameras for dense 3d modeling of indoor environments. In Experimental robotics, pp. 477–491. Springer, 2014.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long Short-Term Memory. Neural Computation, 9(8): 1735–1780, 1997.
+
+Shahram Izadi, David Kim, Otmar Hilliges, David Molyneaux, Richard Newcombe, Pushmeet Kohli, Jamie Shotton, Steve Hodges, Dustin Freeman, Andrew Davison, et al. Kinectfusion: real-time 3d reconstruction and interaction using a moving depth camera. In Proceedings of the 24th annual ACM symposium on User interface software and technology, pp. 559–568. ACM, 2011.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, and koray kavukcuoglu. Spatial transformer networks. In NIPS. 2015.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z. Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. In ICLR, 2017.
+
+Leslie Pack Kaelbling, Michael L Littman, and Anthony R Cassandra. Planning and acting in partially observable stochastic domains. Artificial intelligence, 101(1-2):99–134, 1998.
+
+Michal Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. ViZDoom: A Doom-based AI research platform for visual reinforcement learning. IEEE Conference on Computatonal Intelligence and Games, CIG, 2017. ISSN 23254289.
+
+Ilya Kostrikov. Pytorch implementations of reinforcement learning algorithms. https://github. com/ikostrikov/pytorch-a2c-ppo-acktr, 2018.
+
+Guillaume Lample and Devendra Singh Chaplot. Playing FPS games with deep reinforcement learning. In AAAI, 2017.
+
+Yann Lecun, L Eon Bottou, Yoshua Bengio, and Patrick Haaner. Gradient-Based Learning Applied to Document Recognition. Proceedings of the IEEE, 86(11):2278 – 2324, 1998.
+
+X. Liang, Y. Wei, X. Shen, J. Yang, L. Lin, and S. Yan. Proposal-Free Network for Instance-Level Object Segmentation . IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(12), 2018.
+
+Manolis Savva\*, Abhishek Kadian\*, Oleksandr Maksymets\*, and Dhruv Batra. Habitat: A platform for embodied ai research. arXiv, 2019.
+
+Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J. Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, Dharshan Kumaran, and Raia Hadsell. Learning to Navigate in Complex Environments. In ICLR, 2017.
+
+Piotr Mirowski, Matthew Koichi Grimes, Mateusz Malinowski, Karl Moritz Hermann, Keith Anderson, Denis Teplyashin, Karen Simonyan, Koray Kavukcuoglu, Andrew Zisserman, and Raia Hadsell. Learning to Navigate in Cities Without a Map. In NeurIPS2018, 2018.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540), 2015.
+
+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 ICML, 2016.
+
+H. Moravec. Sensor fusion in certainty grids for mobile robots. AI magazine, 9(2), 1988.
+
+J. O’Keefe and J. Dostrovsky. The hippocampus as a spatial map. preliminary evidence from unit activity in the freely-moving rat. Brain Research, 34(1):171 – 175, 1971.
+
+Emilio Parisotto and Ruslan Salakhutdinov. Neural map: Structured memory for deep reinforcement learning. In ICLR, 2018.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In NIPS-W, 2017.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), NIPS. 2015.
+
+L. Rummelhard, A. Nègre, and C. Laugier. Conditional Monte Carlo Dense Occupancy Tracker. In International Conference on Intelligent Transportation Systems, 2015.
+
+David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, Timothy Lillicrap, Karen Simonyan, and Demis Hassabis. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419):1140–1144, 2018.
+
+Keisuke Tateno, Federico Tombari, Iro Laina, and Nassir Navab. Cnn-slam: Real-time dense monocular slam with learned depth prediction. In CVPR, 2017.
+
+T. Tieleman and G. Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. 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. 5998–6008. Curran Associates, Inc., 2017. URL http: //papers.nips.cc/paper/7181-attention-is-all-you-need.pdf.
+
+Jane X. Wang, Zeb Kurth-Nelson, Dhruva Tirumala, Hubert Soyer, Joel Z. Leibo, Rémi Munos, Charles Blundell, Dharshan Kumaran, and Matthew Botvinick. Learning to reinforcement learn. arxiv pre-print 1611.05763, 2016.
+
+Greg Wayne, Chia-Chun Hung, David Amos, Mehdi Mirza, Arun Ahuja, Agnieszka GrabskaBarwinska, Jack W. Rae, Piotr W. Mirowski, Joel Z. Leibo, Adam Santoro, Mevlana Gemici, Malcolm Reynolds, Tim Harley, Josh Abramson, Shakir Mohamed, Danilo Jimenez Rezende, David Saxton, Adam Cain, Chloe Hillier, David Silver, Koray Kavukcuoglu, Matthew Botvinick, Demis Hassabis, and Timothy P. Lillicrap. Unsupervised predictive memory in a goal-directed agent. arxiv preprint 1803.10760, 2018.
+
+Fei Xia, Amir R. Zamir, Zhi-Yang He, Alexander Sax, Jitendra Malik, and Silvio Savarese. Gibson env: real-world perception for embodied agents. In CVPR, 2018.
+
+Jingwei Zhang, Lei Tai, Joschka Boedecker, Wolfram Burgard, and Ming Liu. Neural SLAM. arxiv preprint 1706.09520, 2017.
+
+A APPENDIX B AFFINE TRANSFORM
+
+A naive implementation of the repeated affine transforms leads to smearing of features Figure 5 demonstrates the degradation of features on synthetic RGB images with repeated rotations and translations. We should how storing the features in an allocentric frame of reference and performing offline transforms for read operations can greatly mitigate this issue.
+
+![](images/460fd06d85f9375d8f303e44bddc5d0af1fc824f1f6022a654fb9e8613f45cbe.jpg)  
+Figure 5: A synthetic 3-channel top down map. Rotations of two degrees per time-step with naive and global reference frame (rows 1 & 2) shown over 180 time-steps. Translations with naive and global reference frame (rows 3 & 4) shown over 180 time-steps. Distinct degradation of the map features are observed by time-step 100 and features are barely visible after 180 steps, leading to poor localization with self-attention queries. In tasks that span up to 500 time-steps, the blurring of features could have greatly restricted the EgoMap agent’s performance.
+
+# C ARCHITECTURES
+
+To encourage reproducibility, we detail the exact architectures of the agents. Figure 6 shows an overview.
+
+Baseline Model — is comprised of the following: Perception Module $f _ { p }$ : A 3 layer CNN with kernel sizes of 8,4,3, strides of 4,2,1, no padding and filter sizes of 16,32,16, respectively and ReLU activation. $f _ { p }$ is a mapping from an RGBD input observation of $R ^ { 4 \times 6 4 \times 1 1 2 }  \bar { R } ^ { 1 6 \times 4 \times 1 \bar { 0 } }$ . Recurrent Module $f _ { r }$ : A FC layer reduces the output of $f _ { p }$ from 640 values to a vector of size 128 and includes a ReLU activation; we then use a GRU layer with 128 hidden units. Policy and Value Heads $f _ { \pi }$ & $f _ { v }$ : These layers receive as input the output of $f _ { r }$ . The policy layer is a FC layer with 5 output units corresponding to the 5 discrete actions available to the agent (through a softmax activation). The value layer is a FC layer with one output unit.
+
+EgoMap Model — is comprised of the following: Perception Module $f _ { p }$ : The same as the baseline architecture, apart from that the mapping operation is applied before the final ReLU activation function. EgoMap Global Read Module: A 3 layer CNN with kernel sizes of 3,4,4, strides of 1,2,2 and filter sizes of 16,16,16 respectively, and no padding. Followed by two linear layers of 256 and 32 hidden units, and ReLU activations, apart from the last which was tanh. Recurrent Module $f _ { r }$ : The output of $f _ { p }$ and the global read module were concatenated to form a vector of size 672 and fed into a FC layer later with 128 output units. The recurrent module was a GRU with 128 units. Self-Attention Read Head: The query head is a linear layer with 17 output units, 16 for the calculation of the EgoMap similarity scores and one for the $\beta$ temperature parameter. The query head returns a vector of size 18 which includes two more scalar values for the average position of the query. Policy and Value Heads $f _ { \pi }$ & $f _ { v }$ : Are the same as the baseline but their input is the concatenation of the output of the $f _ { r }$ and the attention head.
+
+![](images/82404967326e9fa7597a5ada938ba17dc284bbcb5af6e650bc39c1ef3daed0b8.jpg)  
+Figure 6: The baseline agent architecture (light blue) augmented with the EgoMap architecture (green), the agent’s hidden state is $h _ { t }$ and the spatially structured neural memory $M _ { t }$ . We rely on an oracle (the simulator) to provide the depth buffer $D _ { t }$ and the agent deltas $( d x , d y , d \theta )$ .
+
+# D READ MECHANISMS
+
+In figure 7 we provide further details of the operation of the global read, context read and xy-querying.
+
+# E ADDITIONAL RESULTS
+
+In figure 8 we provide the curves of agent performance on held out test configurations for three scenarios: 4-item, 6-item and labyrinth.
+
+![](images/00d7d1117b3beb40913bf94329fc0af281d4485976930e5f9a9a01e9df62a8b5.jpg)  
+Figure 7: Schematics detailing the operation of the read mechanisms, with global read (left), context read(middle) and xy-querying (right).
+
+![](images/65cf6dcbd579474e337bc774aeeefc6dda064e267084d351d80588e9fb5c5e52.jpg)  
+Figure 8: Training curves of held out test set performance on 4-item (top left), 6-item(top-right) and labyrinth scenarios (bottom).

parse/train/S1gfu3EtDr/S1gfu3EtDr_content_list.json

@@ -0,0 +1,1691 @@
+[
+    {
+        "type": "text",
+        "text": "EGOMAP: PROJECTIVE MAPPING AND STRUCTURED EGOCENTRIC MEMORY FOR DEEP RL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tasks involving localization, memorization and planning in partially observable 3D environments are an ongoing challenge in Deep Reinforcement Learning. We present EgoMap, a spatially structured neural memory architecture. EgoMap augments a deep reinforcement learning agent’s performance in 3D environments on challenging tasks with multi-step objectives. The EgoMap architecture incorporates several inductive biases including a differentiable inverse projection of CNN feature vectors onto a top-down spatially structured map. The map is updated with ego-motion measurements through a differentiable affine transform. We show this architecture outperforms both standard recurrent agents and state of the art agents with structured memory. We demonstrate that incorporating these inductive biases into an agent’s architecture allows for stable training with reward alone, circumventing the expense of acquiring and labelling expert trajectories. A detailed ablation study demonstrates the impact of key aspects of the architecture and through extensive qualitative analysis, we show how the agent exploits its structured internal memory to achieve higher performance. ",
+        "bbox": [
+            233,
+            266,
+            766,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            502,
+            336,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A critical part of intelligence is navigation, memory and planning. An animal that is able to store and recall pertinent information about their environment is likely to exceed the performance of an animal whose behavior is purely reactive. Many control problems in partially observed 3D environments involve long term dependencies and planning. Solving these problems requires agents to learn several key capacities: spatial reasoning — to explore the environment in an efficient manner and to learn spatio-temporal regularities and affordances. The agent needs to autonomously navigate, discover relevant objects, store their positions for later use, their possible interactions and the eventual relationships between the objects and the task at hand. Semantic mapping is a key feature in these tasks. A second feature is discovering semantics from interactions — while solutions exist for semantic mapping and semantic SLAM Civera et al. (2011); Tateno et al. (2017), a more interesting problem arises when the semantics of objects and their affordances are not supervised, but defined through the task and thus learned from reward. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A typical approach for these types of problems are agents based on deep neural networks including recurrent hidden states, which encode the relevant information of the history of observations Mirowski et al. (2017); Jaderberg et al. (2017). If the task requires navigation, the hidden state will naturally be required to store spatially structured information. It has been recently reported that spatial structure as inductive bias can improve the performance on these tasks. In Parisotto & Salakhutdinov (2018), for instance, different cells in a neural map correspond to different positions of the agent. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In our work, we go beyond structuring the agent’s memory with respect to the agent’s position. We use projective geometry as an inductive bias to neural networks, allowing the agent to structure its memory with respect to the locations of objects it perceives, as illustrated in Figure 1b. The model performs an inverse projection of CNN feature vectors in order to map and store observations in an egocentric (bird’s eye view) spatially structured memory. The EgoMap is complementary to the hidden state vector of the agent and is read with a combination of a global convolutional read operation and an attention model allowing the agent to query the presence of specific content. We show that incorporating projective spatial memory enables the agent to learn policies that exceed the performance of a standard recurrent agent. Two different objects visible in the same input image ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a64fdae609fefa519a3b39e01173436a63b8116513c90e5f83e9759c47efcb4d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            121,
+            480,
+            337
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(a) Visual features are mapped to the top-down egocentric map. Observations from a first-person viewpoint are passed through a perception module, extracted features are projected with the inverse camera matrix and depth buffer to their 3D coordinates. The operations are implemented in a differentiable manner, so error derivatives can be back-propagated to update the weights of the perception module. Different objects in the same image are mapped to different locations in the map. ",
+        "bbox": [
+            187,
+            342,
+            482,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/b66b4754cb099da956908c73383ed827cabb9faacdeb4da46e20f01f8745c005.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            513,
+            116,
+            803,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(b) An agent exploring in a 3D environment perceives from a projective egocentric viewpoint. Our model learns to unproject learned task-oriented semantic embeddings of observations and to map the positions of relevant objects in a spatially structured (bird’s eye view) neural memory, where different objects in the same input image are stored in different map locations. Using the ego-motion of the agent, the map is updated by differentiable affine resampling at each step in the environment. ",
+        "bbox": [
+            511,
+            342,
+            812,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: Overview of the perception and mapping module (a) and EgoMap agent architecture (b). ",
+        "bbox": [
+            173,
+            479,
+            818,
+            494
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "could be at very different places in the environment. In contrast to Parisotto & Salakhutdinov (2018), our model will map these observations to their respective locations, and not to cells corresponding to the agent’s position, as shown in Figure 1a. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            609
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The model bears a certain structural resemblance with Bayesian occupancy grids (BOG), which have been used in mobile robotics for many years Moravec (1988); Rummelhard et al. (2015). As in BOGs, we perform inverse projections of observations and dynamically resample the map to take into account ego-motion. However, in contrast to BOGs, our model does not require a handcrafted observation model and it learns semantics directly from interactions with the environment through reward. It is fully differentiable and trained end-to-end with backpropagation of derivatives calculated with policy gradient methods. Our contributions are as follows: ",
+        "bbox": [
+            173,
+            617,
+            825,
+            715
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• To our knowledge, we present the first method using a differentiable SLAM-like mapping of visual features into a top-down egocentric feature map using projective geometry while at the same time training this representation using RL from reward.   \n• Our spatial map can be translated and rotated through a differentiable affine transform and read globally and through self-attention.   \nWe show that the mapping, spatial memory and self-attention can be learned end-to-end with RL, avoiding the cost of labelling trajectories from domain experts, auxiliary supervision or pre-training specific parts of the architecture.   \n• We demonstrate the improvement in performance over recurrent and spatial structured baselines without projective geometry.   \n• We illustrate the reasoning abilities of the agent by visualizing the content of the spatial memory and the self-attention process, tying it to the different objects and affordances related to the task.   \n• Experiments with noisy actions demonstrate the agent is robust to actions tolerances of up to $10 \\%$ . ",
+        "bbox": [
+            173,
+            722,
+            826,
+            902
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The code will be made publicly available on acceptance. ",
+        "bbox": [
+            173,
+            910,
+            544,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            343,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning — In recent years the field of Deep Reinforcement Learning (RL) has gained attention with successes on board games Silver et al. (2018) and Atari games Mnih et al. (2015). One key component was the application of deep neural networks Lecun et al. (1998) to frames from the environment or game board states. Recent works that have applied Deep RL for the control of an agent in 3D environments such as maze navigation are Mirowski et al. (2017) and Jaderberg et al. (2017) which explored the use of auxiliary tasks such as depth prediction, loop detection and reward prediction to accelerate learning. Meta RL approaches for 3D navigation have been applied by Wang et al. (2016) and Lample & Chaplot (2017) also accelerated the learning process in 3D environments by prediction of tailored game features. There has also been recent work in the use of street-view scenes to train an agent to navigate in city environments Mirowski et al. (2018). In order to infer long term dependencies and store pertinent information about the partially observable environment; network architectures typically incorporate recurrent memory such as Gated Recurrent Units Chung et al. (2015) or Long Short-Term Memory Hochreiter & Schmidhuber (1997). ",
+        "bbox": [
+            174,
+            145,
+            825,
+            325
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Differentiable memory — Differentiable memory such as Neural Turing Machines Graves et al. (2014) and Differential Neural Computers Graves et al. (2016) have shown promise where long term dependencies and storage are required. Neural Networks augmented with these memory structures have been shown to learn tasks such as copying, repeating and sorting. Some recent works for control in 2D and 3D environments have included structured memory-based architectures and mapping of observations. Neural SLAM Zhang et al. (2017) aims to incorporate a SLAM-like mapping module as part of the network architecture, but uses simulated sensor data rather than RGB observations from the environment, so the agent is unable to extract semantic meaning from its observations. The experimental results focus on 2D environments and the 3D results are limited. Playing Doom with SLAM augmented memory Bhatti et al. (2016) implements a non-differentiable inverse projective mapping with a fixed feature extractor based on Faster-RCNN Ren et al. (2015), pre-trained in a supervised manner. A downside of this approach is that the network does not learn to extract features pertinent to the task at hand as it is not trained end-to-end with RL. Fang et al. (2019) replace recurrent memory with a transformer (Vaswani et al. (2017)) attention distribution over previous observation embeddings, to highlight that recurrent architectures can struggle to capture long term dependencies. The downside is the storage of previous observations grows linearly with each step in the environment and the agent cannot chose to discard redundant information. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Grid cells — there is evidence that biological agents learn to encode spatial structure. Rats develop grid cells/neurons, which fire at different locations with different frequencies and phases, a discovery that led to the 2014 Nobel prize in medicine O’Keefe & Dostrovsky (1971); Hafting et al. (2005). A similar structure seems to emerge in artificial neural networks trained to localize themselves in a maze, discovered independently in 2018 by two different research groups Cueva & Wei (2018); Banino et al. (2018). ",
+        "bbox": [
+            173,
+            574,
+            825,
+            659
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Projective geometry and spatial memory — Our work encodes spatial structure directly into the agent as additional inductive bias. We argue that projective geometry is a strong law imposed on any vision system working from egocentric observations, justifying a fully differentiable model of perception. To our knowledge, we present the first method which uses projective geometry as inductive bias while at the same time learning spatial semantic features with RL from reward. ",
+        "bbox": [
+            174,
+            665,
+            823,
+            734
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The past decade has seen an influx of affordable depth sensors. This has led to a many works in the domain reconstruction of 3D environments, which can be incorporated into robotic systems. Seminal works in this field include Izadi et al. (2011) who performed 3D reconstruction scenes using a moving Kinect sensor and Henry et al. (2014) who created dense 3D maps using RGB-D cameras. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Neural Map Parisotto & Salakhutdinov (2018) implements a structured 2D differentiable memory which was tested in both egocentric and world reference frames, but does not map observations in a SLAM-like manner and instead stores a single feature vector at the agent’s current location. The agent’s position is also discretized to fixed cells and orientation quantized to four angles (North, South, East, West). A further downside is that the movement of the memory is fixed to discrete translations and the map is not rotated to the agent’s current viewpoint. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "MapNet Henriques & Vedaldi (2018) includes an inverse mapping of CNN features, is trained in a supervised manner to predict x,y position and rotation from human trajectories, but does not use the map for control in an environment. Visual Question Answering in Interactive Environments Gordon et al. (2018) creates semantic maps from 3D observations for planning and question answering and is applied in a discrete state space. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/cbdb9b845c85721c4ed5e0221006203ff8453c70ba676d4a47848721a80bb777.jpg",
+        "table_caption": [
+            "Table 1: Comparison of key features of related works "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=10 colspan=4>Semantic mapping Civera et al. (2011)         √Playing Doom with SLAM Bhati et al. (2016)  √Neural SLAM Zhang et al. (2017)Cog.Map Gupta et al. (2017)Semantic SLAM Tateno et al. (2017)IQA Gordon et al. (2018)MapNet Henriques &amp; Vedaldi (2018)           √Neural Map Parisotto &amp; Salakhutdinov (2018)MERLIN Wayne et al. (2018)Learning exploration policies Chen et al. (2019) √</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=2>v</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=2></td></tr><tr><td rowspan=1 colspan=3>Playing Doom with SLAM Bhati et al. (2016)  √</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-   √</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=2></td></tr><tr><td rowspan=2 colspan=2>Neural SLAM Zhang et al. (2017)Cog.Map Gupta et al. (2017)Semantic SLAM Tateno et al. (2017)</td><td rowspan=1 colspan=1>Neural SLAM Zhang et al. (2017)</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√  -</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=2 colspan=1>√</td><td rowspan=2 colspan=1></td><td rowspan=2 colspan=1>√</td><td rowspan=2 colspan=1>：</td><td rowspan=2 colspan=1>：</td><td rowspan=2 colspan=1></td></tr><tr><td rowspan=1 colspan=1>，√</td><td rowspan=1 colspan=1>√√</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>���</td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1>√  √</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-√</td><td rowspan=1 colspan=2>√-</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>v</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√  √</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1>=   √</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=4>EgoMap                                  √</td><td rowspan=1 colspan=1>√   √</td><td rowspan=1 colspan=1>-   √</td><td rowspan=1 colspan=2>√</td><td rowspan=1 colspan=1>√   √</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr></table>",
+        "bbox": [
+            171,
+            98,
+            851,
+            330
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            366,
+            826,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised Predictive Memory in a Goal-Directed Agent Wayne et al. (2018) incorporates a Differential Neural Computer in an RL agent’s architecture and was applied to simulated memorybased tasks. The architecture achieves improved performance over a typical LSTM Hochreiter & Schmidhuber (1997) based RL agent, but does not include spatial structure or projective mapping. In addition, visual features and neural memory are learned through the reconstruction of observations and actions, rather than for a specific task. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            498
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Cognitive Mapping and Planning for Visual Navigation Gupta et al. (2017) applies a differentiable mapping process on 3D viewpoints in a discrete grid-world, trained with imitation learning which provides supervision on expert trajectories. The downside of discretization is that affine sampling is trivial for rotations of 90-degree increments, and this motion is not representative of the real world. Their tasks are simple point-goal problems of up to 32 time-steps, whereas our work focused on complex multi-step objectives in a continuous state space. Their reliance on imitation learning highlights the challenge of training complex neural architectures with reward alone, particular on tasks with sparse reward such as the ones presented in this paper. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Learning Exploration Policies for Navigation Chen et al. (2019), do not learn a perception module but instead map the depth buffer to a 2D map to provide a map-based exploration reward. Our work learns the features that can be mapped so the agent can query not only occupancy, but task-related semantic content. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            680
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our work greatly exceeds the performance of Neural Map Parisotto & Salakhutdinov (2018), by embedding a differentiable inverse projective transform and a continuous egocentric map into the agent’s network architecture. The mapping of the environment is in the agent’s reference frame, including translation and rotation with a differentiable affine transform. We demonstrate stable training with reinforcement learning alone, over several challenging tasks and random initializations, and do not require the expense of acquiring expert trajectories. We detail the key similarities and differences with related work in table 1. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EGOMAP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            804,
+            284,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider partially observable Markov decision processes (POMDPs) Kaelbling et al. (1998) in 3D environments and extend recent Deep-RL models, which include a recurrent hidden layer to store pertinent long term information Mirowski et al. (2017); Jaderberg et al. (2017). In particular, RGBD observations $I _ { t }$ at time step $t$ are passed through a perception module extracting features $s _ { t }$ , which are used to update the recurrent state: ",
+        "bbox": [
+            174,
+            834,
+            825,
+            905
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f81905dbf9e704e735c3399b490b9eae94e91ca452152a463289e7d4f163c163.jpg",
+        "text": "$$\ns _ { t } = f _ { p } ( I _ { t } ; \\theta _ { p } ) \\qquad h _ { t } = f _ { r } ( h _ { t - 1 } , s _ { t } ; \\theta _ { r } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            909,
+            635,
+            926
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { p }$ is a convolutional neural network and $f _ { r }$ is a recurrent neural network in the Gated Recurrent Unit variant Chung et al. (2015). Gates and their equations have been omitted for simplicity. Above and in the rest of this paper, $\\theta _ { * }$ are trainable parameters, exact architectures are provided in the appendix. The controller outputs an estimate of the policy (the action distribution) and the value function given its hidden state: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3afdf7a8076b12ace6422351001be11eef5f71c55a7cbc11f38098e8183eff76.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\pi _ { t } = f _ { \\pi } ( h _ { t } ; \\theta _ { \\pi } ) } & { { } } & { v _ { t } = f _ { v } ( h _ { t } ; \\theta _ { v } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            175,
+            619,
+            191
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proposed model is motivated by the regularities which govern 3D physical environments. When an agent perceives an observation of the 3D world, it observes a 2D planar perspective projection of the world based on its current viewpoint. This projection is a well understood physical process, we aim to imbue the agent’s architecture with an inductive bias based on inverting the 3D to 2D planar projective process. This inverse mapping operation appears to be second nature to many organisms, with the initial step of depth estimation being well studied in the field of Physiology Frégnac et al. (2004). We believe that providing this mechanism implicitly in the agent’s architecture will improve its reasoning capabilities in new environments bypass a large part of the learning process. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            306
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The overall concept is that as the agent explores the environment, the perception module $f _ { p }$ produces a 2D feature map $s _ { t }$ , in which each feature vector represents a learned semantic representation of a small receptive field from the agent’s egocentric observation. While they are integrated into the flat (not spatially structured) recurrent hidden state $h _ { t }$ through function $f _ { r }$ (Equation 1), we propose its integration into a second tensor $M _ { t }$ , a top-down egocentric memory, which we call EgoMap. The feature vectors are mapped to their egocentric positions using the inverse projection matrix and depth estimates. This requires an agent with a calibrated camera (known intrinsic parameters), which is a soft constraint easily satisfied. The map can then be read by the agent in two ways: a global convolutional read operation and a self-attention operation. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            438
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Formally, let the agent’s position and angle at time $t$ be $( x _ { t } , y _ { t } )$ and $\\phi _ { t }$ respectively, $M _ { t }$ is the current EgoMap. $s _ { t }$ are the feature vectors extracted by the perception module, $D _ { t }$ are the depth buffer values. The change in agent position and orientation in the agent’s frame of reference between time-step $t$ and $t - 1$ are $( d x _ { t } , d y _ { t } , d \\phi _ { t } )$ . ",
+        "bbox": [
+            173,
+            443,
+            825,
+            500
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There are three key steps to the operation of the EgoMap: ",
+        "bbox": [
+            174,
+            500,
+            552,
+            513
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. Transform the map to the agent’s egocentric frame of reference: ",
+        "bbox": [
+            174,
+            520,
+            611,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43d2056911c05cf16ff02796107cbd6ce93295a8850601c9968bbbdcc466bd46.jpg",
+        "text": "$$\n\\hat { M } _ { t } = \\mathrm { A f f i n e } ( M _ { t - 1 } , d x _ { t } , d y _ { t } , d \\phi _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            536,
+            625,
+            555
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2. Update the map to include new observations: ",
+        "bbox": [
+            176,
+            558,
+            490,
+            571
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4be6315f79219c332f3ad062451d193943b60e264cc4b9b9d551b231f43d110.jpg",
+        "text": "$$\n\\begin{array} { r } { \\tilde { M } _ { t } = \\mathrm { I n v e r s e P r o j e c t } ( s _ { t } , D _ { t } ) \\qquad M _ { t } ^ { \\prime } = \\mathrm { C o m b i n e } ( \\hat { M } _ { t } , \\tilde { M } _ { t } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            573,
+            704,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3. Perform a global read and attention based read, the outputs of which are fed into the policy and value heads: ",
+        "bbox": [
+            171,
+            595,
+            828,
+            623
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff2763f2531f16fc632cefe1d80ad243a91835114328934b27e41377b84c0c9d.jpg",
+        "text": "$$\nr _ { t } = { \\mathrm { R e a d } } ( M _ { t } ^ { \\prime } ) \\qquad c _ { t } = { \\mathrm { C o n t e x t } } ( M _ { t } ^ { \\prime } , s _ { t } , r _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            626,
+            658,
+            643
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "These three operations will be further detailed below in individual subsections. Projective mapping and spatially structured memory should augment the agent’s performance where spatial reasoning and long term recollection are required. On simpler tasks the network can still perform as well as the baseline, assuming the extra parameters do not cause further instability in the RL training process. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Affine transform — At each time-step we wish to translate and rotate the map into the agent’s frame of reference, this is achieved with a differentiable affine transform, popularized by the well known Spatial Transformer Networks Jaderberg et al. (2015). Relying on the simulator to be an oracle and provide the change in position $( d x , d y )$ and orientation $d \\phi$ , we convert the deltas to the agent’s egocentric frame of reference and transform the map with a differentiable affine transform. The effect of noise on the change in position on the agent’s performance is analysed in the experimental section. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            806
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inverse projective mapping — We take the agent’s current observation, extract relevant semantic embeddings and map them from a 2D planar projection to their 3D positions in an egocentric frame of reference. At each time-step, the agent’s egocentric observation is encoded by the perception module (a convolutional neural network) to produce feature vectors, this step is a mapping from $R ^ { 4 \\times 6 4 \\times 1 1 2 }  R ^ { 1 6 \\times 4 \\times 1 0 }$ . Given the inverse camera projection matrix and the depth buffer provided by the simulator, we can compute the approximate location of the features in the agent’s egocentric frame of reference. As the mapping is a many to one operation, several features can be mapped to the same location. Features that share the same spatial location are averaged element-wise. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The newly mapped features must then be combined with the translated map from the previous time-step. We found that the use of a momentum hyper-parameter, $\\alpha$ , enabled a smooth blending of new and previously observed features. We use an $\\alpha$ value of 0.9 for the tests presented in the paper. We ensured that the blending only occurs where the locations of new projected features and the map from the previous time-step are co-located, this criterion is detailed in Equation 6. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0e599774c7b8c4c090c826a07c84a4e7bc57deee7f5e7d5a09417c9093b1587.jpg",
+        "text": "$$\n\\begin{array} { r } { M _ { t } ^ { \\prime ( x , y ) } = \\eta \\hat { M _ { t } } ^ { ( x , y ) } + ( 1 - \\eta ) \\tilde { M } _ { t } ^ { ( x , y ) } } \\\\ { \\eta = \\left\\{ \\begin{array} { l l } { 1 . 0 , } & { \\mathrm { i f ~ } \\tilde { M } _ { t } ^ { ( x , y ) } = 0 \\& \\hat { M _ { t } } ^ { ( x , y ) } \\neq 0 } \\\\ { 0 . 0 , } & { \\mathrm { i f ~ } \\tilde { M _ { t } } ^ { ( x , y ) } \\neq 0 \\& \\hat { M } _ { t } ^ { ( x , y ) } = 0 } \\\\ { \\alpha , } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            176,
+            642,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sampling from a global map — A naive approach to the storage and transformation of the egocentric feature map would be to apply an affine transformation to the map at each time-step. A fundamental downside of applying repeated affine transforms is that at each step a bilinear interpolation operation is applied, which causes smearing and degradation of the features in the map. We mitigated this issue by storing the map in a global reference frame and mapping the agent’s observations to the global reference frame. For the read operation an offline affine transform is applied. For further details see the appendix B ",
+        "bbox": [
+            173,
+            267,
+            825,
+            364
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Read operations — We wanted the agent to be able to summarize the whole spatial map and also selectively query for pertinent information. This was achieved by incorporating two types of read operation into the agent’s architecture, a Global Read operation and a Self-attention Read. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            414
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The global read operation is a CNN that takes as input the egocentric map and outputs a 32- dimensional feature vector that summarizes the map’s contents. The output of the global read is concatenated with the visual CNN output. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To query for relevant features in the map, the agent’s controller network can output a query vector $q _ { t }$ , the network then compares this vector to each location in the map with a cosine similarity function in order to produce scores, which are the same width and height as the map. The scores are normalized with a softmax operation to produce a soft-attention in the lines of Bahdanau et al. (2014) and used to compute a weighted average of the map, allowing the agent to selectively query and focus on parts of the map. This querying mechanism was used in both the Neural Map Parisotto & Salakhutdinov (2018) and MERLIN Wayne et al. (2018) RL agents. We made the following improvements: Attention Temperature and Query Position. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1127b82299dbb4fb4e55965c4adb7b892f3b67bf0a8c330e45967f97cb94442b.jpg",
+        "text": "$$\n\\sigma ( x ) _ { i } = \\frac { e ^ { \\beta x _ { i } } } { \\sum e ^ { \\beta x _ { j } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            579,
+            558,
+            614
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Query Position: A limitation of self-attention is that the agent can query what it has observed but not where it had observed it. To improve the spatial reasoning performance of the agent we augmented the neural memory with two fixed additional coordinate planes representing the x,y egocentric coordinate system normalized to $( - 1 . 0 , 1 . 0 )$ , as introduced for segmentation in Liang et al. (2018). The agent still queries based on the features in the map, but the returned context vector includes two extra scalar quantities which are the weighted averages of the x,y planes. The impacts of these additions are discussed and quantified in the ablation study, in Section 4. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Attention Temperature: To provide the agent with the ability to learn to modify the attention distribution, the query includes an additional learnable temperature parameter, $\\beta$ , which can adjust the softmax distribution detailed in Equation 7. This parameter can vary query by query and is constrained to be one or greater by a Oneplus function. The use of temperature in neural memory architectures was first introduced in Neural Turing Machines Graves et al. (2014). ",
+        "bbox": [
+            174,
+            718,
+            825,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            326,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The EgoMap and baseline architectures were evaluated on four challenging 3D scenarios, which require navigation and different levels of spatial memory. The scenarios are taken from Beeching et al. (2019) who extended the 3D ViZDoom environment Kempka et al. (2017) with various scenarios that are partially observable, require memory, spatial understanding, have long horizons and sparse rewards. Whilst more visually realistic simulators are available such as Gibson Xia et al. (2018), Matterport Anderson et al. (2018), Home Brodeur et al. (2018) and Habitat Manolis Savva\\* et al. ",
+        "bbox": [
+            173,
+            839,
+            826,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8a204802371c2de350a883d03b60fa4ade9cc071cd3c8430a9c929319c02031e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"8\">Scenario</td></tr><tr><td colspan=\"2\">4 item</td><td colspan=\"2\">6item</td><td colspan=\"2\">Find and Return</td><td colspan=\"2\">Labyrinth</td></tr><tr><td>Agent</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>Random</td><td>-0.179</td><td>-0.206</td><td>-0.21</td><td>-0.21</td><td>-0.21</td><td>-0.21</td><td>-0.115</td><td>-0.086</td></tr><tr><td>Baseline</td><td>2.341 ± 0.026</td><td>2.266 ± 0.035</td><td>2.855 ± 0.164</td><td>2.545 ± 0.226</td><td>0.661± 0.003</td><td>0.633 ± 0.027</td><td>0.73 ±0.02</td><td>0.694 ± 0.009</td></tr><tr><td>Neural Map</td><td>2.339 ±0.038</td><td>2.223 ± 0.040</td><td>2.750 ± 0.062</td><td>2.465 ± 0.034</td><td>0.825 ± 0.070</td><td>0.723 ± 0.026</td><td>0.769 ± 0.042</td><td>0.706 ± 0.018</td></tr><tr><td>EgoMap</td><td>2.398 ± 0.014</td><td>2.291 ± 0.021</td><td>3.214 ± 0.007</td><td>2.801 ± 0.048</td><td>0.893 ±0.007</td><td>0.848 ± 0.017</td><td>0.753 ± 0.002</td><td>0.732 ± 0.016</td></tr><tr><td>Optimum (Upper Bound)</td><td>2.5</td><td>2.5</td><td>3.5</td><td>3.5</td><td>1.0</td><td>1.0</td><td>1.0</td><td>1.0</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            823,
+            183
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Results of the baseline and EgoMap architectures trained on four scenarios for $1 . 2 \\mathrm { ~ B ~ }$ environment steps. We show the mean and std. of the final agent performance, evaluated for three independent experiments on a held-out testing set of scenario configurations. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            236
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(2019), the tasks available are simple point-goal tasks which do not require long term memory and recollection. We target the following three tasks: ",
+        "bbox": [
+            173,
+            257,
+            821,
+            284
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Labyrinth: The agent must find the exit in the fastest time possible, the reward is a sparse positive reward for finding the exit. This tests an agent’s ability to explore in an efficient manner. ",
+        "bbox": [
+            173,
+            284,
+            821,
+            311
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ordered k-item: An agent must find $k$ objects in a fixed order. It tests three aspects of an agent: its ability to explore the environment efficiently, the ability to learn to collect items in a predefined order and its ability to store as part of its hidden state where items were located so they can be retrieved in the correct order. We tested two versions of this scenario with 4-items or 6-items. ",
+        "bbox": [
+            174,
+            318,
+            825,
+            373
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Find and return: The agent starts next to a green totem, must explore the environment to find a red totem and then return to the starting point. This is our implementation of “Minotaur\" scenario from Parisotto & Salakhutdinov (2018). The scenario tests an agent’s ability to navigate and retain information over long time periods. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            436
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All the tasks require different levels of spatial memory and reasoning. For example, if an agent observes an item out of order it can store the item’s location in its spatial memory and navigate back to it later. We observe that scenarios that require more spatial reasoning, long term planning and recollection are where the agent achieves the greatest improvement in performance. In all scenarios there is a small negative reward for each time-step to encourage the agent to complete the task quickly. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            513
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experimental strategy and generalization to unseen environments — Many configurations of each scenario were created through procedural generation and partitioned into separated training and testing sets of size 256 and 64 respectively for each scenario type. Although the task in a scenario is fixed, we vary the locations of the walls, item locations, and start and end points; thus we ensure a diverse range of possible scenario configurations. A limited hyper-parameter sweep was undertaken with the baseline architecture to select the hyper-parameters, which were fixed for both the baseline, Neural Map and EgoMap agents. Three independent experiments were conducted per task to evaluate the algorithmic stability of the training process. To avoid information asymmetry, we provide the baseline agent with $d x , d y , s i n ( d \\theta ) , c o s ( d \\theta )$ concatenated with its visual features. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            646
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training Details — The model parameters were optimized with an on-policy, policy gradient algorithm; batched Advantage Actor Critic (A2C) Mnih et al. (2016), we used the popular PyTorch Paszke et al. (2017) implementation of A2C Kostrikov (2018). We sampled trajectories from 16 parallel agents and updated every 128 steps in the environment with discounted returns bootstrapped from value estimates for non-terminal states. The gamma factor was 0.99, the entropy weight was 0.001, the RMSProp Tieleman & Hinton (2012) optimizer was used with a learning rate of 7e-4. The EgoMap agent map size was $1 6 \\times 2 4 \\times 2 4$ with a grid sampling chosen to cover the environment size with a $20 \\%$ padding. The agent’s policy was updated over 1.2B environment steps, with a frame skip of 4. Training took 36 hours for the baseline and 8 days for the EgoMap, on 4 Xeon E5-2640v3 CPUs, with 32GB of memory and one NVIDIA GK210 GPU. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results — Results from the baseline and EgoMap policies evaluated on the 4 scenarios are shown in table 2, all tasks benefit from the inclusion of inverse projective mapping and spatial memory in the agent’s network architecture, with the largest improvement on the Find and Return scenario. We postulate that the greater improvement in performance is due to two factors; firstly this scenario always requires spatial memory as the agent must return to its starting point and secondly the objects in this scenario are larger and occupy more space in the map. We also compared to the state of the art in spatially structured neural memory, Neural Map Parisotto & Salakhutdinov (2018). Figure 2 shows agent training curves for the recurrent baseline, Neural Map and EgoMap, on the Find and Return test set configurations. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f36aba87008ce43fdbf7d8e5295e4684e09a6d0c4afa3227be420a4caea2e29d.jpg",
+        "image_caption": [
+            "Figure 2: Left: Agent performance on unseen test configurations of the Find and Return scenario. Right: Ablation study on the Find and Return scenario conducted after 800M environment steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            517,
+            262
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3decf1f49c2964ea70bce8e7c89c3727fdf8dfec62918e2c375a20706c33d1cc.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ablation</td><td>Train</td><td>Test</td></tr><tr><td>Baseline</td><td>0.668 ± 0.028</td><td>0.662 ± 0.036</td></tr><tr><td>No global read</td><td>0.787 ± 0.007</td><td>0.771 ± 0.029</td></tr><tr><td>No query</td><td>0.838 ± 0.003</td><td>0.811 ± 0.013</td></tr><tr><td>No query temperature</td><td>0.845 ± 0.014</td><td>0.815 ± 0.019</td></tr><tr><td>No query position</td><td>0.839 ± 0.007</td><td>0.814 ± 0.008</td></tr><tr><td>EgoMap</td><td>0.847 ± 0.011</td><td>0.814 ± 0.017</td></tr><tr><td>EgoMap (L1 query)</td><td>0.851 ± 0.014</td><td>0.828 ± 0.011</td></tr></table>",
+        "bbox": [
+            531,
+            137,
+            825,
+            228
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation study — An ablation study was carried out on the improvements made by the EgoMap architecture. We were interested to see the influence of key options such as the global and attentionbased reads, the similarity function used when querying the map, the learnable temperature parameter and the incorporation of location-based querying. The Cartesian product of these options is large and it was not feasible to test them all, we therefore decided to selectively switch off key options to understand which aspects contribute to the improvement in performance. The results of the ablation study are shown in Table 2. Both the global and self-attention reads provide large improvements in performance over the baseline recurrent agent. The position-based query provides a small improvement. A comparison of the similarity metric of the attention mechanism highlights the L1-similarity achieved higher performance than cosine. A qualitative analysis of the self-attention mechanism is shown in the next section. ",
+        "bbox": [
+            173,
+            308,
+            826,
+            459
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            290,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Noisy Actions — One common criticism of agents trained in simulation is that the agent can query its environment for information that would not be readily available in the real world. In the case of EgoMap, the agent is trained with ground truth ego-motion measurements. Real-world robots have noisy estimates of ego-motion due to the tolerances of available hardware. We performed an analysis of the EgoMap agent trained in the presence of a noisy oracle, which adds noise to the ego-motion measurement. Noise is drawn from a normal distribution centred at one and is multiplied by the agent’s ground-truth motion, the effect of the noise is cumulative but unbiased. Tests were conducted with standard deviations of up to 0.2 which is a tolerance of more than $20 \\%$ on the agent’s ego-motion measurements, results are shown in Figure 3. We observed retain the performance increase over the baseline for up to $10 \\%$ of noisy actions, the performance degrades to that of the baseline agent. ",
+        "bbox": [
+            173,
+            537,
+            825,
+            678
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/99151436a7aa5a697d24a15b8335a12a41c7d053b33af56094b9f20e2bce46aa.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Noise std.</td><td>Averagereturn</td></tr><tr><td>0.00</td><td>0.702 ± 0.026</td></tr><tr><td>0.02</td><td>0.686 ± 0.027</td></tr><tr><td>0.04</td><td>0.669 ± 0.031</td></tr><tr><td>0.06</td><td>0.623 ± 0.018</td></tr><tr><td>0.08</td><td>0.585 ± 0.017</td></tr><tr><td>0.10</td><td>0.568 ± 0.023</td></tr><tr><td>0.12</td><td>0.575 ± 0.020</td></tr><tr><td>0.14</td><td>0.578 ± 0.023</td></tr><tr><td>0.16</td><td>0.546 ± 0.017</td></tr><tr><td>0.20</td><td>0.537 ± 0.031</td></tr><tr><td>Baseline</td><td>0.527 士 0.047</td></tr></table>",
+        "bbox": [
+            619,
+            683,
+            825,
+            845
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f32d64eb6182acaadf8d81589d85850e9d6e48f7bc3b60dd83338f1e14d0dd41.jpg",
+        "image_caption": [
+            "Figure 3: Test set performance of the EgoMap agent during training with noisy ego-motion measurements, conducted for $3 2 0 \\mathbf { M }$ environment frames. Shown are test set performance during training (left), final performance for a range of noise values (centre) which are tabulated (right). We retain an improvement in performance over the baseline agent for noisy actions of up to $10 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            680,
+            612,
+            851
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/070e430f145b92900914e37bc2f254e40aa1e7fec6508fa31ac0cfc7b18f3e6e.jpg",
+        "image_caption": [
+            "Figure 4: Analysis of the EgoMap for key steps (different rows) during an episode from the Ordered 6-item and Find and Return scenarios. Within each sub-figure: Left column - RGB observations, central column - the three largest PCA components of features mapped in the spatially structured memory, right - attention heat map (result of the query) and x,y query position vector. We observe that the agent maps and stores features from key objects and attends to them when they are pertinent to the current stage of the task. For example, for the left figure on the first row at time-step 5 the blue spherical object, which is ordered 4 of 6, is mapped into the agent’s spatial memory. The agent explores the environment collecting the items in order, it collects item 3 of 6 between time-step 105 and 108, shown on rows 2 and 3. As soon as the agent has collected item 3 it queries its internal memory for the presence of item 4, which is shown by the attention distribution on rows 3 and 4. On the last row, time-step 140, the agent observes the item and no longer attempts to query for it, as the item is in the agent’s field of view. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            116,
+            815,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Visualization — The EgoMap architecture is highly interpretable and provides insights about how the agent reasons in 3D environments. In Figures 4a and 4b we show analysis of the spatially structured memory and how the agent has learned to query and self-attend to recall pertinent information. The Figures show key steps during an episode in the Ordered 6-item and Find and Return scenarios, including the first three principal components of a dimensionality reduction of the 16-dimensional EgoMap, the attention distribution and the vector returned from position queries. Refer to the caption for further details. The agent is seen to attend to key objects at certain phases of the task, in the Ordered $6$ -item scenario the agent attends the next item in the sequence and in the Find and Return scenario the agent attends to the green totem located at the start/return point once it has found the intermediate goal. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            683,
+            318,
+            698
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have presented EgoMap, an egocentric spatially structured neural memory that augments an RL agent’s performance in 3D navigation, spatial reasoning and control tasks. EgoMap includes a differentiable inverse projective transform that maps learned task-specific semantic embeddings of agent observations to their world positions. We have shown that through the use of global and self-attentive read mechanisms an agent can learn to focus on important features from the environment. We demonstrate that an RL agent can benefit from spatial memory, particularly in 3D scenarios with sparse rewards that require localization and memorization of objects. EgoMap out-performs existing state of the art baselines, including Neural Map, a spatial memory architecture. The increase in performance compared to Neural Map is due to two aspects. 1) The differential projective transform maps what the objects are to where they are in the map, which allows for direct localization with attention queries and global reads. In comparison, Neural Map writes what the agent observes to where the agent is on the map, this means that the same object viewed from two different directions will be written to two different locations on the map, which leads to poorer localization of the object. 2) Neural Map splits the map to four 90-degree angles, which alleviates the blurring highlighted in the appendix, our novel solution to this issue stores a single unified map in an allocentric frame of reference and performs an offline egocentric read, which allows an agent to act in states spaces where the angle is continuous, without the need to quantize the agent’s angle to 90-degree increments. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have shown, with detailed analysis, how the agent has learned to interact with its structured internal memory with self-attention. The ablation study has shown that the agent benefits from both the global and self-attention operations and that these can be augmented with temperature, position querying and other similarity metrics. We have demonstrated that the EgoMap architecture is robust to actions with tolerances of up to $10 \\%$ . Future work in this area of research would be to apply the mapping and memory architecture in more realistic-looking domains and aim to incorporate both dynamic and static objects into the agent’s network architecture and update mechanisms. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            257,
+            285,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Anderson, Qi Wu, Damien Teney, Jake Bruce, Mark Johnson, Niko Sünderhauf, Ian Reid, Stephen Gould, and Anton den Hengel. Vision-and-language navigation: Interpreting visuallygrounded navigation instructions in real environments. In CVPR, 2018. ",
+        "bbox": [
+            176,
+            281,
+            825,
+            323
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014. ",
+        "bbox": [
+            176,
+            332,
+            821,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Banino, C. Barry, B. Uria, C. Blundell, T. Lillicrap, P. Mirowski, A. Pritzel, M.J. Chadwick, T. Degris, J. Modayil, G. Wayne, H. Soyer, F. Viola, B. Zhang, R. Goroshin, N. Rabinowitz, R. Pascanu, C. Beattie, S. Petersen, A. Sadik, S. Gaffney, H. King, K. Kavukcuoglu, D. Hassabis, R. Hadsell, and D. Kumaran. Vector-based navigation using grid-like representations in artificial agents. Nature, 557, 2018. ",
+        "bbox": [
+            174,
+            369,
+            826,
+            439
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Edward Beeching, Christian Wolf, Jilles Dibangoye, and Olivier Simonin. Deep reinforcement learning on a budget: 3d control and reasoning without a supercomputer. CoRR, abs/1904.01806, 2019. URL http://arxiv.org/abs/1904.01806. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            492
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shehroze Bhatti, Alban Desmaison, Ondrej Miksik, Nantas Nardelli, N. Siddharth, and Philip H. S. Torr. Playing doom with slam-augmented deep reinforcement learning. arxiv preprint 1612.00380, 2016. ",
+        "bbox": [
+            176,
+            501,
+            825,
+            542
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Simon Brodeur, Ethan Perez, Ankesh Anand, Florian Golemo, Luca Celotti, Florian Strub, Jean Rouat, Hugo Larochelle, and Aaron Courville. HoME: a Household Multimodal Environment. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            551,
+            823,
+            594
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tao Chen, Saurabh Gupta, and Abhinav Gupta. Learning exploration policies for navigation. In ICLR, 03 2019. ",
+        "bbox": [
+            168,
+            603,
+            825,
+            632
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio. Gated Feedback Recurrent Neural Networks. In ICML, 2015. ",
+        "bbox": [
+            169,
+            640,
+            825,
+            670
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. Civera, D. Galvez-Lopez, L. Riazuelo, J. D. Tardós, and J. M. M. Montiel. Towards semantic SLAM using a monocular camera. In IROS, 2011. ",
+        "bbox": [
+            173,
+            679,
+            823,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "C.J. Cueva and X.-X. Wei. Emergence of grid-like representations by training recurrent neural networks to perform spatial localization. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            717,
+            823,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kuan Fang, Alexander Toshev, Li Fei-Fei, and Silvio Savarese. Scene memory transformer for embodied agents in long-horizon tasks. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019. ",
+        "bbox": [
+            176,
+            753,
+            825,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yves Frégnac, Alice René, Jean Baptiste Durand, and Yves Trotter. Brain encoding and representation of 3d-space using different senses, in different species. Journal of physiology, Paris, 98(1-3):1, 2004. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel Gordon, Aniruddha Kembhavi, Mohammad Rastegari, Joseph Redmon, Dieter Fox, and Ali Farhadi. Iqa: Visual question answering in interactive environments. In CVPR. IEEE, 2018. ",
+        "bbox": [
+            176,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio Gómez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, et al. ´ Hybrid computing using a neural network with dynamic external memory. Nature, 538(7626):471, 2016. ",
+        "bbox": [
+            174,
+            103,
+            826,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "S. Gupta, J. Davidson, S. Levine, R. Sukthankar, and J. Malik. Cognitive mapping and planning for visual navigation. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7272–7281, July 2017. doi: 10.1109/CVPR.2017.769. ",
+        "bbox": [
+            176,
+            169,
+            823,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Torkel Hafting, Marianne Fyhn, Sturla Molden, May-Britt Moser, and Edvard Moser. Microstructure of a spatial map in the entorhinal cortex. Nature, 436:801–6, 09 2005. doi: 10.1038/nature03721. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J. Henriques and A. Vedaldi. Mapnet: An allocentric spatial memory for mapping environments. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            257,
+            823,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter Henry, Michael Krainin, Evan Herbst, Xiaofeng Ren, and Dieter Fox. Rgb-d mapping: Using depth cameras for dense 3d modeling of indoor environments. In Experimental robotics, pp. 477–491. Springer, 2014. ",
+        "bbox": [
+            173,
+            295,
+            828,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Long Short-Term Memory. Neural Computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            347,
+            823,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shahram Izadi, David Kim, Otmar Hilliges, David Molyneaux, Richard Newcombe, Pushmeet Kohli, Jamie Shotton, Steve Hodges, Dustin Freeman, Andrew Davison, et al. Kinectfusion: real-time 3d reconstruction and interaction using a moving depth camera. In Proceedings of the 24th annual ACM symposium on User interface software and technology, pp. 559–568. ACM, 2011. ",
+        "bbox": [
+            173,
+            383,
+            826,
+            441
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, and koray kavukcuoglu. Spatial transformer networks. In NIPS. 2015. ",
+        "bbox": [
+            173,
+            449,
+            823,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z. Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            487,
+            823,
+            530
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Leslie Pack Kaelbling, Michael L Littman, and Anthony R Cassandra. Planning and acting in partially observable stochastic domains. Artificial intelligence, 101(1-2):99–134, 1998. ",
+        "bbox": [
+            169,
+            537,
+            823,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michal Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. ViZDoom: A Doom-based AI research platform for visual reinforcement learning. IEEE Conference on Computatonal Intelligence and Games, CIG, 2017. ISSN 23254289. ",
+        "bbox": [
+            176,
+            577,
+            823,
+            619
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Kostrikov. Pytorch implementations of reinforcement learning algorithms. https://github. com/ikostrikov/pytorch-a2c-ppo-acktr, 2018. ",
+        "bbox": [
+            171,
+            628,
+            825,
+            656
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample and Devendra Singh Chaplot. Playing FPS games with deep reinforcement learning. In AAAI, 2017. ",
+        "bbox": [
+            173,
+            665,
+            823,
+            694
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann Lecun, L Eon Bottou, Yoshua Bengio, and Patrick Haaner. Gradient-Based Learning Applied to Document Recognition. Proceedings of the IEEE, 86(11):2278 – 2324, 1998. ",
+        "bbox": [
+            173,
+            703,
+            823,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "X. Liang, Y. Wei, X. Shen, J. Yang, L. Lin, and S. Yan. Proposal-Free Network for Instance-Level Object Segmentation . IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(12), 2018. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Manolis Savva\\*, Abhishek Kadian\\*, Oleksandr Maksymets\\*, and Dhruv Batra. Habitat: A platform for embodied ai research. arXiv, 2019. ",
+        "bbox": [
+            171,
+            791,
+            825,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J. Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, Dharshan Kumaran, and Raia Hadsell. Learning to Navigate in Complex Environments. In ICLR, 2017. ",
+        "bbox": [
+            178,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Piotr Mirowski, Matthew Koichi Grimes, Mateusz Malinowski, Karl Moritz Hermann, Keith Anderson, Denis Teplyashin, Karen Simonyan, Koray Kavukcuoglu, Andrew Zisserman, and Raia Hadsell. Learning to Navigate in Cities Without a Map. In NeurIPS2018, 2018. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540), 2015. ",
+        "bbox": [
+            176,
+            103,
+            826,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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 ICML, 2016. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "H. Moravec. Sensor fusion in certainty grids for mobile robots. AI magazine, 9(2), 1988. ",
+        "bbox": [
+            173,
+            234,
+            756,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. O’Keefe and J. Dostrovsky. The hippocampus as a spatial map. preliminary evidence from unit activity in the freely-moving rat. Brain Research, 34(1):171 – 175, 1971. ",
+        "bbox": [
+            173,
+            257,
+            821,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Emilio Parisotto and Ruslan Salakhutdinov. Neural map: Structured memory for deep reinforcement learning. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            295,
+            823,
+            324
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In NIPS-W, 2017. ",
+        "bbox": [
+            174,
+            333,
+            826,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), NIPS. 2015. ",
+        "bbox": [
+            174,
+            385,
+            826,
+            428
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "L. Rummelhard, A. Nègre, and C. Laugier. Conditional Monte Carlo Dense Occupancy Tracker. In International Conference on Intelligent Transportation Systems, 2015. ",
+        "bbox": [
+            173,
+            436,
+            825,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, Timothy Lillicrap, Karen Simonyan, and Demis Hassabis. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419):1140–1144, 2018. ",
+        "bbox": [
+            173,
+            474,
+            826,
+            531
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Keisuke Tateno, Federico Tombari, Iro Laina, and Nassir Navab. Cnn-slam: Real-time dense monocular slam with learned depth prediction. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            540,
+            823,
+            569
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "T. Tieleman and G. Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012. ",
+        "bbox": [
+            169,
+            577,
+            823,
+            607
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. 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. 5998–6008. Curran Associates, Inc., 2017. URL http: //papers.nips.cc/paper/7181-attention-is-all-you-need.pdf. ",
+        "bbox": [
+            176,
+            614,
+            826,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jane X. Wang, Zeb Kurth-Nelson, Dhruva Tirumala, Hubert Soyer, Joel Z. Leibo, Rémi Munos, Charles Blundell, Dharshan Kumaran, and Matthew Botvinick. Learning to reinforcement learn. arxiv pre-print 1611.05763, 2016. ",
+        "bbox": [
+            173,
+            694,
+            826,
+            738
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Greg Wayne, Chia-Chun Hung, David Amos, Mehdi Mirza, Arun Ahuja, Agnieszka GrabskaBarwinska, Jack W. Rae, Piotr W. Mirowski, Joel Z. Leibo, Adam Santoro, Mevlana Gemici, Malcolm Reynolds, Tim Harley, Josh Abramson, Shakir Mohamed, Danilo Jimenez Rezende, David Saxton, Adam Cain, Chloe Hillier, David Silver, Koray Kavukcuoglu, Matthew Botvinick, Demis Hassabis, and Timothy P. Lillicrap. Unsupervised predictive memory in a goal-directed agent. arxiv preprint 1803.10760, 2018. ",
+        "bbox": [
+            174,
+            746,
+            826,
+            830
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Fei Xia, Amir R. Zamir, Zhi-Yang He, Alexander Sax, Jitendra Malik, and Silvio Savarese. Gibson env: real-world perception for embodied agents. In CVPR, 2018. ",
+        "bbox": [
+            168,
+            839,
+            823,
+            868
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jingwei Zhang, Lei Tai, Joschka Boedecker, Wolfram Burgard, and Ming Liu. Neural SLAM. arxiv preprint 1706.09520, 2017. ",
+        "bbox": [
+            171,
+            877,
+            823,
+            905
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX B AFFINE TRANSFORM ",
+        "bbox": [
+            173,
+            102,
+            382,
+            154
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A naive implementation of the repeated affine transforms leads to smearing of features Figure 5 demonstrates the degradation of features on synthetic RGB images with repeated rotations and translations. We should how storing the features in an allocentric frame of reference and performing offline transforms for read operations can greatly mitigate this issue. ",
+        "bbox": [
+            174,
+            170,
+            825,
+            226
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/460fd06d85f9375d8f303e44bddc5d0af1fc824f1f6022a654fb9e8613f45cbe.jpg",
+        "image_caption": [
+            "Figure 5: A synthetic 3-channel top down map. Rotations of two degrees per time-step with naive and global reference frame (rows 1 & 2) shown over 180 time-steps. Translations with naive and global reference frame (rows 3 & 4) shown over 180 time-steps. Distinct degradation of the map features are observed by time-step 100 and features are barely visible after 180 steps, leading to poor localization with self-attention queries. In tasks that span up to 500 time-steps, the blurring of features could have greatly restricted the EgoMap agent’s performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            241,
+            818,
+            441
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            352,
+            614
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To encourage reproducibility, we detail the exact architectures of the agents. Figure 6 shows an overview. ",
+        "bbox": [
+            174,
+            631,
+            823,
+            660
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Baseline Model — is comprised of the following: Perception Module $f _ { p }$ : A 3 layer CNN with kernel sizes of 8,4,3, strides of 4,2,1, no padding and filter sizes of 16,32,16, respectively and ReLU activation. $f _ { p }$ is a mapping from an RGBD input observation of $R ^ { 4 \\times 6 4 \\times 1 1 2 }  \\bar { R } ^ { 1 6 \\times 4 \\times 1 \\bar { 0 } }$ . Recurrent Module $f _ { r }$ : A FC layer reduces the output of $f _ { p }$ from 640 values to a vector of size 128 and includes a ReLU activation; we then use a GRU layer with 128 hidden units. Policy and Value Heads $f _ { \\pi }$ & $f _ { v }$ : These layers receive as input the output of $f _ { r }$ . The policy layer is a FC layer with 5 output units corresponding to the 5 discrete actions available to the agent (through a softmax activation). The value layer is a FC layer with one output unit. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            777
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "EgoMap Model — is comprised of the following: Perception Module $f _ { p }$ : The same as the baseline architecture, apart from that the mapping operation is applied before the final ReLU activation function. EgoMap Global Read Module: A 3 layer CNN with kernel sizes of 3,4,4, strides of 1,2,2 and filter sizes of 16,16,16 respectively, and no padding. Followed by two linear layers of 256 and 32 hidden units, and ReLU activations, apart from the last which was tanh. Recurrent Module $f _ { r }$ : The output of $f _ { p }$ and the global read module were concatenated to form a vector of size 672 and fed into a FC layer later with 128 output units. The recurrent module was a GRU with 128 units. Self-Attention Read Head: The query head is a linear layer with 17 output units, 16 for the calculation of the EgoMap similarity scores and one for the $\\beta$ temperature parameter. The query head returns a vector of size 18 which includes two more scalar values for the average position of the query. Policy and Value Heads $f _ { \\pi }$ & $f _ { v }$ : Are the same as the baseline but their input is the concatenation of the output of the $f _ { r }$ and the attention head. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/82404967326e9fa7597a5ada938ba17dc284bbcb5af6e650bc39c1ef3daed0b8.jpg",
+        "image_caption": [
+            "Figure 6: The baseline agent architecture (light blue) augmented with the EgoMap architecture (green), the agent’s hidden state is $h _ { t }$ and the spatially structured neural memory $M _ { t }$ . We rely on an oracle (the simulator) to provide the depth buffer $D _ { t }$ and the agent deltas $( d x , d y , d \\theta )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            302,
+            146,
+            692,
+            287
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D READ MECHANISMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            390,
+            379,
+            406
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In figure 7 we provide further details of the operation of the global read, context read and xy-querying. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            436
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            398,
+            472
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In figure 8 we provide the curves of agent performance on held out test configurations for three scenarios: 4-item, 6-item and labyrinth. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            516
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/00d7d1117b3beb40913bf94329fc0af281d4485976930e5f9a9a01e9df62a8b5.jpg",
+        "image_caption": [
+            "Figure 7: Schematics detailing the operation of the read mechanisms, with global read (left), context read(middle) and xy-querying (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            166,
+            795,
+            270
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/65cf6dcbd579474e337bc774aeeefc6dda064e267084d351d80588e9fb5c5e52.jpg",
+        "image_caption": [
+            "Figure 8: Training curves of held out test set performance on 4-item (top left), 6-item(top-right) and labyrinth scenarios (bottom). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            436,
+            813,
+            819
+        ],
+        "page_idx": 14
+    }
+]

parse/train/T1STW1NYYKW/T1STW1NYYKW.md

@@ -0,0 +1,474 @@
+# Practical Bayesian Optimization of Objectives with Conditioning Variables
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+Bayesian optimization is a class of data efficient model based algorithms typically focused on global optimization. We consider the more general case where a user is faced with multiple tasks that each need to be optimized, find the global optima within each task, all the task conditional optima. For example given a range of cities with different patient distributions, we optimize the ambulance locations for each and every city; given subclass partitions of CIFAR-10, we optimize CNN hyperparameters for each partition. Similarity across tasks boosts optimization of each task in two ways: in modelling by data sharing across objectives, and also in acquisition by quantifying how a single point on one task can help learn the optima of similar tasks. For this we propose a framework for conditional optimization: ConBO. This can be built on top of a range of acquisition functions and we propose a new Hybrid Knowledge Gradient acquisition function. The resulting method is intuitive and theoretically grounded, either matches or significantly outperforms recently published works on a range of problems, and thanks to the unique nature of conditional optimization, is easily parallelized to collect a batch of points.
+
+# 16 1 Introduction
+
+17 Expensive stochastic black box functions arise in many fields such as fluid simulations [1], engineering   
+18 wing design [2], and machine learning parameter tuning [3]. Bayesian optimization is a powerful set   
+19 of tools to optimize such functions, finding the input with highest long term average performance   
+20 $x ^ { * } = \arg \operatorname* { m a x } _ { x } \mathbb { E } [ f ( x ) ]$ , (the expectation represents averaging over the performance noise). In this   
+21 work we consider an under-explored generalization of the standard setting previously referred to as   
+22 “conditional optimization" [4] where a user has a collection of functions, or tasks, and simply seeks   
+23 the peak of each function/task. Formally, we have an expensive black box $f$ that takes as arguments   
+24 both a task $s \in S$ and an input $x \in X$ , typically box-constrained continuous variables, and returns a   
+25 noisy scalar performance
+
+$$
+f ( s , x ) : S \times X \to \mathbb { R } .
+$$
+
+26 At each iteration an algorithm determines both task and input $( s , x )$ then observes performance   
+27 $y = f ( s , x )$ and the goal is to learn the input with highest average performance for each task
+
+$$
+x ^ { * } ( s ) = \arg \operatorname* { m a x } _ { x } \mathbb { E } [ f ( s , x ) ] .
+$$
+
+28 $x ^ { * } ( s )$ is referred to as the optima conditioned on $s$ , see Figure 1 black line. In certain applications,   
+29 one may want to give higher priority to particular tasks hence a task weighting function $W ( s )$ may   
+30 also be specified. In this work we consider the following applications.   
+31 CNN hyperparameters: the CIFAR-10 dataset contains 10 classes, this is split into five mutually   
+32 exclusive binary classification datasets and for each we train a CNN, each CNN is a task in $S =$   
+33 $\{ 1 , . . . , 5 \}$ . For each CNN, we optimize dropout rates, batch size and Adam parameters, so $X \subset \mathbb { R } ^ { 7 }$   
+4 and $f ( s , x )$ is the validation accuracy. We assume all five CNNs have equal priority, $W ( s ) = 1 / 5$ .   
+35 Ambulances in a square: [5] given a range of   
+36 $3 0 \mathrm { k m } \times 3 0 \mathrm { k m }$ cities, each city is a task with a   
+37 different population centre $\dot { s } \in [ 0 , 3 0 ] ^ { 2 }$ . For   
+38 a given city, we optimize the 2D location of   
+39 three ambulance bases, $x \in [ 0 , 3 0 ] ^ { 3 \times 2 } \subset \mathbb { R } ^ { 6 }$ .   
+40 Given a city $s$ and ambulance bases $x$ , a vir  
+41 tual environment randomly generates patients   
+42 for a simulated day and the average ambulance   
+43 journey time, $f ( s , x )$ , is returned. Inland cities,   
+44 like Paris or London, with population centres   
+45 in the middle are more common than coastal   
+46 cities, like Singapore or Dubai, with a popula  
+47 tion centre on a boundary. Thus, $W ( s )$ mirrors   
+48 this distribution of city centres, a Gaussian cen  
+49 tred at $s = ( 1 5 , 1 5 )$ with $7 \mathrm { k m }$ standard deviation   
+50 and truncated to $[ 0 , 3 0 ] ^ { 2 }$ .   
+51 Assemble to order: [6, 7] a company owns   
+52 many stock warehouses and each one faces a   
+53 different level of demand $s \in [ 0 . 5 , 1 . 5 ]$ . Equal   
+54 priority is given to all warehouses and so $W ( s )$   
+55 is uniform. At each warehouse, stock levels are   
+56 controlled by setting targets of a control pol  
+57 icy $x = [ 0 , \dot { 2 } 0 ] ^ { 8 }$ . Given a demand level $s$ and   
+58 control parameters $x$ , a simulator generates cus  
+59 tomer orders according to demand, the ware
+
+![](images/303db05f44ad7878365f95c85f17cf1431f40372fc7008a7e0445e40355d1cf4.jpg)  
+Figure 1: Top: GP model. Each task (vertical slice) is an objective function to maximise. A new sample $( s , x ) ^ { \searrow n + 1 }$ provides information about the optima of similar tasks. Bottom: the acquisition function value of each task using hybrid Knowledge Gradient.
+
+house stock is sold and replenished according to policy $x$ , and profit over a simulated month is returned as $f ( s , x )$ .
+
+62 The closely related multi-task Bayesian optimisation or Bayesian Quadrature optimisation methods   
+63 [8, 9, 10, 11] aim to find a single peak that maximises the weighted sum/integral over tasks, $x ^ { * } =$   
+64 arg $\begin{array} { r } { \operatorname* { m a x } _ { x } \int \mathbb { E } [ f ( s , x ) ] W ( s ) d s } \end{array}$ . However, as they are fundamentally designed for a different purpose,   
+65 we observe that they struggle to find the peak of each and every task, see experiments in Supplementary   
+66 Material 6 (SM 6).   
+67 Also closely related are contextual optimization algorithms [12, 13, 14], conditional optimization   
+68 has also been referred to as “offline contextual" [15]. In contextual applications, at iteration $n$ the   
+69 next task (called context) $s ^ { n }$ is passed from the black box to a contextual algorithm that intelligently   
+70 determines $x ^ { n }$ . Then the black box returns both performance $y ^ { n }$ and the next task/context $s ^ { n + 1 }$ . One   
+71 could “hotfix" a contextual algorithm for conditional optimization problems by randomly choosing   
+72 $s ^ { n + 1 } \sim \mathbb { P } [ s ] \propto W ( s )$ at each iteration. However, we empirically show that, unsurprisingly, randomly   
+73 choosing the task in each iteration is significantly worse than intelligently choosing the task.   
+74 Multi-fidelity and multi-information source methods [16, 17, 18, 19] assume there is a single known   
+75 constant target task $s ^ { * } \in S$ corresponding to the highest fidelity level or most expensive information   
+76 source that must be optimized, $x ^ { * } = \arg \operatorname* { m a x } _ { x } \mathbb { E } [ f ( s ^ { * } , x ) ]$ . If the cost of evaluation varies across the   
+77 function domain, $c ( s , x )$ , cheaper regions of the domain can be evaluated improving sample efficiency.   
+78 Again, such methods may be hotfixed for the setting we consider by artificially designating a target   
+79 task, e.g. the highest priority task $s ^ { * } = \arg \operatorname* { m a x } _ { s } W ( s )$ . However, we observe that if cost is constant   
+80 across the domain (as is commonly assumed in the BO literature), these methods greedily optimise   
+81 the artificial target task $s ^ { * }$ and blindly neglect all other tasks, see SM4. This desirable behaviour in   
+82 multi-fidelity optimization problems leads to failure in conditional optimization problems.
+
+To the best of our knowledge, there exist only a small number of works that propose algorithms specifically designed for the conditional setting.
+
+85 The Surrogate Collaborative Tuning (SCoT) algorithm [20] optimizes a finite set of tasks. It iteratively   
+86 visits each task, $s$ , in a round-robin fashion and determines the input $x$ by expected improvement (EI).   
+87 The authors apply this to optimize the hyperparameters of an ML model for multiple datasets. The   
+88 Profile Expected Improvement (PEI) and Profile Expected Quantile Improvment (PEQI) algorithms   
+89 [21, 4] consider continuous tasks and significantly improve upon SCoT by dynamically determining   
+90 the task in each iteration. The acquisition value of a given point $( s , x )$ is the expected improvement   
+91 of a new output over the best predicted output within the same task.   
+92 The REVI algorithm [22] at each iteration discretizes both task $S$ and input $X$ spaces. Given a new   
+93 hypothetical point, $( s , x ) ^ { n + 1 }$ , for each task in the discretization, $s _ { i }$ , the discrete Knowledge Gradient   
+94 over the $X$ discretization quantifies how $( s , x ) ^ { n + 1 }$ will benefit task $s _ { i }$ . Summing the benefits over the   
+95 tasks yields the acquisition value of $( s , x ) ^ { n + 1 }$ . REVI was designed to account for how all tasks can be   
+96 optimized by each sample. However, this comes with exponential cost, increasing problem dimension   
+97 leads to exponentially increasing discretization size with corresponding exponential space and time   
+98 requirements. On the other hand, sparse discretizations can lead to poor and arbitrary measures   
+99 of acquisition value. Consequently, REVI has only successfully been applied to low-dimensional   
+100 synthetic problems.   
+101 Most recently, the Multi-task Thompson sampling (MTS) method [15] uses a novel kernel with a   
+102 length scale that varies across tasks. This is combined with a Thompson sampling method for col  
+103 lecting new data and showed performance improvements over REVI. However, Thompson sampling   
+104 also does not account for how one sample provides benefit for optimizing all tasks, a fundamental   
+105 structural property of conditional optimization.   
+106 We propose a method that exploits the basic structure of conditional optimization while also being   
+107 highly scalable, and therefore applicable to more challenging real-world problems. We make the   
+108 following contributions:   
+1. A framework for conditional Bayesian optimization with theoretical guarantees: ConBO.   
+2. A new, fast global optimization method: Hybrid Knowledge Gradient.   
+3. State-of-the-art performance on open source problems including CNNs and simulators.
+
+# 112 2 The Conditional Bayesian Optimization Algorithm
+
+113 We first discuss the fitting of the Gaussian process model and the predicted conditional optima. We   
+114 then motivate the acquisition value for a single task and how this is integrated over tasks yielding the   
+115 acquisition function. Because integrating over tasks multiplies the computational burden, we propose   
+116 Hybrid Knowledge Gradient as a solution. See Algorithm 1 in the SM 2 for a high level summary.   
+117 At a stage after having observed $n$ data points, $\{ ( s ^ { i } , x ^ { i } , y ^ { i } ) \} _ { i = 1 } ^ { n }$ where $y ^ { i } = f ( s ^ { i } , x ^ { i } )$ , a Gaussian   
+118 process is fit over the joint space $S \times X$ to scalar outputs $y$ . Let $\tilde { X } ^ { n } = ( ( s , x ) ^ { 1 } , . . . , ( s , x ) ^ { n } )$ and   
+119 $\mathbf { \bar { \boldsymbol { Y } } } ^ { n } = ( y ^ { 1 } , . . . , y ^ { n } )$ . A Gaussian process is defined by a prior mean and prior covariance function,   
+120 $\mu ^ { 0 } ( s , x )$ , $k ^ { 0 } ( ( s , x ) , ( s ^ { \prime } , x ^ { \prime } ) )$ which are chosen for each application, for more information see [23].   
+121 Let the data covariance matrix be $K = k ^ { 0 } ( \tilde { X } ^ { n } , \tilde { X } ^ { n } ) \in \mathbb { R } ^ { n \times n }$ , the posterior mean is given by
+
+$$
+\mu ^ { n } ( s , x ) = \mu ^ { 0 } ( s , x ) + k ^ { 0 } ( ( s , x ) , \tilde { X } ^ { n } ) \big ( K + \sigma _ { 0 } ^ { 2 } I \big ) ^ { - 1 } \big ( Y ^ { n } - \mu ^ { 0 } ( \tilde { X } ^ { n } ) \big )
+$$
+
+122 and the posterior covariance is given by
+
+$$
+k ^ { n } ( ( s , x ) , ( s ^ { \prime } , x ^ { \prime } ) ) = k ^ { 0 } ( ( s , x ) , ( s ^ { \prime } , x ^ { \prime } ) ) + k ^ { 0 } ( ( s , x ) , \tilde { X } ^ { n } ) \big ( K + \sigma _ { 0 } ^ { 2 } I \big ) ^ { - 1 } k ^ { 0 } ( \tilde { X } ^ { n } , ( s ^ { \prime } , x ^ { \prime } ) ) .
+$$
+
+123 At the end of data collection, in standard BO, often the peak posterior mean is returned as the   
+124 predicted best input. Generalizing to the conditional setting we simply condition on $s$ ,
+
+$$
+x ^ { * N } ( s ) = \underset { x } { \mathrm { a r g m a x } } \mu ^ { N } ( s , x ) .
+$$
+
+125 During data collection, a new data point $y ^ { n + 1 }$ at $( s , x ) ^ { n + 1 }$ will update the Gaussian process over the   
+126 whole domain $S \times X$ . To construct an acquisition function for conditional optimization, we start   
+127 by looking for standard acquisition functions that account for how the model changes at unsampled   
+128 locations $\mathbf { \bar { \Phi } } ( s ^ { \prime } , x ^ { \prime } ) \neq ( s , x ) ^ { n + 1 }$ . Specifically, the popular Expected improvement (EI) [24] and upper   
+129 confidence bound (UCB) [25] methods are both functions of the mean and kernel at the sampled point   
+130 only, i.e. of $( \mu ^ { n } ( ( s , x ) ^ { n + 1 } )$ , $k ^ { n } ( ( s , x ) ^ { n + 1 } , ( s , x ) ^ { n + 1 } ) \big )$ , hence would require non-trivial modification   
+131 to be able to account for how a sample affects similar tasks. Methods that do utilise the mean and   
+132 kernel at unsampled points include Entropy search (ES [26, 27] and PES [28]) that measures the   
+133 mutual information between the new output $\mathbb { P } [ y ^ { n + 1 } | x ^ { n + 1 } ]$ and the (uncertain) location of the peak   
+134 $\mathbb { P } [ x ^ { * } | { \tilde { X } } ^ { n } , Y ^ { n } ]$ , Max-value entropy search (MES) [29] that measures mutual information between   
+135 the new output $\mathbb { P } [ y ^ { n + 1 } | x ^ { n + 1 } ]$ and the (uncertain) largest output $\mathbb { P } [ \operatorname* { m a x } y | \tilde { X } ^ { n } , Y ^ { n } ]$ , and Knowledge   
+136 Gradient (KG) [30] that measures the expected peak of the new posterior mean $\mathbb { E } [ \operatorname* { m a x } \mu ^ { n + 1 } ( \breve { x } ) ]$   
+137 caused by a new yn+1 at xn+1 .   
+138 Each single task $s$ defines a single global optimization problem over $x \in X$ . Given a proposed   
+139 sample $( { \bar { s } } , x ) ^ { n + 1 } = ( s ^ { n + 1 } , x ^ { n + 1 } )$ , the acquisition benefit for task $s$ may be computed using ES, PES,   
+140 MES or KG. In this work we adopt KG for its Bayesian decision theoretic derivation that extends   
+141 seamlessly to the conditional setting. For KG, the benefit for a given task is the expected increase in   
+142 peak predicted performance within the task. We denote the task-conditioned KG as
+
+![](images/3e4a18929624b6e8451a395ae19c2c9a9ecd7b4f945ce90815c5d43073617386.jpg)  
+Figure 2: Methods for computing $\mathrm { K G } ( x ^ { n + 1 } )$ at $x ^ { n + 1 } = 7$ . Left: $\mu ^ { n } ( x )$ and samples of $\mu ^ { n + 1 } ( x )$ determined by a scalar $Z \sim N ( 0 , 1 )$ . Centre-left: ${ \mathrm { K G } } _ { d }$ replaces $X$ with up to 3000 points $x _ { i } \in X _ { d }$ and $\mu ^ { n + 1 } ( x _ { i } )$ is linear in $Z$ . Centre-right: ${ \mathrm { K G } } _ { M C }$ samples up to 1000 functions $\mu ^ { n + 1 } ( x )$ functions and maximises each of them numerically. Right: ${ \mathrm { K G } } _ { h }$ samples up to 5 functions $\dot { \mu } ^ { n + 1 } ( x )$ and maximizes them numerically, the arg max points $x _ { 1 } ^ { * } , . . , x _ { 5 } ^ { * }$ are used as $X _ { d }$ in $\operatorname { K G } _ { d }$ .
+
+$$
+\mathrm { K G } _ { c } ( s ; ( s , x ) ^ { n + 1 } ) = \mathbb { E } _ { y ^ { n + 1 } } [ \operatorname* { m a x } _ { x ^ { \prime } } \mu ^ { n + 1 } ( s , x ^ { \prime } ) | ( s , x ) ^ { n + 1 } ] - \operatorname* { m a x } _ { x ^ { \prime \prime } } \mu ^ { n } ( s , x ^ { \prime \prime } ) .
+$$
+
+143 We discuss numerical evaluation of $\operatorname { K G } _ { c } ( \cdot )$ in Section 2.1. Similar expressions for conditioned   
+144 entropy methods, $\mathrm { E S } _ { c } ( \cdot ) , \mathrm { P E S } _ { c } ( \cdot ) , \mathrm { M E S } _ { c } ( \cdot ) .$ , are derived in SM 7. Integrating over all tasks $s$ yields   
+145 the total acquisition value
+
+$$
+\int _ { S } { \bf K } { \bf G } _ { c } ( s ; ( s , x ) ^ { n + 1 } ) W ( s ) d s .
+$$
+
+146 For discrete $S$ the integral is replaced by summation. For continuous $S$ , the integral over tasks $s$   
+147 cannot be computed analytically so we use Monte Carlo with importance sampling. When using   
+148 a kernel that factorises $\bar { k ( s , x , s ^ { \prime } , x ^ { \prime } ) } = \sigma _ { 0 } ^ { 2 } k _ { S } ( s , s ^ { \prime } ) k _ { X } ( x , x ^ { \prime } )$ , like squared exponential or Matérn,   
+149 similarity across tasks is encoded in $k _ { S } ( s , s ^ { \prime } )$ . This naturally leads to the proposal distribution   
+150 $q ( s | s ^ { n + \bar { 1 } } ) \propto k _ { S } ( s , s ^ { n + 1 } )$ . In our continuous task experiments, we use the Matérn kernel and a   
+151 Gaussian proposal distribution with mean $s ^ { n + 1 }$ and the task kernel length scales, $l _ { s }$ , as standard   
+152 deviations,
+
+$$
+q ( s | s ^ { n + 1 } ) \sim \mathcal { N } ( s | s ^ { n + 1 } , \mathrm { d i a g } ( l _ { s } ^ { 2 } ) ) .
+$$
+
+153 We generate $n _ { s } = 2 0$ samples $\boldsymbol { S _ { M C } } = \{ s _ { 1 } , . . . , s _ { n _ { s } } \}$ , finally the acquisition function is
+
+$$
+\mathrm { C o n B O } ( s ^ { n + 1 } , x ^ { n + 1 } ) = \sum _ { s _ { i } \in S _ { M C } } \frac { W ( s _ { i } ) } { q ( s _ { i } | s ^ { n + 1 } ) } \mathrm { K G } _ { c } ( s _ { i } ; ( s , x ) ^ { n + 1 } ) .
+$$
+
+154 Figure 1 shows a set of sampled tasks and the $\mathrm { K G } _ { c } ( \cdot )$ for each one. Each KG term directly measures   
+155 increase in predicted performance for one task, e.g. if $y$ values are dollar amounts, ConBO with   
+156 $\mathrm { K G } _ { c } ( \cdot )$ is the sum of dollar increases over all tasks. However, for entropy based methods, ConBO   
+157 becomes a sum of Shannon information units thereby indirectly optimizing the dollar amounts.   
+158 The randomly sampled tasks $S _ { M C }$ may be resampled with each call to $\mathbf { C o n B O } ( s , x )$ and gradients   
+159 estimated enabling the optimal $( s , x ) ^ { n + 1 }$ to be found with a stochastic gradient ascent optimizer such   
+160 as Adam [31]. Selecting each point according to maximising ConBO is also myopically optimal in a   
+161 value of information framework:
+
+Theorem 1 Let $( s ^ { * } , x ^ { * } ) \in \arg \operatorname* { m a x } C o n B O ( s , x )$ be a point chosen for sampling. $( s ^ { * } , x ^ { * } )$ is also the point that maximises the myopic Value of Information, the increase in predicted performance.
+
+164 Further, in finite search space, with an infinite sampling budget all points will be sampled infinitely:
+
+<table><tr><td colspan="2">Algorithm 1 Computing ConBO(s,x). For each call with a candidate (task, input) point, similar tasks are sampled.For each sampled task a cheap acquisition function, hybrid KG, is evaluated. The output is the importance weighted average of hybrid KG values. Details and full numerical expressions are given in SM 3.</td></tr><tr><td colspan="2">Require: candidate point (s,x)n+1, parameters ns, nz Sample ng tasks similar to gn+1, SMc ~ q(s|sn+1) Initialize output value Q ← 0 parfor si in SMc do InitializeX*←0</td></tr><tr><td>parfor j i ,...,nz do zj←Φ-1((2j-1)/2nz) computed with (s,x)n+1 and zj 3 x ← arg maxx μ+1(si,x) with Optimizer() X←X*U(si,x） end parfor</td><td>Hybrid Knowledge Gradient</td></tr><tr><td colspan="2">αi ←KGd(X*) Q ← Q+αi W(si)/q(si|sn+1) end parfor</td></tr></table>
+
+165 Theorem 2 Let $S$ and $X$ be finite sets and $N$ the budget to be sequentially allocated by ConBO.   
+166 Let $n ( s , x , N )$ be the number of samples allocated to a point $( s , x )$ within budget $N$ . Then for all   
+167 $( s , x ) \in S \times X$ we have that $\begin{array} { r } { \operatorname* { l i m } _ { N \to \infty } n ( s , x , N ) = \infty } \end{array}$ .
+
+The law of large numbers ensures that the algorithm learns the true expected performance for all points. Proofs are given in the SM 1.
+
+# 170 2.1 Hybrid Knowledge Gradient
+
+171 By definition, KG is more expensive than EI and UCB. Further, the function $\operatorname { K G } _ { c } ( s _ { i } , ( s , x ) ^ { n + 1 } )$   
+172 must be computed once for each sampled task $s _ { i }$ , the computational cost is therefore $n _ { s }$ times the   
+173 global acquisition function equivalent. To alleviate this cost, we propose a novel, efficient algorithm   
+174 for computing KG. In the following section we assume constant $s$ for brevity, reducing to the   
+175 global optimization setting. Given a hypothetical location $x ^ { n + 1 }$ , KG quantifies the value of a new   
+176 hypothetical observation $y ^ { \bar { n } + 1 }$ by the expected increase in the peak of the posterior mean
+
+$$
+\operatorname { K G } ( x ^ { n + 1 } ) = \mathbb { E } _ { y ^ { n + 1 } } \big [ \operatorname* { m a x } _ { x ^ { \prime } } \mu ^ { n + 1 } ( x ^ { \prime } ) \big | x ^ { n + 1 } \big ] - \operatorname* { m a x } _ { x ^ { \prime \prime } } \mu ^ { n } ( x ^ { \prime \prime } ) .
+$$
+
+177 However, $\operatorname* { m a x } _ { x ^ { \prime } } \mu ^ { n + 1 } ( x ^ { \prime } )$ has no explicit formula and approximations are required which we describe   
+178 next. At time $n$ , the next posterior mean is unknown, however, it may be written as $\mu ^ { n + 1 } ( x ) =$   
+179 $\mu ^ { n } ( x ) + \tilde { \sigma } ( x ; x ^ { n + 1 } ) Z$ where $\tilde { \sigma } ( x ; x ^ { n + 1 } )$ is a deterministic function and the scalar $Z \sim \mathcal { N } ( 0 , 1 )$   
+180 captures the randomness of $y ^ { n + 1 }$ , see SM 2. Previously, $\operatorname { K G } ( x )$ has been computed in two ways.
+
+KG by discretization [30, 32]: in Equation 6, the maximizations may be performed over a discrete set of $d$ points $X _ { d } \subset X$ . Denoting $\underline { { \mu } } ^ { \mathsf { ^ { \prime } } } = \mu ^ { n } ( X _ { d } ) \in \mathbb { R } ^ { d }$ and $\underline { { \tilde { \sigma } } } ( x ^ { n + 1 } ) \overset { \bullet } { = } \tilde { \sigma } ( \mathbf { \tilde { X } } _ { d } ; x ^ { n + 1 } ) \in \mathbb { R } ^ { d }$ , then
+
+$$
+\mathrm { K G } _ { d } ( x ^ { n + 1 } ) = \mathbb { E } _ { Z } \left[ \operatorname* { m a x } \{ \underline { { \mu } } + \underline { { \tilde { \sigma } } } ( x ^ { n + 1 } ) Z \} \right] - \operatorname* { m a x } \underline { { \mu } } .
+$$
+
+181 The $\operatorname* { m a x } \{ \underline { { \mu } } + \tilde { \underline { { \sigma } } } ( x ^ { n + 1 } ) Z \}$ is a piece-wise linear function of $Z$ and the expectation is analytically   
+182 tractable. The output is a lower bound of the true $\operatorname { K G } ( x )$ . REVI [22] and the MiSo algorithm   
+183 [17] used ${ \mathrm { K G } } _ { d }$ with 3000 uniformly random distributed points. This method suffers the curse of   
+184 dimensionality as $X _ { d }$ must grow exponentially with dimension. Further, the discretization may likely   
+185 contain many useless points in uneventful regions of $X$ , see Figure 2 centre-left plot.
+
+<table><tr><td>KG</td><td>Type of Estimate</td><td>nz=3</td><td>nz=5</td><td>nz=7</td><td>nz= 50</td></tr><tr><td>Discrete</td><td>lower bound</td><td>0.24 (1.37)</td><td>0.41 (1.49)</td><td>0.55 (1.91)</td><td>2.03 (2.2)</td></tr><tr><td>MC</td><td>unbiased</td><td>3.54 (4.79)</td><td>3.73 (4.51)</td><td>3.50 (3.39)</td><td>3.36 (1.18)</td></tr><tr><td>MC++</td><td>unbiased</td><td>2.97 (3.78)</td><td>3.50 (2.68)</td><td>3.22 (1.69)</td><td>3.32 (0.2)</td></tr><tr><td>Hybrid</td><td>lower bound</td><td>3.15 (0.00)</td><td>3.28 (0.00)</td><td>3.31 (0.00)</td><td>3.34 (0.00)</td></tr></table>
+
+Table 1: We collect 20 points on the Rosenbrock function, a point was randomly selected and KG computed by the different methods. Each calculation is repeated 50 times and we report mean and two standard deviations. The Monte Carlo methods suffer from high variance, the discrete method is volatile and returns a very loose lower bound. Hybrid KG is very stable with errors too small to show.
+
+187 KG by Monte Carlo [33, 34]: given $x ^ { n + 1 }$ , the method samples up to $n _ { z } = 1 0 0 0$ Gaussian values   
+188 of $Z$ . For each $Z _ { j }$ , construct the posterior mean, $\mu _ { j } ^ { n + 1 } ( x )$ , find the maximum with a continuous   
+189 numerical Optimizer() like L-BFGS or CG. Averaging the maxima from all $Z _ { j }$ yields
+
+$$
+\mathrm { K G } _ { M C } ( x ^ { n + 1 } ) = \frac { 1 } { n _ { s } } \sum _ { j } \mathbb { O } \mathrm { p t i } \underset { x ^ { \prime } } { \mathrm { i m i } } z \mathrm { e r } \left( \mu _ { j } ^ { n + 1 } ( x ) \right) - \mathbb { O } \mathrm { p t i } \underset { x ^ { \prime \prime } } { \mathrm { i m i } } z \mathrm { e r } \left( \mu ^ { n } ( x ^ { \prime \prime } ) \right) .
+$$
+
+190 The result is an unbiased estimate of true $\operatorname { K G } ( x )$ and scales better to higher dimensional $X$ , the   
+191 univariate $Z$ is discretized by Monte Carlo samples instead of $X$ . However, for a good estimate, $n _ { z }$   
+192 must be large, many Optimizer() calls are required. See Figure 2 centre right.   
+193 We instead propose a simple mixture of the two approaches above that both scales to higher dimen  
+194 sional $X$ and drastically reduces the number of Optimizer() calls.
+
+Hybrid KG: given $x ^ { n + 1 }$ , following ${ \mathrm { K G } } _ { M C }$ we use $n _ { z } = 5$ values of $Z _ { j }$ , construct $\mu _ { j } ^ { n + 1 } ( x )$ and use Optimizer() to find the peak location $\boldsymbol { x } _ { i } ^ { * }$ . The set of peak locations $X _ { d } ^ { * } = \{ x _ { 1 } ^ { * } , . . . , x _ { n _ { z } } ^ { * } \}$ is used as a dynamic optimized discretization in $\check { \mathsf { K G } } _ { d }$ thus analytically computing an extremely tight lower bound of the true $\operatorname { K G } ( x )$ . Let $\underline { { \mu } } ^ { * } = \mu ^ { n } ( X _ { d } ^ { * } )$ and similarly for $\tilde { \sigma } ^ { * } ( x ^ { n + 1 } )$ , Hybrid KG is given by
+
+$$
+\mathrm { K G } _ { h } ( x ^ { n + 1 } ) = \mathbb { E } _ { Z } [ \operatorname* { m a x } \underline { { \mu } } ^ { * } + \underline { { \tilde { \sigma } } } ^ { * } ( x ^ { n + 1 } ) Z ] - \operatorname* { m a x } \underline { { \mu } } ^ { * } .
+$$
+
+195 Compared to $\operatorname { K G } _ { d }$ , the hybrid method removes redundant points in the discretization $X _ { d }$ , all $X _ { d } ^ { * }$   
+196 points contribute to max $\mu ^ { n + 1 } ( X _ { d } ^ { * } )$ and there are far fewer points. Compared to ${ \mathrm { K G } } _ { M C }$ that samples   
+197 many $Z _ { j }$ and optimizes many $\boldsymbol { x } _ { j } ^ { * }$ , Hybrid KG uses far fewer $Z _ { j }$ and optimizes far fewer $\boldsymbol { x } _ { j } ^ { * }$ . See   
+198 Algorithm 1 for a summary of evaluating ConBO with Hybrid KG. ConBO can be reduced to the   
+199 REVI algorithm by replacing the dynamic importance sampled tasks with a pre-frozen discretization   
+200 of tasks and the (dynamic optimized) hybrid KG with discrete KG over a pre-frozen discretization of   
+201 inputs. These changes drastically improve scalability enabling ConBO to be applied to a far broader   
+202 range of applications.   
+203 To ensure asymptotic convergence, in a discrete domain, we require that the acquisition function   
+204 is non-negative, $\mathrm { K G } _ { h } ( x ) \geq { \mathit { \bar { 0 } } }$ , and the acquisition function is zero where GP variance is zero,   
+205 ${ \bf K G } _ { h } ( x ) = 0 \iff k ^ { n } ( x , x ) = 0$ . Therefore, always choosing $x ^ { n + 1 } = \arg \operatorname* { m a x } \mathbf { K } \mathbf { G } _ { h } ( x )$ ensures   
+206 only points with GP variance will be revisited until all points have no variance i.e. the true function is   
+207 known for all points. We can ensure these properties by setting $n _ { z } \geq 2$ and at least one $Z _ { j }$ is equal to   
+208 zero.
+
+Theorem 3 Let $n _ { z } \geq 2$ and let $\underline { { Z } } = \{ Z _ { j } | j = 1 , . . . , n _ { z } \} .$ . If $0 \in \underline { { Z } }$ then $K G _ { h } ( x ) \ge 0$ for all $x \in X$ and if $x$ is sampled infinitely often $K G _ { h } ( x ) = 0$ .
+
+Proof is in the SM 1. The $Z _ { j }$ values can be fixed, for $n _ { z } = 5$ we use equal Gaussian quantiles $\underline { { Z } } = \{ \Phi ^ { - 1 } ( 0 . 1 ) , \Phi ^ { - 1 } ( 0 . 3 ) , \ldots , \Phi ^ { - 1 } ( 0 . 9 ) \}$ where $\Phi ( \cdot )$ is the Gaussian CDF. Using quantile spacing and odd $n _ { z }$ ensures $Z _ { j } = \Phi ^ { - 1 } ( 0 . 5 ) = 0$ is included which satisfies the assumptions of asymptotic convergence. See Fig.2 (right).
+
+The computational complexity of a single call to ConBO requires the posterior variance $( O ( n ^ { 2 } ) )$ and $n _ { s } n _ { z }$ runs of Optimizer(). Let $n _ { c a l l s }$ be the number of times that Optimizer() calls the posterior mean costing $O ( n )$ . Thus, ConBO total complexity is $O ( n ^ { 2 } + n n _ { c a l l s } n _ { s } n _ { z } )$ . Note this is linear in $n _ { s } n _ { z }$ , the size of the (small) dynamic optimal discretization over $S \times X$ . Thompson sampling with
+
+![](images/6b231524753c9d2579d81150e39a26e287244085ac1ab47829b5b86b5ec7a49e.jpg)  
+Figure 3: Opportunity Cost across a range of synthetic test problems. The dummy baseline, KNN, is worst in all cases, policy gradient is better however the Gaussian process based methods all perform better. UNI and EI are not conditional algorithms yet outperform PEQI. Amongst other conditional algorihtms, MTS, REVI and ConBO methods all perform significantly better. ConBO-3 is outperformed by ConBO-5 demonstrating the improvement with more accurate ${ \mathrm { K G } } _ { h }$ .
+
+219 discretization uses one operation that scales cubically as $O ( n ^ { 2 } ( n _ { s } n _ { z } ) + n ( n _ { s } n _ { z } ) ^ { 2 } + ( n _ { s } n _ { z } ) ^ { 3 } )$ in   
+220 the worst case and to reduce cost special techniques are required e.g. Fourier features, CG matrix   
+221 inversion.
+
+# 222 3 Experiments
+
+We consider synthetic benchmarks and the three applications described in Section 1. In SM 4 we also present parallelization batch sampling results, and experiments with contextual, multi-task and multi-fidelity methods in SM 6. We also briefly test Hybrid KG for global optimization, SM 5, and observe that ${ \mathrm { K G } } _ { M C }$ performs worse in the same computation time hence we exclude ${ \mathrm { K G } } _ { M C }$ methods from the conditional experiments. For each benchmark, for evaluation, held out test tasks are sampled from $\mathbb { P } [ s ] \propto W ( s )$ , for each test task, $s _ { i } ^ { t e s t }$ , the predicted optimal input is computed, $x ^ { * } ( s _ { i } ^ { t e s t } )$ and we report the true black box output averaged over all test tasks, see SM 3 for details.
+
+# 230 3.1 How Accurate is Hybrid Knowledge Gradient?
+
+The theoretical Knowledge Gradient cannot be analytically computed and must be approximated (similarly, entropy based methods are not fully tractable). To illustrate the quality of the approximations, we collected 20 points from the Rosenbrock test function and fit a Gaussian process. Another point was then randomly selected and true KG was estimated by the different methods, keeping the $2 0 + 1$ points fixed and only varying the $n _ { z }$ parameter. Each estimate of KG was recalculated 50 times and Table 1 shows the mean and two standard deviations. Discrete KG results in an extremely loose, volatile bound. The (state of the art) MC method with $n _ { z } = 5 0$ has a run-to-run variance of $\pm 3 5 \%$ , variance reduction techniques used in $\mathbf { M C } { + + }$ (latin hypercube inverse sampling and control variates) can reduce this to $\pm 6 \%$ . Hybrid KG with $n _ { z } = 3$ is extremely stable, run-to-run variance is too small to show, and is within the error margins of $\mathbf { M C } { + + }$ with $n _ { z } = 5 0$ which is $\sim 1 7 \times$ more expensive to compute. Increasing $n _ { z }$ tightens the bound, hybrid KG with $n _ { z } = 5$ has $9 8 . 2 \%$ of the value of $n _ { z } = 5 0$ . As a result, Hybrid KG is much easier to optimize, the Adam optimizer may be used with a much higher learning rate and lower momentum and thus converges much faster.
+
+244 As an aside, the recently proposed one-shot KG [34] enhances the optimization of ${ \mathrm { K G } } _ { M C }$ . By   
+245 freezing the $Z$ values between calls to ${ \mathrm { K G } } _ { M C }$ thus ${ \tilde { X } } ^ { * }$ may be reused, this enables joint gradient   
+246 ascent of $( x ^ { n + 1 } , \tilde { X } ^ { * } )$ . In the global optimization use case (a constant single task) one-shot KG and   
+247 Hybrid KG can be combined. In the conditional setting, the ${ \tilde { X } } _ { i } ^ { * }$ of past sampled tasks may be saved,   
+248 however each call to ConBO must sample new tasks that are not in the saved history, one-shot KG   
+249 style joint optimization is not possible. In our implementation we utilise caching of ${ \tilde { X } } _ { i } ^ { * }$ from old   
+250 tasks to heuristically warm start finding ${ \tilde { X } } _ { i } ^ { * }$ for new tasks, see SM 3.
+
+# 3.2 Synthetic Functions
+
+52 We perform low-dimensional toy experiments in an ideal setting as a sanity check where we expect   
+53 all conditional methods to perform similarly. We use the popular Branin-Hoo and Rosenbrock test   
+54 functions in 2D defining the (task, input) domain as displayed in Figure 1.
+
+![](images/9385521d4cb702ed5972a88ec10ce8b14c1e39e1302cbcaf93973af158dd7909.jpg)  
+Figure 4: Left: validation accuracy. Centre-left: validation accuracy after 50 samples. Centre-right: validation accuracy after 100 samples. Right: algorithm overhead in seconds. After 50 samples, none of the multi-task models outperform the baseline, $\mathrm { E I } + \mathrm { T r }$ (dashed line) suggesting all datasets can use similar hyperparameters. For the larger budget 100, all models outperform the baseline by $0 . 1 \%$ suggesting that for more fine-tuning, each dataset requires different hyperaparameters. In all cases, performing data optimization significantly increases performance.
+
+Synthetic Functions Using the Rosenbrock and Branin-Hoo functions, we consider a uniform and a triangular task weighting $W ( s )$ . For baselines, we adopt two policy based methods. KNN: (dummy baseline) randomly collect data, $x _ { K N N } ^ { * } ( s )$ takes a task, $s$ , and returns the best input from 10 nearest neighbor tasks. PG: policy gradient, a parametric quadratic policy $x _ { P G } ^ { * } ( s ) = \pi _ { \theta } ( s )$ is learnt by maximising observed performance values, each iteration samples a task from $\mathbb { P } [ s ] \propto W ( s )$ then $x$ is sampled with an $\epsilon$ -greedy strategy. For a controlled ablation study, all the BO methods fit the same GP and for evaluation use the same definition of ${ { x } ^ { * N } } ( s )$ (Equation 3), methods only differ by their data acquisition strategy. UNI: random data collection, the most recent conditional methods PEQI, REVI, MTS with all parameters given in SM 3. ConBO- $n _ { z }$ : given $( s , x )$ , 20 tasks are importance sampled, ${ \mathrm { K G } } _ { h }$ with $n _ { z } = 3 , 5$ points is used. EI: expected improvement that treats $( s , x )$ as inputs to be optimized.
+
+Results are shown in Figure 3. Policy based methods KNN and PG consistently perform worse than the Gaussian process methods. Surprisingly, the conditional BO algorithm PEQI performs similarly to UNI and much worse than EI. All other conditional methods outperform all non-conditional methods.
+
+# 3.3 CNN Training Hyperparameters
+
+270 We apply MTS, REVI, and ConBO variants, and we adopt the recently proposed kernel used for BO   
+271 with Common Random Numbers [35],
+
+$$
+k ( ( s , x ) , ( s ^ { \prime } , x ^ { \prime } ) ) = \sigma _ { 0 } ^ { 2 } M ( x , x ^ { \prime } ; \underline { { { l } } } ) + \delta _ { s ^ { \prime } s } ( \sigma _ { 1 } ^ { 2 } M ( x , x ^ { \prime } ; \underline { { { l } } } ) + \sigma _ { 3 } ^ { 2 } ) .
+$$
+
+272 where $M ( x , x ^ { \prime } ; \underline { { l } } )$ is a Matérn $\frac { 5 } { 2 }$ kernel with length scales $l$ . The first term models a common trend   
+273 function across all tasks and the second term models how each task independently differs from the   
+274 trend. The differences are composed of another Matérn and the constant kernel to model a global   
+275 offset e.g. one dataset may have universally higher validation accuracy. This kernel has far fewer   
+276 parameters than a full multi-task product kernel, it is easy to fit and scales to an arbitrary number of   
+277 tasks (or datasets) without adding extra parameters.   
+278 In this problem setting, learning hyperparameters over similar datasets, one may expect that the   
+279 optimal hyperparameters would be the same for all datasets. Therefore, as a baseline we apply EI   
+280 to learn the hyperparameters of the first dataset (task 1). We then evaluate the objective function   
+281 (validation accuracy) on the rest of the datasets using the best observed hyperparameters from dataset   
+282 1, we refer to this as $\mathbf { E I + }$ Transfer.
+
+Argument Optimization versus Data Optimization In continuous task settings, it is not possible to evaluate every task. In discrete task settings with large sampling budgets $N \gg | S |$ , a user may desire a single high (although stochastic) output value, max $y$ , for every task. For example, in network hyperparameter optimization, the network with the best validation error, $\operatorname { m a x } y$ , will be deployed (and the hyperparameters $x$ may or may not be reused). We refer to this is data optimization (DO). For simulated environments, the input (or “action") that generalizes providing the best long-term average performance, $\operatorname* { m a x } _ { x } \mathbb { E } [ f ( s , x ) ]$ , is deployed and we refer to this is argument optimization (AO). Past work [22] has shown that argument optimization finds inputs that generalize better but
+
+![](images/bb7082c7937c6daaeb0b0adc8d411d4d577c7cd7566be3c09e6d35929ac64a61.jpg)  
+Figure 5: Left: average journey times across a range of cities. Right $:$ average profit across a range of warehouses. ConBO-5 and EI perform best on these benchmarks.
+
+291 may not provide optimal max $y$ for all tasks during the optimization run. The authors propose a “DO   
+292 trick”, use an AO method for $N - | S |$ iterations, then finally allocate one sample per task with input,   
+293 $x ^ { n + 1 }$ , determined by EI within the task. We apply this trick to all algorithms in this experiment.
+
+Results are shown in Figure 4. For the medium budget of 50 samples, ConBO performs best of the standard algorithms yet it is still worse than the $\mathrm { E I + T r }$ baseline. Applying the final round of DO improves all results to match the baseline. For the large budget of 100 samples, all methods outperform the baseline suggesting dataset specific fine-tuning of hyperparameters is required to achieve best results. Again, DO provides a significant boost to performance for all methods.
+
+Gaussian process kernel parameter learning required approximately 2–5 seconds using Tensorflow. In Figure 4 (right) we show the runtime of each algorithm excluding model fitting and network training, purely acquisition function optimization time. MTS and ConBO-3 are quickest while Conbo-5 increases linearly over ConBO-3 and REVI takes much longer.
+
+# 3.4 Ambulances and Warehouses
+
+We apply all methods from Section 3.2 to two benchmarks from the www.SimOpt.org library for simulation optimization problems. The ambulance problem (AMB) is 8-dimensional and consists of a range of cities and one must optimize ambulance locations for each city. The Assemble-to-order problem (ATO) is 9-dimensional consisting of a range of warehouses and one must optimize target 8 stock level for each warehouse. Results are shown in Figure 5. Of the policy based methods, PG performs poorly and does not show on the plots whilst KNN performs poorly on AMB and performs well on ATO suggesting that AMB is a more difficult problem. Of the GP based methods, EI performs well for smaller budgets. Although it is not a conditional algorithm we include it to highlight that 2 sometimes the simplest idea can also work. Of the conditional methods, MTS, REVI, and ConBO-3 all perform similarly, either slightly (AMB) or largely (ATO) outperforming UNI. These methods struggle in higher dimensions while ConBO-5 uses a more accurate acquisition function and is the only method that consistently performs well across all problems. We hypothesize that these problems 6 are more difficult than the synthetics and CNN and truly stress test conditional algorithms.
+
+# 317 4 Conclusion
+
+Potential Limitations and Broader Impact there are multiple ways in which ConBO may fail, in this work we have not investigated how ConBO or Hybrid KG suffers with poorly learnt Gaussian process hyperparameters. In many applications, a poorly chosen kernel or unoptimized hyperparameters can lead to poor performance and our proposed methods may be more sensitive or more robust to these failures than alternative approaches. We propose a general purpose optimization algorithm and analysis, we do not currently see any immediate societal impact.
+
+324 We investigate Conditional Bayesian optimization and propose ConBO. ConBO is designed from   
+325 the ground up to fully exploit the structure of conditional problems, namely that optimizing one task   
+326 helps optimize similar tasks. Hence every point should be collected to maximise the benefit of all   
+327 tasks. However, this can lead to excessive computational cost, particularly in higher dimensions.   
+328 Thus we also propose Hybrid KG that mixes past methods to be both fast and scalable.   
+329 References   
+330 [1] Victor Picheny and David Ginsbourger. A nonstationary space-time gaussian process model for   
+331 partially converged simulations. SIAM/ASA Journal on Uncertainty Quantification, 1(1):57–78,   
+332 2013.   
+333 [2] Shinkyu Jeong, Mitsuhiro Murayama, and Kazuomi Yamamoto. Efficient optimization design   
+334 method using kriging model. Journal of aircraft, 42(2):413–420, 2005.   
+335 [3] Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine   
+336 learning algorithms. In Advances in neural information processing systems, pages 2951–2959,   
+337 2012.   
+338 [4] Diariétou Sambakhé, Lauriane Rouan, Jean-Noël Bacro, and Eric Gozé. Conditional opti  
+339 mization of a noisy function using a kriging metamodel. Journal of Global Optimization,   
+340 73(3):615–636, 2019.   
+341 [5] Naijia Anna Dong, David J Eckman, Xueqi Zhao, Shane G Henderson, and Matthias Poloczek.   
+342 Empirically comparing the finite-time performance of simulation-optimization algorithms. In   
+343 2017 Winter Simulation Conference (WSC), pages 2206–2217. IEEE, 2017.   
+344 [6] Jing Xie, Peter I Frazier, and Stephen E Chick. Bayesian optimization via simulation with   
+345 pairwise sampling and correlated prior beliefs. Operations Research, 64(2):542–559, 2016.   
+346 [7] Matthias Poloczek, Jialei Wang, and Peter I Frazier. Warm starting bayesian optimization. In   
+347 2016 Winter Simulation Conference (WSC), pages 770–781. IEEE, 2016.   
+348 [8] Kevin Swersky, Jasper Snoek, and Ryan Prescott Adams. Multi-task bayesian optimization. In   
+349 Advances in Neural Information Processing Systems. Curran Associates, Inc., 2013.   
+350 [9] Supratik Paul, Konstantinos Chatzilygeroudis, Kamil Ciosek, Jean-Baptiste Mouret, Michael   
+351 Osborne, and Shimon Whiteson. Alternating optimisation and quadrature for robust control. In   
+352 Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.   
+353 [10] Saul Toscano-Palmerin and Peter I Frazier. Bayesian optimization with expensive integrands.   
+354 arXiv preprint arXiv:1803.08661, 2018.   
+355 [11] Michael Pearce and Juergen Branke. Bayesian simulation optimization with input uncertainty.   
+356 In 2017 Winter Simulation Conference (WSC), pages 2268–2278. IEEE, 2017.   
+357 [12] Wei Chu, Lihong Li, Lev Reyzin, and Robert Schapire. Contextual bandits with linear payoff   
+358 functions. In Geoffrey Gordon, David Dunson, and Miroslav Dudík, editors, Proceedings of   
+359 the Fourteenth International Conference on Artificial Intelligence and Statistics, volume 15 of   
+360 Proceedings of Machine Learning Research, pages 208–214, Fort Lauderdale, FL, USA, 11–13   
+361 Apr 2011. JMLR Workshop and Conference Proceedings.   
+362 [13] Wei Chu, Lihong Li, Lev Reyzin, and Robert Schapire. Contextual bandits with linear payoff   
+363 functions. In Proceedings of the Fourteenth International Conference on Artificial Intelligence   
+364 and Statistics, pages 208–214. JMLR Workshop and Conference Proceedings, 2011.   
+365 [14] Supratik Paul, Michael A Osborne, and Shimon Whiteson. Contextual policy optimisation.   
+366 arXiv preprint arXiv:1805.10662, 2018.   
+367 [15] Ian Char, Youngseog Chung, Willie Neiswanger, Kirthevasan Kandasamy, Andrew Oakleigh   
+368 Nelson, Mark Boyer, Egemen Kolemen, and Jeff Schneider. Offline contextual bayesian   
+369 optimization. In Advances in Neural Information Processing Systems, pages 4629–4640, 2019.   
+370 [16] Deng Huang, Theodore T Allen, William I Notz, and R Allen Miller. Sequential kriging   
+371 optimization using multiple-fidelity evaluations. Structural and Multidisciplinary Optimization,   
+372 32(5):369–382, 2006.   
+373 [17] Matthias Poloczek, Jialei Wang, and Peter Frazier. Multi-information source optimization. In   
+374 Advances in Neural Information Processing Systems, pages 4289–4299, 2017.
+
+[18] Kirthevasan Kandasamy, Gautam Dasarathy, Jeff Schneider, and Barnabás Póczos. Multi-fidelity bayesian optimisation with continuous approximations. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1799–1808. JMLR. org, 2017.   
+[19] Aaron Klein, Stefan Falkner, Simon Bartels, Philipp Hennig, and Frank Hutter. Fast Bayesian Optimization of Machine Learning Hyperparameters on Large Datasets. In Aarti Singh and Jerry Zhu, editors, Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, volume 54 of Proceedings of Machine Learning Research, pages 528–536, Fort Lauderdale, FL, USA, 20–22 Apr 2017. PMLR. [20] R. Bardenet, Mátyás Brendel, Balázs Kégl, and Michele Sebag. Collaborative hyperparameter tuning. In International Conference on Machine Learning, pages 199–207, 2013.   
+385 [21] David Ginsbourger, Jean Baccou, Clément Chevalier, Frédéric Perales, Nicolas Garland, and Yann Monerie. Bayesian adaptive reconstruction of profile optima and optimizers. SIAM/ASA Journal on Uncertainty Quantification, 2(1):490–510, 2014. [22] Michael Pearce and Juergen Branke. Continuous multi-task bayesian optimisation with correlation. European Journal of Operational Research, 270(3):1074–1085, 2018.   
+390 [23] C. E. Rasmussen and C. K. I. Williams. Gaussian Processes for Machine Learning. MIT Press, 2004. [24] D. R. Jones, M. Schonlau, and W. J. Welch. Efficient global optimization of expensive black-box functions. Journal of Global optimization, 13(4):455–492, 1998.   
+394 [25] Andreas Krause and Cheng S Ong. Contextual gaussian process bandit optimization. In Advances in neural information processing systems, pages 2447–2455, 2011.   
+396 [26] Philipp Hennig and Christian J Schuler. Entropy search for information-efficient global optimization. Journal of Machine Learning Research, 13(Jun):1809–1837, 2012. [27] J. Villemonteix, E. Vazquez, and E. Walter. An informational approach to the global optimization of expensive-to-evaluate functions. Journal of Global Optimization, 44(4):509–534, 2009. [28] J. M. HernÂŽandez-Lobato, M. W. Hoffman, and Z. Ghahramani. Predictive entropy search for efficient global optimization of black-box functions. In Advances in Neural Information Processing Systems, pages 918–926. Curran Associates, Inc., 2014.   
+403 [29] Zi Wang and Stefanie Jegelka. Max-value entropy search for efficient bayesian optimization. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 3627–3635. JMLR. org, 2017.   
+406 [30] P. Frazier, W. Powell, and S. Dayanik. The knowledge-gradient policy for correlated normal beliefs. INFORMS Journal on Computing, 21(4):599–613, 2009. [31] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. [32] Warren Scott, Peter Frazier, and Warren Powell. The correlated knowledge gradient for simulation optimization of continuous parameters using gaussian process regression. SIAM Journal on Optimization, 21(3):996–1026, 2011.   
+413 [33] Jian Wu and Peter I Frazier. Discretization-free knowledge gradient methods for bayesian optimization. arXiv preprint arXiv:1707.06541, 2017.   
+415 [34] Maximilian Balandat, Brian Karrer, Daniel Jiang, Samuel Daulton, Ben Letham, Andrew G Wilson, and Eytan Bakshy. Botorch: A framework for efficient monte-carlo bayesian optimization. Advances in Neural Information Processing Systems, 33, 2020.   
+418 [35] Michael Pearce, Matthias Poloczek, and Juergen Branke. Bayesian optimization allowing for common random numbers. arXiv preprint arXiv:1910.09259, 2019.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] ConBO is theoretically grounded, see Theorems 1-3. ConBO outperforms recently published works on a range of problems, see Section 3, ConBO is easily parallelizable, see SM Section 4.   
+(b) Did you describe the limitations of your work? [Yes] see Section 4   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] see Section 4   
+(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? [Yes] see SM Section 1 (b) Did you include complete proofs of all theoretical results? [Yes] see SM Section 1
+
+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] All code is submitted with the SM   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] all parameters for all baselines are given in SM section 3.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(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] SM section 3
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] code from Simopt.org is cited.   
+(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 benchmark test problems.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/rklp93EtwH/rklp93EtwH.md

@@ -0,0 +1,390 @@
+# AUTOMATED RELATIONAL META-LEARNING
+
+Huaxiu $\mathbf { Y a o } ^ { 1 \circ }$ , Xian $\mathbf { W } \mathbf { u } ^ { 2 }$ , Zhiqiang $\mathbf { T a o ^ { 3 } }$ , Yaliang $\mathbf { L i } ^ { 4 }$ , Bolin $\mathbf { D i n g ^ { 4 } }$ , Ruirui $\mathbf { L i } ^ { 5 }$ , Zhenhui Li1
+
+1Pennsylvania State University, 2University of Notre Dame, 3Northeastern University   
+4Alibaba Group, 5University of California, Los Angeles   
+1{huaxiuyao,JessieLi}@psu.edu, 2xwu9@nd.edu, $^ 3 { z }$ qtao@ece.neu.edu   
+4{yaliang.li,bolin.ding}@alibaba-inc.com, 5rrli@cs.ucla.edu
+
+# ABSTRACT
+
+In order to efficiently learn with small amount of data on new tasks, meta-learning transfers knowledge learned from previous tasks to the new ones. However, a critical challenge in meta-learning is the task heterogeneity which cannot be well handled by traditional globally shared meta-learning methods. In addition, current task-specific meta-learning methods may either suffer from hand-crafted structure design or lack the capability to capture complex relations between tasks. In this paper, motivated by the way of knowledge organization in knowledge bases, we propose an automated relational meta-learning (ARML) framework that automatically extracts the cross-task relations and constructs the meta-knowledge graph. When a new task arrives, it can quickly find the most relevant structure and tailor the learned structure knowledge to the meta-learner. As a result, the proposed framework not only addresses the challenge of task heterogeneity by a learned meta-knowledge graph, but also increases the model interpretability. We conduct extensive experiments on 2D toy regression and few-shot image classification and the results demonstrate the superiority of ARML over state-of-the-art baselines.
+
+# 1 INTRODUCTION
+
+Learning quickly is the key characteristic of human intelligence, which remains a daunting problem in machine intelligence. The mechanism of meta-learning is widely used to generalize and transfer prior knowledge learned from previous tasks to improve the effectiveness of learning on new tasks, which has benefited various applications, such as computer vision (Kang et al., 2019; Liu et al., 2019), natural language processing (Gu et al., 2018; Lin et al., 2019) and social good (Zhang et al., 2019; Yao et al., 2019a). Most of existing meta-learning algorithms learn a globally shared meta-learner (e.g., parameter initialization (Finn et al., 2017; 2018), meta-optimizer (Ravi & Larochelle, 2016), metric space (Snell et al., 2017; Garcia & Bruna, 2017; Oreshkin et al., 2018)). However, globally shared meta-learners fail to handle tasks lying in different distributions, which is known as task heterogeneity (Vuorio et al., 2018; Yao et al., 2019b). Task heterogeneity has been regarded as one of the most challenging issues in meta-learning, and thus it is desirable to design meta-learning models that effectively optimize each of the heterogeneous tasks.
+
+The key challenge to deal with task heterogeneity is how to customize globally shared meta-learner by using task-specific information? Recently, a handful of works try to solve the problem by learning a task-specific representation for tailoring the transferred knowledge to each task (Oreshkin et al., 2018; Vuorio et al., 2018; Lee & Choi, 2018). However, the expressiveness of these methods is limited due to the impaired knowledge generalization between highly related tasks. Recently, learning the underlying structure across tasks provides a more effective way for balancing the customization and generalization. Representatively, Yao et al. propose a hierarchically structured meta-learning method to customize the globally shared knowledge to each cluster (Yao et al., 2019b). Nonetheless, the hierarchical clustering structure completely relies on the handcrafted design which needs to be tuned carefully and may lack the capability to capture complex relationships.
+
+Hence, we are motivated to propose a framework to automatically extract underlying relational structures from historical tasks and leverage those relational structures to facilitate knowledge customization on a new task. This inspiration comes from the way of structuring knowledge in knowledge bases (i.e., knowledge graphs). In knowledge bases, the underlying relational structures across text entities are automatically constructed and applied to a new query to improve the searching efficiency. In the meta-learning problem, similarly, we aim at automatically establishing the metaknowledge graph between prior knowledge learned from previous tasks. When a new task arrives, it queries the meta-knowledge graph and quickly attends to the most relevant entities (vertices), and then takes advantage of the relational knowledge structures between them to boost the learning effectiveness with the limited training data.
+
+The proposed meta-learning framework is named as Automated Relational Meta-Learning (ARML). Specifically, the ARML automatically builds the meta-knowledge graph from meta-training tasks to memorize and organize learned knowledge from historical tasks, where each vertex represents one type of meta-knowledge (e.g., the common contour between birds and aircrafts). To learn the meta-knowledge graph at meta-training time, for each task, we construct a prototype-based relational graph for each class, where each vertex represents one prototype. The prototype-based relational graph not only captures the underlying relationship behind samples, but alleviates the potential effects of abnormal samples. The meta-knowledge graph is then learned by summarizing the information from the corresponding prototype-based relational graphs of meta-training tasks. After constructing the meta-knowledge graph, when a new task comes in, the prototype-based relational graph of the new task taps into the meta-knowledge graph for acquiring the most relevant knowledge, which further enhances the task representation and facilitates its training process.
+
+Our major contributions of the proposed ARML are three-fold: (1) it automatically constructs the meta-knowledge graph to facilitate learning a new task; (2) it empirically outperforms the state-ofthe-art meta-learning algorithms; (3) the meta-knowledge graph well captures the relationship among tasks and improves the interpretability of meta-learning algorithms.
+
+# 2 RELATED WORK
+
+Meta-learning designs models to learn new tasks or adapt to new environments quickly with a few training examples. There are mainly three research lines of meta-learning: (1) black-box amortized methods design black-box meta-learners to infer the model parameters (Ravi & Larochelle, 2016; Andrychowicz et al., 2016; Mishra et al., 2018; Gordon et al., 2019); (2) gradient-based methods aim to learn an optimized initialization of model parameters, which can be adapted to new tasks by a few steps of gradient descent (Finn et al., 2017; 2018; Lee & Choi, 2018; Yoon et al., 2018; Grant et al., 2018); (3) non-parametric methods combine parametric meta-learners and non-parametric learners to learn an appropriate distance metric for few-shot classification (Snell et al., 2017; Vinyals et al., 2016; Yang et al., 2018; Oreshkin et al., 2018; Yoon et al., 2019; Garcia & Bruna, 2017).
+
+Our work is built upon the gradient-based meta-learning methods. In the line of gradient-based meta-learning, most algorithms learn a globally shared meta-learners from previous tasks (Finn et al., 2017; Li et al., 2017; Flennerhag et al., 2019), to improve the effectiveness of learning process on new tasks. However, these algorithms typically lack the ability to handle heterogeneous tasks (i.e., tasks sample from sufficient different distributions). To tackle this challenge, recent works tailor the globally shared initialization to different tasks by customizing initialization (Vuorio et al., 2018; Yao et al., 2019b) and using probabilistic models (Yoon et al., 2018; Finn et al., 2018). Representatively, HSML customizes the globally shared initialization with a manually designed hierarchical clustering structure to balance the generalization and customization (Yao et al., 2019b). However, the handcrafted designed hierarchical structure may not accurately reflect the real structure and the clustering structure constricts the complexity of relationship. Compared with these methods, ARML leverages the most relevant structure from the automatically constructed meta-knowledge graph. Thus, ARML not only discovers more accurate underlying structures to improve the effectiveness of meta-learning algorithms, but also the meta-knowledge graph further enhances the model interpretability.
+
+# 3 PRELIMINARIES
+
+Few-shot Learning Considering a task $\mathcal { T } _ { i }$ , the goal of few-shot learning is to learn a model with a dataset $\mathcal { D } _ { i } = \{ \mathcal { D } _ { i } ^ { t r } , \mathcal { D } _ { i } ^ { t s } \}$ , where the labeled training set $\mathcal { D } _ { i } ^ { t r } = \{ \mathbf { x } _ { j } ^ { t r } , \mathbf { y } _ { j } ^ { t r } \mathbf { \bar { | \forall } } j \in [ 1 , N ^ { t r } ] \}$ only has a few samples and $\mathcal { D } _ { i } ^ { t s }$ represents the corresponding test set. A learning model (a.k.a., base model) $f$ with parameters $\theta$ are used to evaluate the effectiveness on $\mathcal { D } _ { i } ^ { t s }$ by minimizing the expected empirical loss on $\mathcal { D } _ { i } ^ { t r }$ , i.e., $\mathcal { L } ( \mathcal { D } _ { T _ { i } } ^ { t r } , \theta )$ , and obtain the optimal parameters $\theta _ { i }$ . For the regression problem, the loss function is defined based on the mean square error (i.e., $\begin{array} { r } { \sum _ { ( \mathbf { x } _ { j } , \mathbf { y } _ { j } ) \in \mathcal { D } _ { i } ^ { t r } } \| f _ { \theta } \left( \mathbf { x } _ { j } \right) - \mathbf { y } _ { j } \| _ { 2 } ^ { 2 } ) } \end{array}$ and for the classification problem, the loss function uses the cross-entropy loss (i.e., $- \textstyle \sum _ { ( \mathbf { x } _ { j } , \mathbf { y } _ { j } ) \in \mathcal { D } _ { i } ^ { t r } } \log p \big ( \mathbf { y } _ { j } | \mathbf { x } _ { j } , f _ { \theta } \big ) \big )$ . Usually, optimizing and learning parameter $\theta$ for the task $\mathcal { T } _ { i }$ with a few labeled training samples is difficult. To address this limitation, meta-learning provides us a new perspective to improve the performance by leveraging knowledge from multiple tasks.
+
+Meta-learning and Model-agnostic Meta-learning In meta-learning, a sequence of tasks $\{ \mathcal { T } _ { 1 } , . . . , \mathcal { T } _ { I } \}$ are sampled from a task-level probability distribution $p ( \mathcal { T } )$ , where each one is a few-shot learning task. To facilitate the adaption for incoming tasks, the meta-learning algorithm aims to find a well-generalized meta-learner on $I$ training tasks at meta-learning phase. At meta-testing phase, the optimal meta-learner is applied to adapt the new tasks $\mathcal { T } _ { t }$ . In this way, meta-learning algorithms are capable of adapting to new tasks efficiently even with a shortage of training data for a new task.
+
+Model-agnostic meta-learning (MAML) (Finn et al., 2017), one of the representative algorithms in gradient-based meta-learning, regards the meta-learner as the initialization of parameter $\theta$ , i.e., $\theta _ { 0 }$ and learns a well-generalized initialization $\theta _ { 0 } ^ { * }$ during the meta-training process. The optimization problem is formulated as (one gradient step as exemplary):
+
+$$
+\theta _ { 0 } ^ { * } : = \arg \operatorname* { m i n } _ { \theta _ { 0 } } \sum _ { i = 1 } ^ { I } \mathcal { L } ( f _ { \theta _ { i } } , \mathcal { D } _ { i } ^ { t s } ) = \arg \operatorname* { m i n } _ { \theta _ { 0 } } \sum _ { i = 1 } ^ { I } \mathcal { L } \big ( f _ { \theta _ { 0 } - \alpha \nabla _ { \theta } \mathcal { L } ( f _ { \theta } , \mathcal { D } _ { i } ^ { t r } ) } , \mathcal { D } _ { i } ^ { t s } \big ) .
+$$
+
+At the meta-testing phase, to obtain the adaptive parameter $\theta _ { t }$ for each new task $\mathcal { T } _ { t }$ , we finetune the initialization of parameter $\theta _ { 0 } ^ { * }$ by performing gradient updates a few steps, i.e., $f _ { \theta _ { t } } = f _ { \theta _ { 0 } ^ { \ast } - \alpha \nabla _ { \theta } \mathcal { L } ( f _ { \theta } , \mathcal { D } _ { t } ^ { t r } ) }$
+
+# 4 METHODOLOGY
+
+In this section, we introduce the details of the proposed ARML. To better explain how it works, we show its framework in Figure 1. The goal of ARML is to facilitate the learning process of new tasks by leveraging transferable knowledge learned from historical tasks. To achieve this goal, we introduce a meta-knowledge graph, which is automatically constructed at the meta-training time, to organize and memorize historical learned knowledge. Given a task, which is built as a prototypebased relational structure, it taps into the meta-knowledge graph to acquire relevant knowledge for enhancing its own representation. The enhanced prototype representations further aggregate and incorporate with meta-learner for fast and effective adaptions by utilizing a modulating function. In the following subsections, we elaborate three key components: prototype-based sample structuring, automated meta-knowledge graph construction and utilization, and task-specific knowledge fusion and adaptation, respectively.
+
+# 4.1 PROTOTYPE-BASED SAMPLE STRUCTURING
+
+Given a task which involves either classifications or regressions regarding a set of samples, we first investigate the relationships among these samples. Such relationship is represented by a graph, called prototype-based relational graph in this work, where the vertices in the graph denote the prototypes of different classes while the edges and the corresponding edge weights are created based on the similarities between prototypes. Constructing the relational graph based on prototypes instead of raw samples allows us to alleviate the issue raised by abnormal samples. As the abnormal samples, which locate far away from normal samples, could pose significant concerns especially when only a limited number of samples are available for training. Specifically, for classification problem, the prototype, denoted by $\mathbf { c } _ { i } ^ { k } \in \mathbb { R } ^ { d }$ , is defined as:
+
+$$
+\mathbf { c } _ { i } ^ { k } = \frac { 1 } { N _ { k } ^ { t r } } \sum _ { j = 1 } ^ { N _ { k } ^ { t r } } \mathcal { E } ( \mathbf { x } _ { j } ) ,
+$$
+
+where $N _ { k } ^ { t r }$ denotes the number of samples in class $k$ . $\mathcal { E }$ is an embedding function, which projects $\mathbf { x } _ { j }$ into a hidden space where samples from the same class are located closer to each other while samples from different classes stay apart. For regression problem, it is not straightforward to construct
+
+![](images/83fe0d89630929ccce224ae815324fbaaf71ab392899488fa9f1a1e2c13840cd.jpg)  
+Figure 1: The framework of ARML. For each task $\mathcal { T } _ { i }$ , ARML first builds a prototype-based relational structure $\mathcal { R } _ { i }$ by mapping the training samples $\mathcal { D } _ { i } ^ { t r }$ into prototypes, with each prototype represents one class. Then, $\mathcal { R } _ { i }$ interacts with the meta-knowledge graph $\mathcal { G }$ to acquire the most relevant historical knowledge by information propagation. Finally, the task-specific modulation tailors the globally shared initialization $\theta _ { 0 }$ by aggregating of raw prototypes and enriched prototypes, which absorbs relevant historical information from the meta-knowledge graph.
+
+the prototypes explicitly based on class information. Therefore, we cluster samples by learning an assignment matrix $\mathbf { P } _ { i } \in \mathbb { R } ^ { K \times N ^ { t r } }$ . Specifically, we formulate the process as:
+
+$$
+\mathbf P _ { i } = \mathrm { S o f t m a x } ( \mathbf W _ { p } \boldsymbol { \mathcal E } ^ { \mathrm { T } } ( \mathbf { X } ) + \mathbf b _ { p } ) , \ \mathbf c _ { i } ^ { k } = \mathbf P _ { i } [ k ] \mathcal { F } ( \mathbf { X } ) ,
+$$
+
+where $\mathbf { P } _ { i } [ k ]$ represents the $k$ -th row of $\mathbf { P } _ { i }$ . Thus, training samples are clustered to $K$ clusters, which serve as the representation of prototypes.
+
+After calculating all prototype representations $\{ \mathbf { c } _ { i } ^ { k } | \forall k \in [ 1 , K ] \}$ , which serve as the vertices in the the prototype-based relational graph $\mathcal { R } _ { i }$ , we further define the edges and the corresponding edge weights. The edge weight $A _ { \mathcal { R } _ { i } } ( \mathbf { c } _ { i } ^ { j } , \mathbf { c } _ { i } ^ { m } )$ between two prototypes $\mathbf { c } _ { i } ^ { j }$ and $\mathbf { c } _ { i } ^ { m }$ is gauged by the the similarity between them. Formally:
+
+$$
+A _ { \mathcal { R } _ { i } } ( \mathbf { c } _ { i } ^ { j } , \mathbf { c } _ { i } ^ { m } ) = \sigma ( \mathbf { W } _ { r } ( | \mathbf { c } _ { i } ^ { j } - \mathbf { c } _ { i } ^ { m } | / \gamma _ { r } ) + \mathbf { b } _ { r } ) ,
+$$
+
+where ${ \mathbf W } _ { r }$ and $ { \mathbf { b } } _ { r }$ represents learnable parameters, $\gamma _ { r }$ is a scalar and $\sigma$ is the Sigmoid function, which normalizes the weight between 0 and 1. For simplicity, we denote the prototype-based relational graph as $\mathcal { R } _ { i } = ( \mathbf { C } _ { \mathcal { R } _ { i } } , \mathbf { A } _ { \mathcal { R } _ { i } } )$ , where $\mathbf { C } _ { \mathcal { R } _ { i } } = \{ \mathbf { c } _ { i } ^ { j } | \forall j \in \lbrack \bar { 1 } , K \rbrack \} \in \mathbb { R } ^ { K \times d }$ represent a set of vertices, with each one corresponds to the prototype from a class, while $\mathbf { A } _ { \mathcal { R } _ { i } } = \{ | \bar { A _ { \mathcal { R } _ { i } } } ( \mathbf { c } _ { i } ^ { j } , \mathbf { c } _ { i } ^ { m } ) | \forall j , m \in [ 1 , K ] \} \in \mathbb { R } ^ { K \times K }$ gives the adjacency matrix, which indicates the proximity between prototypes.
+
+# 4.2 AUTOMATED META-KNOWLEDGE GRAPH CONSTRUCTION AND UTILIZATION
+
+In this section, we first discuss how to organize and distill knowledge from historical learning process and then expound how to leverage such knowledge to benefit the training of new tasks. To organize and distill knowledge from historical learning process, we construct and maintain a meta-knowledge graph. The vertices represent different types of meta-knowledge (e.g., the common contour between aircrafts and birds) and the edges are automatically constructed to reflect the relationship between meta-knowledge. When serving a new task, we refer to the meta-knowledge, which allows us to efficiently and automatically identify relational knowledge from previous tasks. In this way, the training of a new task can benefit from related training experience and get optimized much faster than otherwise possible. In this paper, the meta-knowledge graph is automatically constructed at the meta-training phase. The details of the construction are elaborated as follows:
+
+Assuming the representation of an vertex $g$ is given by $\mathbf { h } ^ { g } \in \mathbb { R } ^ { d }$ , we define the meta-knowledge graph as $\mathcal { G } = ( \mathbf { H } _ { \mathcal { G } } , \mathbf { A } _ { \mathcal { G } } )$ , where $\mathbf { H } _ { \mathcal { G } } = \{ \mathbf { h } ^ { j } | \forall j \in [ 1 , G ] \} \in \mathbb { R } ^ { G \times d }$ and $\mathbf { A } _ { \mathcal { G } } = \{ A _ { \mathcal { G } } ( \mathbf { h } ^ { j } , \mathbf { h } ^ { m } ) \vert \forall j , m \ : \ : \in$ $[ 1 , G ] \} \in \mathbb { R } ^ { G \times G }$ denote the vertex feature matrix and vertex adjacency matrix, respectively. To better explain the construction of the meta-knowledge graph, we first discuss the vertex representation $\mathbf { H } _ { \mathcal { G } }$ . During meta-training, tasks arrive one after another in a sequence and their corresponding vertices representations are expected to be updated dynamically in a timely manner. Therefore, the vertex representation of meta-knowledge graph are defined to get parameterized and learned at the training time. Moreover, to encourage the diversity of meta-knowledge encoded in the meta-knowledge graph, the vertex representations are randomly initialized. Analogous to the definition of weight in the prototype-based relational graph $\mathcal { R } _ { i }$ in equation 4, the weight between a pair of vertices $j$ and $m$ is constructed as:
+
+$$
+A _ { \mathcal { G } } ( \mathbf { h } ^ { j } , \mathbf { h } ^ { m } ) = \sigma ( \mathbf { W } _ { o } ( | \mathbf { h } ^ { j } - \mathbf { h } ^ { m } | / \gamma _ { o } ) + \mathbf { b } _ { o } ) ,
+$$
+
+where $\mathbf { W } _ { o }$ and ${ \bf b } _ { o }$ represent learnable parameters and $\gamma _ { o }$ is a scalar.
+
+To enhance the learning of new tasks with involvement of historical knowledge, we query the prototype-based relational graph in the meta-knowledge graph to obtain the relevant knowledge in history. The ideal query mechanism is expected to optimize both graph representations simultaneously at the meta-training time, with the training of one graph facilitating the training of the other. In light of this, we construct a super-graph $\boldsymbol { S } _ { i }$ by connecting the prototype-based relational graph $\mathcal { R } _ { i }$ with the meta-knowledge graph $\mathcal { G }$ for each task $\tau _ { i }$ . The union of the vertices in $\mathcal { R } _ { i }$ and $\mathcal { G }$ contributes to the vertices in the super-graph. The edges in $\mathcal { R } _ { i }$ and $\mathcal { G }$ are also reserved in the super-graph. We connect $\mathcal { R } _ { i }$ with $\mathcal { G }$ by creating links between the prototype-based relational graph with the meta-knowledge graph. The link between prototype $\mathbf { c } _ { i } ^ { j }$ in prototype-based relational graph and vertex $\mathbf { h } ^ { m }$ in metaknowledge graph is weighted by the similarity between them. More precisely, for each prototype $\mathbf { c } _ { i } ^ { j }$ the link weight $A _ { S } ( \mathbf { c } _ { i } ^ { j } , \bar { \mathbf { h } ^ { m } } )$ is calculated by applying softmax over Euclidean distances between $\mathbf { c } _ { i } ^ { j }$ and $\{ \mathbf { h } ^ { m } | \forall m \in [ 1 , G ] \}$ as follows:
+
+$$
+A s ( \mathbf { c } _ { i } ^ { j } , \mathbf { h } ^ { k } ) = \frac { \exp ( - \| ( \mathbf { c } _ { i } ^ { j } - \mathbf { h } ^ { k } ) / \gamma _ { s } \| _ { 2 } ^ { 2 } / 2 ) } { \sum _ { k ^ { \prime } = 1 } ^ { K } \exp ( - \| ( \mathbf { c } _ { i } ^ { j } - \mathbf { h } ^ { k ^ { \prime } } ) / \gamma _ { s } \| _ { 2 } ^ { 2 } / 2 ) } ,
+$$
+
+where $\gamma _ { s }$ is a scaling factor. We denote the intra-adjacent matrix as $\mathbf { A } _ { \mathcal { S } } ~ = ~ \{ A _ { \mathcal { S } } ( \mathbf { c } _ { i } ^ { j } , \mathbf { h } ^ { m } ) | \forall j ~ \in$ $[ 1 , K ] , m \in [ 1 , G ] \} \in \bar { \mathbb { R } } ^ { K \times G }$ . Thus, for task $\mathcal { T } _ { i }$ , the adjacent matrix and feature matrix of super-graph ${ \cal { S } } _ { i } = ( { \bf { A } } _ { i } , { \bf { H } } _ { i } )$ is defined as $\mathbf { A } _ { i } = \left( \mathbf { A } _ { \mathcal { R } _ { i } } , \mathbf { A } _ { \mathcal { S } } ; \mathbf { A } _ { \mathcal { S } } ^ { \mathrm { T } } , \tilde { \mathbf { A } } _ { \mathcal { G } } \right) \in \mathbb { R } ^ { \left( K + G \right) \times \left( K + G \right) }$ and $\mathbf { H } _ { i } = ( \mathbf { C } _ { \mathcal { R } _ { i } } ; \mathbf { H } _ { \mathcal { G } } ) \in$ $\mathbb { R } ^ { ( K + G ) \times d }$ , respectively.
+
+After constructing the super-graph $\boldsymbol { S } _ { i }$ , we are able to propagate the most relevant knowledge from meta-knowledge graph $\mathcal { G }$ to the prototype-based relational graph $\mathcal { R } _ { i }$ by introducing a Graph Neural Networks (GNN). In this work, following the “message-passing” framework (Gilmer et al., 2017), the GNN is formulated as:
+
+$$
+\mathbf { H } _ { i } ^ { ( l + 1 ) } = \mathrm { M P } ( \mathbf { A } _ { i } , \mathbf { H } _ { i } ^ { ( l ) } ; \mathbf { W } ^ { ( l ) } ) ,
+$$
+
+where $\mathrm { M P } ( \cdot )$ is the message passing function and has several possible implementations (Hamilton et al., 2017; Kipf & Welling, 2017; Velickovi ˇ c et al., 2018), ´ $\mathbf { \bar { H } } _ { i } ^ { ( l ) }$ is the vertex embedding after $l$ layers of GNN and $\mathbf { W } ^ { ( l ) }$ is a learnable weight matrix of layer $l$ . The input $\mathbf { H } _ { i } ^ { ( 0 ) } = \mathbf { H } _ { i }$ . After stacking $L$ GNN layers, we get the information-propagated feature representation for the prototype-based relational graph $\mathcal { R } _ { i }$ as the top- $K$ rows of $\mathbf { H } _ { i } ^ { ( L ) }$ , which is denoted as $\hat { \mathbf { C } } \mathcal { R } _ { i } = \{ \hat { \mathbf { c } } _ { i } ^ { j } | j \in [ 1 , K ] \}$ .
+
+# 4.3 TASK-SPECIFIC KNOWLEDGE FUSION AND ADAPTATION
+
+After propagating information form meta-knowledge graph to prototype-based relational graph, in this section, we discuss how to learn a well-generalized meta-learner for fast and effective adaptions to new tasks with limited training data. To tackle the challenge of task heterogeneity, in this paper, we incorporate task-specific information to customize the globally shared meta-learner (e.g., initialization here) by leveraging a modulating function, which has been proven to be effective to provide customized initialization in previous studies (Wang et al., 2019; Vuorio et al., 2018).
+
+The modulating function relies on well-discriminated task representations, while it is difficult to learn all representations by merely utilizing the loss signal derived from the test set $\mathcal { D } _ { i } ^ { t s }$ . To encourage such stability, we introduce two reconstructions by utilizing two auto-encoders. There are two collections of parameters, i.e, $\mathbf { C } _ { \mathcal { R } _ { i } }$ and $\hat { \mathbf { C } } _ { \mathcal { R } _ { i } }$ , which contribute the most to the creation of the task-specific meta-learner. $\mathbf { C } \mathcal { R } _ { i }$ express the raw prototype information without tapping into the meta-knowledge graph, while $\hat { \mathbf { C } } _ { \mathcal { R } _ { i } }$ give the prototype representations after absorbing the relevant knowledge from the meta-knowledge graph. Therefore, the two reconstructions are built on $\mathbf { C } \mathcal { R } _ { i }$ and $\hat { \mathbf { C } } \mathcal { R } _ { i }$ . To reconstruct $\mathbf { C } _ { \mathcal { R } _ { i } }$ , an aggregator $\mathrm { A G } ^ { q } ( \cdot )$ (e.g., recurrent network, fully connected layers) is involved to encode $\mathbf { C } _ { \mathcal { R } _ { i } }$ into a dense representation, which is further fed into a decoder $\mathrm { A G } _ { d e c } ^ { q } ( \cdot )$ to achieve reconstructions.
+
+# Algorithm 1 Meta-Training Process of ARML
+
+Require: $p ( \mathcal { T } )$ : distribution over tasks; $K$ : Number of vertices in meta-knowledge graph; $\alpha$ : stepsize for gradient descent of each task (i.e., inner loop stepsize); $\beta$ : stepsize for meta-optimization (i.e., outer loop stepsize); $\mu _ { 1 } , \mu _ { 2 }$ : balancing factors in loss function   
+1: Randomly initialize all learnable parameters $\Phi$   
+2: while not done do   
+3: Sample a batch of tasks $\{ T _ { i } | i \in [ 1 , I ] \}$ from $p ( \mathcal { T } )$   
+4: for all $\tau _ { i }$ do   
+5: Sample training set $\mathcal { D } _ { i } ^ { t r }$ and testing set $\mathcal { D } _ { i } ^ { t s }$   
+6: Construct the prototype-based relational graph $\mathcal { R } _ { i }$ by computing prototype in equation 2 and weight in equation 4   
+7: Compute the similarity between each prototype and meta-knowledge vertex in equation 6 and construct the super-graph $\boldsymbol { S } _ { i }$   
+8: Apply GNN on super-graph $\boldsymbol { S } _ { i }$ and get the information-propagated representation $\hat { \mathbf { C } } _ { \mathcal { R } _ { i } }$   
+9: Aggregate $\mathbf { C } \mathcal { R } _ { i }$ in equation 8 and $\tilde { \hat { \mathbf { C } } } _ { \mathcal { R } _ { i } }$ in equation 9 to get the representations ${ \bf q } _ { i } , { \bf t } _ { i }$ and reconstruction loss $\mathcal { L } _ { q }$ , $\mathcal { L } _ { t }$   
+10: Compute the task-specific initialization $\theta _ { 0 i }$ in equation 10 and update parameters $\theta _ { i } \ =$ $\theta _ { 0 i } - \mathrm { \bar { \alpha } } \mathrm { \nabla } _ { \alpha } \mathcal { L } ( f _ { \theta } , \mathcal { D } _ { i } ^ { t r } )$
+
+Then, the corresponded task representation ${ \bf q } _ { i }$ of $\mathbf { C } _ { \mathcal { R } _ { i } }$ is summarized by applying a mean pooling operator over prototypes on the encoded dense representation. Formally,
+
+$$
+{ \bf q } _ { i } = \mathrm { M e a n P o o l } ( \mathrm { A G } ^ { q } ( { \bf C } _ { \mathcal { R } _ { i } } ) ) = \frac { 1 } { N ^ { t r } } \sum _ { j = 1 } ^ { N ^ { t r } } ( \mathrm { A G } ^ { q } ( { \bf c } _ { i } ^ { j } ) ) , ~ \mathcal { L } _ { q } = \| { \bf C } _ { \mathcal { R } _ { i } } - \mathrm { A G } _ { d e c } ^ { q } ( \mathrm { A G } ^ { q } ( { \bf C } _ { \mathcal { R } _ { i } } ) ) \| _ { F } ^ { 2 }
+$$
+
+Similarly, we reconstruct $\hat { \mathbf { C } } _ { \mathcal { R } _ { i } }$ and get the corresponded task representation $\mathbf { t } _ { i }$ as follows:
+
+$$
+\mathbf { t } _ { i } = \operatorname { M e a n P o o l } ( \operatorname { A G } ^ { t } ( \hat { \mathbf { C } } _ { \mathcal { R } _ { i } } ) ) = \frac { 1 } { N ^ { t r } } \sum _ { j = 1 } ^ { N ^ { t r } } ( \operatorname { A G } ^ { t } ( \hat { \mathbf { c } } _ { i } ^ { j } ) ) , \mathcal { L } _ { t } = \Vert \hat { \mathbf { C } } _ { \mathcal { R } _ { i } } - \operatorname { A G } _ { d e c } ^ { t } ( \operatorname { A G } ^ { t } ( \hat { \mathbf { C } } _ { \mathcal { R } _ { i } } ) ) \Vert _ { F } ^ { 2 }
+$$
+
+The reconstruction errors in Equations 8 and 9 pose an extra constraint to enhance the training stability, leading to improvement of task representation learning.
+
+After getting the task representation ${ \bf q } _ { i }$ and $\mathbf { t } _ { i }$ , the modulating function is then used to tailor the task-specific information to the globally shared initialization $\theta _ { 0 }$ , which is formulated as:
+
+$$
+\theta _ { 0 i } = \sigma ( \mathbf { W } _ { g } ( \mathbf { t } _ { i } \oplus \mathbf { q } _ { i } ) + \mathbf { b } _ { g } ) \circ \theta _ { 0 } ,
+$$
+
+where $\mathbf { W } _ { g }$ and ${ \bf b } _ { g }$ is learnable parameters of a fully connected layer. Note that we adopt the Sigmoid gating as exemplary and more discussion about different modulating functions can be found in ablation studies of Section 5.
+
+For each task $\mathcal { T } _ { i }$ , we perform the gradient descent process from $\theta _ { 0 i }$ and reach its optimal parameter $\theta _ { i }$ Combining the reconstruction loss $\mathcal { L } _ { t }$ and $\mathcal { L } _ { q }$ with the meta-learning loss defined in equation 1, the overall objective function of ARML is:
+
+$$
+\operatorname* { m i n } _ { \Phi } \mathcal { L } _ { a l l } = \operatorname* { m i n } _ { \Phi } \mathcal { L } + \mu _ { 1 } \mathcal { L } _ { t } + \mu _ { 2 } \mathcal { L } _ { q } = \operatorname* { m i n } _ { \Phi } \sum _ { i = 1 } ^ { I } \mathcal { L } \big ( f _ { \theta _ { 0 i } - \alpha \nabla _ { \theta } \mathcal { L } ( f _ { \theta } , \mathcal { D } _ { i } ^ { t r } ) } , \mathcal { D } _ { i } ^ { t s } \big ) + \mu _ { 1 } \mathcal { L } _ { t } + \mu _ { 2 } \mathcal { L } _ { q } ,
+$$
+
+where $\mu _ { 1 }$ and $\mu _ { 2 }$ are introduced to balance the importance of these three items. $\Phi$ represents all learnable parameters. The algorithm of meta-training process of ARML is shown in Alg. 2. The details of the meta-testing process of ARML are available in Appendix A.
+
+# 5 EXPERIMENTS
+
+In this section, we conduct extensive experiments to demonstrate the effectiveness of the ARML on 2D regression and few-shot classification.
+
+# 5.1 EXPERIMENTAL SETTINGS
+
+Methods for Comparison We compare our proposed ARML with two types of baselines: (1) Gradient-based meta-learning methods: both globally shared methods (MAML (Finn et al., 2017), Meta-SGD (Li et al., 2017)) and task-specific methods (MT-Net (Lee & Choi, 2018), MUMOMAML (Vuorio et al., 2018), HSML (Yao et al., 2019b), BMAML (Yoon et al., 2018)) are considered for comparison. (2) Other meta-learning methods (non-parametric and black box amortized methods): we select globally shared methods VERSA (Gordon et al., 2019), Prototypical Network (ProtoNet) (Snell et al., 2017), TapNet (Yoon et al., 2019) and task-specific method TADAM (Oreshkin et al., 2018) as baselines. Following the traditional settings, non-parametric baselines are only used in few-shot classification. Detailed implementations of baselines are discussed in Appendix B.3.
+
+Hyperparameter Settings For the aggregated function in autoencoder structure ( $\mathrm { A G } ^ { t }$ , $\mathrm { A G } _ { d e c } ^ { t }$ $\operatorname { A G } ^ { q }$ , $\mathrm { A G } _ { d e c } ^ { q } )$ , we use the GRU as the encoder and decoder in this structure. We adopt one layer GCN (Kipf & Welling, 2017) with tanh activation as the implementation of GNN in equation 7. For the modulation network, we test sigmoid, tanh and Film modulation, and find that sigmoid modulation achieves best performance. Thus, in the future experiment, we set the sigmoid modulation as modulating function. More detailed discussion about experiment settings are presented in Appendix B.
+
+# 5.2 2D REGRESSION
+
+Dataset Description In 2D regression problem, we adopt the similar regression problem settings as (Finn et al., 2018; Vuorio et al., 2018; Yao et al., 2019b; Rusu et al., 2019), which includes several families of functions. In this paper, to model more complex relational structures, we design a 2D regression problem rather than traditional 1D regression. Input $x \sim U [ 0 . 0 , 5 . 0 ]$ and $y \sim U [ 0 . 0 , 5 . 0 ]$ are sampled randomly and random Gaussian noisy with standard deviation 0.3 is added to the output. Furthermore, six underlying functions are selected, including (1) Sinusoids: $z ( x , y ) =$ $a _ { s } s i n ( w _ { s } x + b _ { s } )$ , where $a _ { s } \sim U [ 0 . 1 , 5 . 0 ]$ , $b _ { s } \sim U [ 0 , 2 \pi ] w _ { s } \sim U [ 0 . 8 , 1 . 2 ] ;$ (2) Line: $z ( x , y ) = a _ { l } x + b _ { l }$ , where $a _ { l } \sim U [ - 3 . 0 , 3 . 0 ]$ , $b _ { l } \sim U [ - 3 . 0 , 3 . 0 ]$ ; (3) Quadratic: $z ( x , y ) = a _ { q } x ^ { 2 } + b _ { q } x + c _ { q }$ , where $a _ { q } \sim$ $U [ - 0 . 2 , 0 . 2 ]$ , $b _ { q } \sim U [ - 2 . 0 , 2 . 0 ]$ , $c _ { q } \sim U [ - 3 . 0 , 3 . 0 ]$ ; (4) Cubic: $z ( x , y ) = a _ { c } x ^ { 3 } + b _ { c } x ^ { 2 } + c _ { c } x + d _ { c }$ , where $a _ { c } \sim U [ - 0 . 1 , 0 . 1 ]$ , $b _ { c } \sim U [ - 0 . 2 , 0 . 2$ ], $c _ { c } \sim U [ - 2 . 0 , 2 . 0 ]$ , $d _ { c } \sim U [ - 3 . 0 , 3 . 0 ]$ ; (5) Quadratic Surface: $z ( x , y ) = a _ { q s } x ^ { 2 } + b _ { q s } y ^ { 2 }$ , where $a _ { q s } \sim U [ - 1 . 0 , 1 . 0$ ], $b _ { q s } \sim U [ - 1 . 0 , 1 . 0 ]$ ; (6) Ripple: $z ( x , y ) =$ $s i n ( - a _ { r } ( x ^ { 2 } + y ^ { 2 } ) ) + b _ { r }$ , where $a _ { r } \sim U [ - 0 . 2 , 0 . 2$ ], $b _ { r } \sim U [ - 3 . 0 , 3 . 0 ]$ . Note that, function 1-4 are located in the subspace of $y = 1$ . Follow (Finn et al., 2017), we use two fully connected layers with 40 neurons as the base model. The number of vertices of meta-knowledge graph is set as 6.
+
+Results and Analysis In Figure 2, we summarize the interpretation of meta-knowledge graph (see top figure, and more cases are provided in Figure 8 of Appendix G.4) and the the qualitative results (see bottom table) of 10-shot 2D regression. In the bottom table, we can observe that ARML achieves the best performance as compared to competitive gradient-based meta-learning methods, i.e., globally shared models and task-specific models. This finding demonstrates that the meta-knowledge graph is necessary to model and capture task-specific information. The superior performance can also be interpreted in the top figure. In the left, we show the heatmap between prototypes and meta-knowledge vertices (darker color means higher similarity). We can see that sinusoids and line activate V1 and V4, which may represent curve and line, respectively. V1 and V4 also contribute to quadratic and quadratic surface, which also show the similarity between these two families of functions. V3 is activated in P0 of all functions and the quadratic surface and ripple further activate V1 in P0, which may show the different between 2D functions and 3D functions (sinusoid, line, quadratic and cubic lie in the subspace). Specifically, in the right figure, we illustrate the meta-knowledge graph, where we set a threshold to filter the link with low similarity score and show the rest. We can see that V3 is the most popular vertice and connected with V1, V5 (represent curve) and V4 (represent line). V1 is further connected with V5, demonstrating the similarity of curve representation.
+
+# 5.3 FEW-SHOT CLASSIFICATION
+
+Dataset Description and Settings In the few-shot classification problem, we first use the benchmark proposed in (Yao et al., 2019b), where four fine-grained image classification datasets are included (i.e., CUB-200-2011 (Bird), Describable Textures Dataset (Texture), FGVC of Aircraft (Aircraft), and FGVCx-Fungi (Fungi)). For each few-shot classification task, it samples classes from one of four datasets. In this paper, we call this dataset as Plain-Multi and each fine-grained dataset as subdataset.
+
+![](images/a35d3c90b440f97591e568716c4d2972a6fef51317ac1eb4b693199e18e527d7.jpg)
+
+Then, to demonstrate the effectiveness of our proposed model for handling more complex underlying structures, in this paper, we increase the difficulty of few-shot classification problem by introducing two image filters: blur filter and pencil filter. Similar to (Jerfel et al., 2019), for each image in PlainMulti, one artistic filters are applied to simulate a changing distribution of few-shot classification tasks. After applying the filters, the total number of subdatasets is 12 and each task is sampled from one of them. This data is named as Art-Multi. More detailed descriptions of the effect of different filters are discussed in Appendix C.
+
+Following the traditional meta-learning settings, all datasets are divided into meta-training, metavalidation and meta-testing classes. The traditional N-way K-shot settings are used to split training and test set for each task. We adopt the standard four-block convolutional layers as the base learner (Finn et al., 2017; Snell et al., 2017) for ARML and all baselines for a fair comparison. The number of vertices of meta-knowledge graph for Plain-Multi and Art-Multi datasets are set as 4 and 8, respectively. Additionally, for the miniImagenet and tieredImagenet (Ren et al., 2018), similar to (Finn et al., 2018), which tasks are constructed from a single domain and do not have heterogeneity, we compare our proposed ARML with baseline models and present the results in Appendix D.
+
+Overall Performance Experimental results for Plain-Multi and Art-Multi are shown in Table 1 and Table 2, respectively. For each dataset, the performance accuracy with $9 5 \%$ confidence interval is reported. Due to the space limitation, in Art-Multi dataset, we only show the average value of each filter here. The full results are shown in Table 8 of Appendix E. In these two tables, first, we can observe that task-specific gradient-based models (MT-Net, MUMOMAML, HSML, BMAML) significantly outperforms globally shared models (MAML, Meta-SGD). Second, compared ARML with other task-specific gradient-based meta-learning methods, the better performance confirms that ARML can model and extract task-specific information more accurately by leveraging the constructed meta-knowledge graph. Especially, the performance gap between the ARML and HSML verifies the benefits of relational structure compared with hierarchical clustering structure. Third, as a gradientbased meta-learning algorithm, ARML can also outperform methods of other research lines (i.e., ProtoNet, TADAM, TapNet and VERSA). Finally, to show the effectiveness of proposed components in ARML, we conduct comprehensive ablation studies in Appendix F. The results further demonstrate the effectiveness of prototype-based relational graph and meta-knowledge graph.
+
+Analysis of Constructed Meta-knowledge Graph In this section, we conduct extensive qualitative analysis for the constructed meta-knowledge graph, which is regarded as the key component in ARML. Due to the space limit, we present the results on Art-Multi datasets here and the analysis of Plain-Multi with similar observations is discussed in Appendix G.1. We further analyze the effect of different number of vertices in meta-knowledge graph in Appendix G.2 and conduct a comparison with HSML about the learned structure in Appendix G.3.
+
+Table 1: Overall few-shot classification results (accuracy $\pm ~ 9 5 \%$ confidence) on Plain-Multi dataset.   
+
+<table><tr><td>Settings</td><td>Algorithms</td><td>Data: Bird</td><td>Data: Texture</td><td>Data: Aircraft</td><td>Data: Fungi</td></tr><tr><td rowspan="9">5-way 1-shot</td><td>VERSA</td><td>53.40 ± 1.41%</td><td>30.43 ± 1.30%</td><td>50.60 ± 1.34%</td><td>40.40 ±1.40%</td></tr><tr><td>ProtoNet</td><td>54.11 ± 1.38%</td><td>32.52 ± 1.28%</td><td>50.63 ± 1.35%</td><td>41.05 ± 1.37%</td></tr><tr><td>TapNet</td><td>54.90 ± 1.34%</td><td>32.44 ± 1.23%</td><td>51.22 ± 1.34%</td><td>42.88 ± 1.35%</td></tr><tr><td>TADAM</td><td>56.58 ± 1.34%</td><td>33.34 ± 1.27%</td><td>53.24 ± 1.33%</td><td>43.06 ± 1.33%</td></tr><tr><td>MAML</td><td>53.94 ± 1.45%</td><td>31.66 ± 1.31%</td><td>51.37 ± 1.38%</td><td>42.12 ± 1.36%</td></tr><tr><td>MetaSGD</td><td>55.58 ± 1.43%</td><td>32.38 ± 1.32%</td><td>52.99 ± 1.36%</td><td>41.74 ± 1.34%</td></tr><tr><td>BMAML</td><td>54.89 ± 1.48%</td><td>32.53 ± 1.33%</td><td>53.63 ± 1.37%</td><td>42.50 ± 1.33%</td></tr><tr><td>MT-Net</td><td>58.72 ±1.43%</td><td>32.80 ± 1.35%</td><td>47.72 ± 1.46%</td><td>43.11 ± 1.42%</td></tr><tr><td>MUMOMAML HSML</td><td>56.82 ±1.49%</td><td>33.81 ± 1.36%</td><td>53.14 ± 1.39%</td><td>42.22 ± 1.40%</td></tr><tr><td></td><td></td><td>60.98 ± 1.50%</td><td>35.01 ± 1.36%</td><td>57.38 ± 1.40%</td><td>44.02 ± 1.39%</td></tr><tr><td rowspan="10">5-way</td><td>ARML</td><td>62.33 ±1.47%</td><td>35.65 ±1.40%</td><td>58.56 ± 1.41%</td><td>44.82 ±1.38%</td></tr><tr><td>VERSA</td><td>65.86 ± 0.73%</td><td>37.46 ± 0.65%</td><td>62.81 ± 0.66%</td><td>48.03±0.78%</td></tr><tr><td>ProtoNet</td><td>68.67 ± 0.72%</td><td>45.21 ± 0.67%</td><td>65.29 ± 0.68%</td><td>51.27 ± 0.81%</td></tr><tr><td>TapNet</td><td>69.07 ± 0.74%</td><td>45.54± 0.68%</td><td>67.16 ± 0.66%</td><td>51.08 ± 0.80%</td></tr><tr><td>TADAM</td><td>69.13 ± 0.75%</td><td>45.78 ± 0.65%</td><td>69.87 ± 0.66%</td><td>53.15 ± 0.82%</td></tr><tr><td>MAML</td><td>68.52 ±0.79%</td><td>44.56 ± 0.68%</td><td>66.18 ± 0.71%</td><td>51.85 ± 0.85%</td></tr><tr><td>MetaSGD</td><td>67.87 ± 0.74%</td><td>45.49 ± 0.68%</td><td>66.84 ±0.70%</td><td>52.51 ± 0.81%</td></tr><tr><td>BMAML</td><td>69.01 ±0.74%</td><td>46.06 ± 0.69%</td><td>65.74 ± 0.67%</td><td>52.43±0.84%</td></tr><tr><td>MT-Net</td><td>69.22 ±0.75%</td><td>46.57 ± 0.70%</td><td>63.03 ±0.69%</td><td>53.49 ± 0.83%</td></tr><tr><td>MUMOMAML</td><td>70.49 ± 0.76%</td><td>45.89 ± 0.69%</td><td>67.31 ± 0.68%</td><td>53.96 ± 0.82%</td></tr><tr><td>HSML</td><td>71.68 ± 0.73%</td><td>48.08 ±0.69%</td><td></td><td>73.49 ± 0.68%</td><td>56.32 ± 0.80%</td></tr><tr><td>ARML</td><td></td><td>73.34± 0.70%</td><td>49.67 ± 0.67%</td><td>74.88± 0.64%</td><td>57.55 ± 0.82%</td></tr></table>
+
+To analyze the learned meta-knowledge graph, for each subdataset, we randomly select one task as exemplary (see Figure 9 of Appendix G.4 for more cases). For each task, in the left part of Figure 3, we show the similarity heatmap between prototypes and vertices in meta-knowledge graph, where deeper color means higher similarity. V0-V8 and P1-P5 denote the different vertices and prototypes, respectively. The meta-knowledge graph is also illustrated in the right part. Similar to the graph in 2D regression, we set a threshold to filter links with low similarity and illustrate the rest of them. First, we can see that the V1 is mainly activated by bird and aircraft (including all filters), which may reflect the shape similarity between bird and aircraft. Second, V2, V3, V4 are firstly activated by texture and they form a loop in the meta-knowledge graph. Especially, V2 also benefits images with blur and pencil filters. Thus, V2 may represent the main texture and facilitate the training process on other subdatasets. The meta-knowledge graph also shows the importance of V2 since it is connected with almost all other vertices. Third, when we use blur filter, in most cases (bird blur, texture blur, fungi blur), V7 is activated. Thus, V7 may show the similarity of images with blur filter. In addition, the connection between V7 and V2 and V3 show that classifying blur images may depend on the texture information. Fourth, V6 (activated by aircraft mostly) connects with V2 and V3, justifying the importance of texture information to classify the aircrafts.
+
+# 6 CONCLUSION
+
+In this paper, to improve the effectiveness of meta-learning for handling heterogeneous task, we propose a new framework called ARML, which automatically extract relation across tasks and construct a meta-knowledge graph. When a new task comes in, it can quickly find the most relevant relations through the meta-knowledge graph and use this knowledge to facilitate its training process. The experiments demonstrate the effectiveness of our proposed algorithm.
+
+In the future, we plan to investigate the problem in the following directions: (1) we are interested to investigate the more explainable semantic meaning in the meta-knowledge graph on this problem; (2)
+
+Table 2: Overall few-shot classification results (accuracy $\pm ~ 9 5 \%$ confidence) on Art-Multi dataset.   
+
+<table><tr><td>Settings</td><td>Algorithms</td><td>Avg. Original</td><td>Avg. Blur</td><td>Avg. Pencil</td></tr><tr><td rowspan="7">5-way, 1-shot</td><td>VERSA</td><td>43.91 ± 1.35%</td><td>41.98 ± 1.35%</td><td>38.70 ± 1.33%</td></tr><tr><td>Protonet TapNet</td><td>42.08 ± 1.34%</td><td>40.51 ± 1.37%</td><td>36.24 ± 1.35%</td></tr><tr><td>TADAM</td><td>42.15 ± 1.36% 44.73 ± 1.33%</td><td>41.16 ± 1.34% 42.44 ± 1.35%</td><td>37.25 ± 1.33% 39.02 ± 1.34%</td></tr><tr><td>MAML</td><td>42.70 ± 1.35%</td><td>40.53 ± 1.38%</td><td></td></tr><tr><td>MetaSGD</td><td>44.21± 1.38%</td><td>42.36 ± 1.39%</td><td>36.71 ± 1.37%</td></tr><tr><td>MT-Net</td><td>43.94±1.40%</td><td>41.64 ± 1.37%</td><td>37.21 ± 1.39% 37.79 ±1.38%</td></tr><tr><td>BMAML MUMOMAML</td><td>43.66 ± 1.36%</td><td>41.08 ± 1.35%</td><td>37.28 ± 1.39%</td></tr><tr><td rowspan="7"></td><td>HSML</td><td>45.63±1.39%</td><td>41.59 ± 1.38%</td><td>39.24±1.36%</td></tr><tr><td></td><td>45.68 ± 1.37%</td><td>42.62 ± 1.38%</td><td>39.78 ± 1.36%</td></tr><tr><td>ARML VERSA</td><td>47.92 ± 1.34%</td><td>44.43 ± 1.34%</td><td>41.44 ±1.34%</td></tr><tr><td>Protonet</td><td>55.03 ±0.71%</td><td>53.41 ±0.70%</td><td>47.93± 0.70%</td></tr><tr><td></td><td>58.12 ±0.74%</td><td>55.07 ± 0.73%</td><td>50.15 ± 0.74%</td></tr><tr><td>TapNet TADAM</td><td>57.77 ± 0.73%</td><td>55.21 ± 0.72%</td><td>50.68±0.71%</td></tr><tr><td>MAML</td><td>60.35 ± 0.72%</td><td>58.36 ± 0.73%</td><td>53.15 ± 0.74%</td></tr><tr><td rowspan="6">5-way, 5-shot</td><td></td><td>58.30±0.74%</td><td>55.71 ± 0.74%</td><td>49.59 ± 0.73%</td></tr><tr><td>MetaSGD</td><td></td><td></td><td></td></tr><tr><td>BMAML</td><td>57.82± 0.72%</td><td>55.54 ± 0.73%</td><td>50.24± 0.72%</td></tr><tr><td>MT-Net</td><td>58.84± 0.73%</td><td>56.21 ± 0.71%</td><td>51.22 ± 0.73%</td></tr><tr><td>MUMOMAML</td><td>57.95 ± 0.74%</td><td>54.65 ± 0.73%</td><td>49.18 ± 0.73%</td></tr><tr><td>HSML ARML</td><td>58.60 ±0.75% 60.63±0.73%</td><td>56.29 ±0.72% 57.91 ± 0.72%</td><td>51.15 ± 0.73% 53.93 ± 0.72%</td></tr></table>
+
+![](images/02c4b8aaf7aa8090fb0901fc4a86eab732165f6e1e6874a68dc9590b63b9b7be.jpg)  
+Figure 3: Interpretation of meta-knowledge graph on Art-Multi dataset. For each subdataset, we randomly select one task from them. In the left, we show the similarity heatmap between prototypes (P0-P5) and meta-knowledge vertices (V0-V7). In the right part, we show the meta-knowledge graph.
+
+we plan to extend the ARML to the continual learning scenario where the structure of meta-knowledge graph will change over time; (3) our proposed model focuses on tasks where the feature space, the label space are shared. We plan to explore the relational structure on tasks with different feature and label spaces.
+
+# ACKNOWLEDGMENTS
+
+The work was supported in part by NSF awards #1652525 and #1618448. The views and conclusions contained in this paper are those of the authors and should not be interpreted as representing any funding agencies.
+
+# REFERENCES
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, Brendan Shillingford, and Nando De Freitas. Learning to learn by gradient descent by gradient descent. In NeurIPS, pp. 3981–3989, 2016.
+
+Chelsea Finn and Sergey Levine. Meta-learning and universality: Deep representations and gradient descent can approximate any learning algorithm. In ICLR, 2018.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In ICML, pp. 1126–1135, 2017.
+
+Chelsea Finn, Kelvin Xu, and Sergey Levine. Probabilistic model-agnostic meta-learning. In NeurIPS, 2018.
+
+Sebastian Flennerhag, Pablo G Moreno, Neil D Lawrence, and Andreas Damianou. Transferring knowledge across learning processes. ICLR, 2019.
+
+Victor Garcia and Joan Bruna. Few-shot learning with graph neural networks. In ICLR, 2017.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In ICML, pp. 1263–1272. JMLR. org, 2017.
+
+Jonathan Gordon, John Bronskill, Matthias Bauer, Sebastian Nowozin, and Richard E Turner. Metalearning probabilistic inference for prediction. In ICLR, 2019.
+
+Erin Grant, Chelsea Finn, Sergey Levine, Trevor Darrell, and Thomas Griffiths. Recasting gradientbased meta-learning as hierarchical bayes. In ICLR, 2018.
+
+Jiatao Gu, Yong Wang, Yun Chen, Kyunghyun Cho, and Victor OK Li. Meta-learning for low-resource neural machine translation. In EMNLP, 2018.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NeurIPS, pp. 1024–1034, 2017.
+
+Ghassen Jerfel, Erin Grant, Thomas L Griffiths, and Katherine Heller. Reconciling meta-learning and continual learning with online mixtures of tasks. NeurIPS, 2019.
+
+Bingyi Kang, Zhuang Liu, Xin Wang, Fisher Yu, Jiashi Feng, and Trevor Darrell. Few-shot object detection via feature reweighting. In ICCV, 2019.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.
+
+Yoonho Lee and Seungjin Choi. Gradient-based meta-learning with learned layerwise metric and subspace. In ICML, pp. 2933–2942, 2018.
+
+Zhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-sgd: Learning to learn quickly for few shot learning. arXiv preprint arXiv:1707.09835, 2017.
+
+Zhaojiang Lin, Andrea Madotto, Chien-Sheng Wu, and Pascale Fung. Personalizing dialogue agents via meta-learning. 2019.
+
+Ming-Yu Liu, Xun Huang, Arun Mallya, Tero Karras, Timo Aila, Jaakko Lehtinen, and Jan Kautz. Few-shot unsupervised image-to-image translation. arXiv preprint arXiv:1905.01723, 2019.
+
+Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. A simple neural attentive metalearner. ICLR, 2018.
+
+Alex Nichol and John Schulman. Reptile: a scalable metalearning algorithm. arXiv preprint arXiv:1803.02999, 2018.
+
+Boris Oreshkin, Pau Rodr´ıguez Lopez, and Alexandre Lacoste. Tadam: Task dependent adaptive ´ metric for improved few-shot learning. In NeurIPS, pp. 721–731, 2018.
+
+Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. Film: Visual reasoning with a general conditioning layer. In AAAI, 2018.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. ICLR, 2016.
+
+Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B. Tenenbaum, Hugo Larochelle, and Richard S. Zemel. Meta-learning for semi-supervised few-shot classification. In ICLR, 2018.
+
+Andrei A Rusu, Dushyant Rao, Jakub Sygnowski, Oriol Vinyals, Razvan Pascanu, Simon Osindero, and Raia Hadsell. Meta-learning with latent embedding optimization. In ICLR, 2019.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In NeurIPS, pp. 4077–4087, 2017.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. In ICLR, 2018.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In NeurIPS, pp. 3630–3638, 2016.
+
+Risto Vuorio, Shao-Hua Sun, Hexiang Hu, and Joseph J Lim. Toward multimodal model-agnostic meta-learning. arXiv preprint arXiv:1812.07172, 2018.
+
+Xin Wang, Fisher Yu, Ruth Wang, Trevor Darrell, and Joseph E Gonzalez. Tafe-net: Task-aware feature embeddings for low shot learning. In CVPR, pp. 1831–1840, 2019.
+
+Flood Sung Yongxin Yang, Li Zhang, Tao Xiang, Philip HS Torr, and Timothy M Hospedales. Learning to compare: Relation network for few-shot learning. In CVPR, 2018.
+
+Huaxiu Yao, Yiding Liu, Ying Wei, Xianfeng Tang, and Zhenhui Li. Learning from multiple cities: A meta-learning approach for spatial-temporal prediction. In WWW. ACM, 2019a.
+
+Huaxiu Yao, Ying Wei, Junzhou Huang, and Zhenhui Li. Hierarchically structured meta-learning. In ICML, pp. 7045–7054, 2019b.
+
+Jaesik Yoon, Taesup Kim, Ousmane Dia, Sungwoong Kim, Yoshua Bengio, and Sungjin Ahn. Bayesian model-agnostic meta-learning. In NeurIPS, pp. 7343–7353, 2018.
+
+Sung Whan Yoon, Jun Seo, and Jaekyun Moon. Tapnet: Neural network augmented with task-adaptive projection for few-shot learning. In ICML, 2019.
+
+Xi Sheryl Zhang, Fengyi Tang, Hiroko Dodge, Jiayu Zhou, and Fei Wang. Metapred: Meta-learning for clinical risk prediction with limited patient electronic health records. In KDD, 2019.
+
+# A ALGORITHM IN META-TESTING PROCESS
+
+# Algorithm 2 Meta-Testing Process of ARML
+
+Require: Training data $\mathcal { D } _ { t } ^ { t r }$ of a new task $\mathcal { T } _ { t }$   
+1: Construct the prototype-based relational graph $\mathcal { R } _ { t }$ by computing prototype in equation 2 and weight in equation 4   
+2: Compute the similarity between each prototype and meta-knowledge vertice in equation 6 and construct the super-graph $S _ { t }$   
+3: Apply GNN on super-graph $\scriptstyle { S _ { t } }$ and get the updated prototype representation $\hat { \mathbf { C } } \mathcal { R } _ { t }$   
+4: Aggregate $\mathbf { C } _ { \mathcal { R } _ { t } }$ in equation 8, $\hat { \mathbf { C } } _ { \mathcal { R } _ { t } }$ in equation 9 and get the representations $\mathbf { q } _ { t }$ , $\mathbf { t } _ { t }$   
+5: Compute the task-specific initialization $\theta _ { 0 t }$ in equation 10   
+6: Update parameters $\theta _ { t } = \theta _ { 0 t } - \alpha \nabla _ { \theta } \mathcal { L } ( f _ { \theta } , \mathcal { D } _ { t } ^ { t r } )$
+
+# B HYPERPARAMETERS SETTINGS
+
+# B.1 2D REGRESSION
+
+In 2D regression problem, we set the inner-loop stepsize (i.e., $\alpha$ ) and outer-loop stepsize (i.e., $\beta$ ) as 0.001 and 0.001, respectively. The embedding function $\mathcal { E }$ is set as one layer with 40 neurons. The autoencoder aggregator is constructed by the gated recurrent structures. We set the meta-batch size as 25 and the inner loop gradient steps as 5.
+
+# B.2 FEW-SHOT IMAGE CLASSIFICATION
+
+In few-shot image classification, for both Plain-Multi and Art-Multi datasets, we set the corresponding inner stepsize (i.e., $\alpha$ ) as 0.001 and the outer stepsize (i.e., $\beta$ ) as 0.01. For the embedding function $\mathcal { E }$ , we employ two convolutional layers with $3 \times 3$ filters. The channel size of these two convolutional layers are 32. After convolutional layers, we use two fully connected layers with 384 and 128 neurons for each layer. Similar to the hyperparameter settingsis constructed by the gated recurrent structures, i.e., $\mathrm { A G } ^ { t }$ D, $\mathrm { A G } _ { d e c } ^ { t }$ $\operatorname { A G } ^ { q }$ t, $\mathrm { A G } _ { d e c } ^ { q }$ oencoder aggregatorare all GRUs. The meta-batch size is set as 4. For the inner loop, we use 5 gradient steps.
+
+# B.3 DETAILED BASELINE SETTINGS
+
+For the gradient-based baselines (i.e., MAML, MetaSGD, MT-Net, BMAML. MUMOMAML, HSML), we use the same inner loop stepsize and outer loop stepsize rate as our ARML. As for non-parametric based meta-learning algorithms, both TADAM and Prototypical network, we use the same meta-training and meta-testing process as gradient-based models. Additionally, TADAM uses the same embedding function $\mathcal { E }$ as ARML for fair comparison (i.e., similar expressive ability).
+
+# C ADDITIONAL DISCUSSION OF DATASETS
+
+In this dataset, we use pencil and blur filers to change the task distribution. To investigate the effect of pencil and blur filters, we provide one example in Figure 4. We can observe that different filters result in different data distributions. All used filters are provided by OpenCV1.
+
+![](images/77c979b874c825d4fee44229816bff808d30527562104fcc429d19907dfbe263.jpg)  
+Figure 4: Effect of different filters.
+
+# D RESULTS ON MINIIMAGENET AND TIEREDIMAGENET
+
+For miniimagenet and tieredImagenet, since it do not have the characteristic of task heterogeneity, we show the results in Table 3 and Table 4, respectively. In this table, we compare our model with other gradient-based meta-learning models (the top baselines are globally shared models and the bottom baselines are task-specific models). Similar to (Finn et al., 2018), we also apply the standard 4-block convolutional layers for each baseline. For MT-Net on MiniImagenet, we use the reported results in (Yao et al., 2019b), which control the model with the same expressive power. Most task-specific models including ARML achieve the similar performance on the standard benchmark due to the homogeneity between tasks.
+
+Table 3: Performance comparison on the 5-way, 1-shot MiniImagenet dataset.   
+
+<table><tr><td>Algorithms</td><td>5-way 1-shot Accuracy</td></tr><tr><td>MAML (Finn et al., 2017)</td><td>48.70 ± 1.84%</td></tr><tr><td>LLAMA (Finn &amp; Levine, 2018)</td><td>49.40 ± 1.83%</td></tr><tr><td>Reptile (Nichol &amp; Schulman,2018)</td><td>49.97 ± 0.32%</td></tr><tr><td>MetaSGD (Li et al., 2017)</td><td>50.47 ± 1.87%</td></tr><tr><td>MT-Net (Lee &amp; Choi,2018)</td><td>49.75 ± 1.83%</td></tr><tr><td>MUMOMAML (Vuorio et al., 2018)</td><td>49.86 ± 1.85%</td></tr><tr><td>HSML(Yao et al.,2019b)</td><td>50.38 ± 1.85%</td></tr><tr><td>PLATIPUS (Finn et al., 2018)</td><td>50.13 ± 1.86%</td></tr><tr><td>ARML</td><td>50.42 ± 1.73%</td></tr></table>
+
+Table 4: Performance comparison on the 5-way, 1-shot tieredImagenet dataset.   
+
+<table><tr><td>Algorithms</td><td> 5-way 1-shot Accuracy</td></tr><tr><td>MAML (Finn et al., 2017)</td><td>51.37 ± 1.80%</td></tr><tr><td>Reptile (Nichol &amp; Schulman, 2018)</td><td>49.41 ± 1.82%</td></tr><tr><td>MetaSGD (Li et al., 2017)</td><td>51.48 ± 1.79%</td></tr><tr><td>MT-Net (Lee &amp; Choi, 2018)</td><td>51.95 ± 1.83%</td></tr><tr><td>MUMOMAML (Vuorio et al., 2018)</td><td>52.59 ± 1.80%</td></tr><tr><td>HSML (Yao et al.,2019b)</td><td>52.67 ± 1.85%</td></tr><tr><td>ARML</td><td>52.91 ± 1.83%</td></tr></table>
+
+# E ADDITIONAL RESULTS OF FEW-SHOT IMAGE CLASSIFICATION
+
+We provide the full results table of Art-Multi Dataset in Table 8. In this table, we can see our proposed ARML outperforms almost all baselines in every sub-datasets.
+
+# F ABLATION STUDY
+
+In this section, we perform the ablation study of the proposed ARML to demonstrate the effectiveness of each component. The results of ablation study on 5-way, 5-shot scenario for Art-Multi and PlainMulti datasets are presented in Table 5 and Table 6, respectively. Specifically, to show the effectiveness of prototype-based relational graph, in ablation I, we apply the mean pooling to aggregate each sample and then feed it to interact with meta-knowledge graph. In ablation II, we use all samples to construct the sample-level relational graph without constructing prototype. In ablation III, we remove the links between prototypes. Compared with ablation I, II and III, the better performance of ARML shows that structuring samples can (1) better handling the underlying relations (2) alleviating the effect of potential anomalies by structuring samples as prototypes.
+
+In ablation IV, we remove the meta-knowledge graph and use the prototype-based relational graph with aggregator $\operatorname { A G } ^ { q }$ as the task representation. The better performance of ARML demonstrates the effectiveness of meta-knowledge graph for capturing the relational structure and facilitating the classification performance. We further remove the reconstruction loss in ablation V and replace the encoder/decoder structure as MLP in ablation VI. The results demonstrate that the autoencoder structure benefits the process of task representation learning and selected encoder and decoder.
+
+In ablation VII, we share the gate value within each filter in Convolutional layers. Compared with VII, the better performance of ARML indicates the benefit of customized gate for each parameter. In ablation VIII and IX, we change the modulate function to Film (Perez et al., 2018) and tanh, respectively. We can see that ARML is not very sensitive to the modulating activation, and Sigmoid function is slightly better in most cases.
+
+Table 5: Full evaluation results of model ablation study on Art-Multi dataset. B, T, A, F represent bird, texture, aircraft, fungi, respectively. Plain means original image.   
+
+<table><tr><td>Model</td><td>B Plain</td><td>B Blur</td><td>B Pencil</td><td>T Plain</td><td>T Blur</td><td>T Pencil</td></tr><tr><td>I. no prototype-based graph</td><td>72.08%</td><td>71.06%</td><td>66.83%</td><td>45.23%</td><td>39.97%</td><td>41.67%</td></tr><tr><td>II. no prototype</td><td>72.99%</td><td>70.92%</td><td>67.19%</td><td>45.17%</td><td>40.05%</td><td>41.04%</td></tr><tr><td>III. no prototype links</td><td>72.53%</td><td>71.09%</td><td>67.11%</td><td>45.08%</td><td>40.12%</td><td>41.01%</td></tr><tr><td>IV. no meta-knowledge graph</td><td>70.79%</td><td>69.53%</td><td>64.87%</td><td>43.37%</td><td>39.86%</td><td>41.23%</td></tr><tr><td>V. no reconstruction loss</td><td>70.82%</td><td>69.87%</td><td>65.32%</td><td>44.02%</td><td>40.18%</td><td>40.52%</td></tr><tr><td>VI. replace encoder/decoder as MLP</td><td>71.36%</td><td>70.25%</td><td>66.38%</td><td>44.18%</td><td>39.97%</td><td>41.85%</td></tr><tr><td> VII. share the gate within Conv. filter</td><td>72.03%</td><td>68.15%</td><td>65.23%</td><td>43.98%</td><td>40.13%</td><td>39.71%</td></tr><tr><td>VIII. tanh</td><td>72.70%</td><td>69.53%</td><td>66.85%</td><td>45.81%</td><td>40.79%</td><td>38.64%</td></tr><tr><td>IX. film</td><td>71.52%</td><td>68.70%</td><td>64.23%</td><td>43.83%</td><td>40.52%</td><td>39.49%</td></tr><tr><td>ARML</td><td>73.05%</td><td>71.31%</td><td>67.14%</td><td>45.32%</td><td>40.15%</td><td>41.98%</td></tr><tr><td>Model</td><td>A Plain</td><td>A Blur</td><td>A Pencil</td><td>F Plain</td><td>F Blur</td><td>F Pencil</td></tr><tr><td>I. no prototype-based graph</td><td>70.06%</td><td>68.02%</td><td>60.66%</td><td>55.81%</td><td>54.39%</td><td>50.01%</td></tr><tr><td> II. no prototype</td><td>71.10%</td><td>67.59%</td><td>61.07%</td><td>56.11%</td><td>54.82%</td><td>49.95%</td></tr><tr><td>III. no prototype links</td><td>71.56%</td><td>67.91%</td><td>60.83%</td><td>55.76%</td><td>54.60%</td><td>50.08%</td></tr><tr><td>IV. no meta-knowledge graph</td><td>69.97%</td><td>68.03%</td><td>59.72%</td><td>55.84%</td><td>53.72%</td><td>48.91%</td></tr><tr><td>V. no reconstruction loss</td><td>66.83%</td><td>65.73%</td><td>55.98%</td><td>54.62%</td><td>53.02%</td><td>48.01%</td></tr><tr><td>VI. replace encoder/decoder as MLP</td><td>70.93%</td><td>68.12%</td><td>60.95%</td><td>56.02%</td><td>53.83%</td><td>50.22%</td></tr><tr><td> VII. share the gate within Conv. filter</td><td>71.25%</td><td>67.49%</td><td>58.09%</td><td>55.36%</td><td>54.25%</td><td>49.90%</td></tr><tr><td>VIII. tanh</td><td>73.96%</td><td>69.70%</td><td>60.75%</td><td>56.87%</td><td>54.30%</td><td>49.82%</td></tr><tr><td>IX. film</td><td>69.13%</td><td>66.93%</td><td>55.59%</td><td>55.77%</td><td>53.72%</td><td>48.92%</td></tr><tr><td>ARML</td><td>71.89%</td><td>68.59%</td><td>61.41%</td><td>56.83%</td><td>54.87%</td><td>50.53%</td></tr></table>
+
+Table 6: Results of Model Ablation (5-way, 5-shot results) on Plain-Multi dataset.   
+
+<table><tr><td>Ablation Models</td><td>Bird</td><td>Texture</td><td>Aircraft</td><td>Fungi</td></tr><tr><td>I. no prototype-based graph II. no prototype</td><td>71.96 ±0.72% 72.86 ±0.74%</td><td>48.79 ±0.67% 49.03 ±0.69%</td><td>74.02 ± 0.65% 74.36±0.65%</td><td>56.83 ±0.80% 57.02 ± 0.81%</td></tr><tr><td>III no prototype links IV. no meta-knowledge graph V. no reconstruction loss</td><td>72.53��0.72% 71.23 ±0.75% 70.99 ±0.74%</td><td>49.25 ±0.68% 47.96 ± 0.68% 48.03 ±0.69%</td><td>74.46 ± 0.64% 73.71 ±0.69% 69.86 ±0.66%</td><td>57.10 ± 0.81% 55.97 ±0.82% 55.78 ±0.83%</td></tr><tr><td>VI. replace encoder/decoder as MLP VII. share the gate within Conv. filter</td><td>72.36±0.72%</td><td>48.93 ±0.67%</td><td>74.28±0.65%</td><td>56.91 ±0.83%</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VIII. tanh</td><td>72.83±0.72%</td><td>48.66 ±0.68%</td><td>74.13 ± 0.66%</td><td>56.83 ±0.81%</td></tr><tr><td></td><td>73.45 ±0.71%</td><td>49.23 ±0.66%</td><td>74.39 ±0.65%</td><td>57.38±0.80%</td></tr><tr><td>IX. film</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>72.95 ±0.73%</td><td>49.18 ±0.69%</td><td>73.82 ±0.68%</td><td>56.89 ±0.80%</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ARML</td><td>73.34±0.70%</td><td>49.67 ± 0.67%</td><td>74.88 ± 0.64%</td><td>57.55±0.82%</td></tr></table>
+
+# G ADDITIONAL ANALYSIS OF META-KNOWLEDGE GRAPH
+
+# G.1 QUALITATIVE ANALYSIS ON PLAIN-MULTI DATASET
+
+Then, we analyze the meta-knowledge graph on Plain-Multi dataset by visualizing the learned metaknowledge graph on Plain-Multi dataset (as shown in Figure 5). In this figure, we can see that different subdatasets activate different vertices. Specifically, V2, which is mainly activated by texture, plays a significantly important role in aircraft and fungi. Thus, V2 connects with V3 and V1 in the meta-knowledge graph, which is mainly activated by fungi and aircraft, respectively. In addition, V0 is also activated by aircraft because of the similar contour between aircraft and bird. Furthermore, in meta-knowledge graph, V0 connects with V3, which shows the similarity of environment between bird images and fungi images.
+
+![](images/bc7cf91b89b4ad760a680d4858297560839040267a801060e86c493be3b01849.jpg)  
+Figure 5: Interpretation of meta-knowledge graph on Plain-Multi dataset. For each subdataset, one task is randomly selected from them. In the left figure, we show the similarity heatmap between prototypes (P1-P5) and meta-knowledge vertices (denoted as E1-E4), where deeper color means higher similarity. In the right part, we show the meta-knowledge graph, where a threshold is also set to filter low similarity links.
+
+# G.2 PERFORMANCE V.S. VERTICE NUMBERS
+
+We first investigate the impact of vertice numbers in meta-knowledge graph. The results of Art-Multi (5-way, 5-shot) are shown in Table 7. From the results, we can notice that the performance saturates as the number of vertices around 8. One potential reason is that 8 vertices are enough to capture the potential relations. If we have a larger datasets with more complex relations, more vertices may be needed. In addition, if the meta-knowledge graph does not have enough vertices, the worse performance suggests that the graph may not capture enough relations across tasks.
+
+Table 7: Full evaluation results of performance v.s. # vertices of meta-knowledge graph on Art-Multi. B, T, A, F represent bird, texture, aircraft, fungi, respectively. Plain means original image.   
+
+<table><tr><td># of Vertices</td><td>B Plain</td><td>B Blur</td><td>B Pencil</td><td>T Plain</td><td>T Blur</td><td>TPencil</td></tr><tr><td>4</td><td>72.29%</td><td>70.36%</td><td>67.88%</td><td>45.37%</td><td>41.05%</td><td>41.43%</td></tr><tr><td>8</td><td>73.05%</td><td>71.31%</td><td>67.14%</td><td>45.32%</td><td>40.15%</td><td>41.98%</td></tr><tr><td>12</td><td>73.45%</td><td>70.64%</td><td>67.41%</td><td>44.53%</td><td>41.41%</td><td>41.05%</td></tr><tr><td>16</td><td>72.68%</td><td>70.18%</td><td>68.34%</td><td>45.63%</td><td>41.43%</td><td>42.18%</td></tr><tr><td>20</td><td>73.41%</td><td>71.07%</td><td>68.64%</td><td>46.26%</td><td>41.80%</td><td>41.61%</td></tr><tr><td># of Vertices</td><td>A Plain</td><td>A Blur</td><td>A Pencil</td><td>F Plain</td><td>F Blur</td><td>F Pencil</td></tr><tr><td>4</td><td>70.98%</td><td>67.36%</td><td>60.46%</td><td>56.07%</td><td>53.77%</td><td>50.08%</td></tr><tr><td>8</td><td>71.89%</td><td>68.59%</td><td>61.41%</td><td>56.83%</td><td>54.87%</td><td>50.53%</td></tr><tr><td>12</td><td>71.78%</td><td>67.26%</td><td>60.97%</td><td>56.87%</td><td>55.14%</td><td>50.86%</td></tr><tr><td>16</td><td>71.96%</td><td>68.55%</td><td>61.14%</td><td>56.76%</td><td>54.54%</td><td>49.41%</td></tr><tr><td>20</td><td>72.02%</td><td>68.29%</td><td>60.59%</td><td>55.95%</td><td>54.53%</td><td>50.13%</td></tr></table>
+
+# G.3 DISCUSSION BETWEEN ARML AND HSML
+
+In this part, we provide the case study to visualize the task structure of HSML and ARML. HSML is one of representative task-specific meta-learning methods, which adapts transferable knowledge by introducing a task-specific representation. It proposes a tree structure to learn the relations between tasks. However, the structure requires massive labor efforts to explore the optimal structure. By contrast, ARML automatically learn the relation across tasks by introducing the knowledge graph. In addition, ARML fully exploring there types of relations simultaneously, i.e., the prototype-prototype, prototype-knowledge and knowledge-knowledge relations.
+
+To compare these two models, we show the case studies of HSML and ARML in Figure 6 and Figure 7. For tasks sampled from bird, bird blur, aircraft and aircraft blur are selected for this comparison. Following case study settings in the original paper (Yao et al., 2019b), for each task, we show the soft-assignment probability to each cluster and the learned hierarchical structure. For ARML, like 3, we show the learned meta-knowledge and the similarity heatmap between prototypes and meta-knowledge vertices. In this figures we can observe that ARML constructs relations in a more flexible way by introducing the graph structure. More specifically, while HSML activate relevant node in a fixed two-layer hierarchical way, ARML provides more possibilities to leverage previous learned tasks by leveraging prototypes and the learned meta-knowledge graph.
+
+![](images/2e74b640c85720adeaca865992792b74b8ebfaebe4216658e176bfcac6c17729.jpg)  
+Figure 6: Case study for learned structure of HSML. For each task, the top heatmap shows the soft-assignment probability with each cluster and the top tree show the learned hierarchical structure.
+
+![](images/2c9d97d6ecbb56ce5d17b4ed260d949a008f0809919f9e5c4ebfa22711a1c119.jpg)  
+Figure 7: Case study for learned structure of ARML. Both the learned graph and the similarity heatmap between prototypes and meta-knowledge vertices are illustrated.
+
+# G.4 ADDITIONAL CASES OF META-KNOWLEDGE GRAPH ANALYSIS
+
+We provide additional case study in this section. In Figure 8, we show the cases of 2D regression and the additional cases of Art-Multi are illustrated in Figure 9. We can see the additional cases also support our observations and interpretations.
+
+![](images/03f9939d8be68d6a6e9e08c0f0dccac8dae1fadd66550c106faa8694678919b6.jpg)  
+Figure 8: Additional cases on 2D regression.
+
+![](images/537db7925ac9a454fe4a70c67c173d113b9922ee7ece6e570038c841d8360406.jpg)  
+Figure 9: Additional cases of Art-Multi.
+
+<table><tr><td>redg 55550</td><td>55350 55590 %2790 38390 50090</td><td>55550 %96&#x27;20 55590 530.20 %9380 25534 233.35 %69&#x27;95</td><td>17825 %63.95 514.55 1784 170.20 %61&#x27;25 %0560</td><td rowspan="5">11110 5287 %09 16859 55659 62179 50560</td></tr><tr><td>59560 Jrr</td><td>%0080 55560 %60.00 585.88</td><td>%99.68 51355 38005 249 %8000 %7735 500.0</td><td>59509 %99:09 1441 57 55479 58189</td></tr><tr><td>Trg 57175</td><td>53211 55929 11135 55333</td><td>%80 %6000 25010 %/675 289 %69 18119 51430</td><td>35539 %5099 %80 58551 59659 %1059</td></tr><tr><td>Airee t %10</td><td>56520 %9999 %/11 55553</td><td>58650 %80&#x27;98 353233 %59.69 %18:00 116.35 55559 %805</td><td>51159 %60&#x27;69 %4060 53351 116.19 %7195</td></tr><tr><td>JAr t %6825</td><td>15600 11000 57925 14</td><td>26724 6897 %8000 23335 160 %462</td><td>%979 %459 %6759 %99&#x27;89</td><td>%%9 %9359 53339 56789 %9519</td></tr><tr><td>11d a 500.59</td><td>24554 %8195 %0000</td><td>25595 14711 6889 2454 56666 %8665</td><td>%66:19 %7859 %5899 %9199 157330</td><td>%£9&#x27;29 %69&#x27;89 %8959 %8859 62999 53339 59339 %0101 %681</td></tr><tr><td>[reel 258</td><td>5858 680.67 %7800</td><td>56387 58388 669.67 53560 %06&#x27;67 %2100</td><td>531.31 53830 50580 %09&#x27;88 %8100</td><td>%2889 %36.29 %9260 607.60 %/000 2335 %861V</td></tr><tr><td>%01.67 JIgm</td><td>%80&#x27;67 %8567 %06&#x27;67</td><td>56.87 71180 %1167 %39.65 72267 50000</td><td>%0131 55550 353580 %9829 %08.10</td><td>66228 53860 66566 53569 25005 %015 50515</td></tr><tr><td>[TTdg 500.00</td><td>57333 57530 53350</td><td>500.33 58767 %7010 53353 %8830 53000</td><td>53351 355880 %8 1 51650</td><td>%96 %68 18535 23235 1/14 %89 53325</td></tr><tr><td>rree g %08&#x27;85</td><td>%99&#x27;95 %9225 158.85</td><td>185.85 %8185 %8825 3500:9 %9609 %60.19</td><td>3/7.779 %9209 %78&#x27;19 %69&#x27;79 555.59</td><td>%3639 5355 %66&#x27;59 %8789 %/659 %7999 %129</td></tr><tr><td>55956 Jrg</td><td>%86.09 J/11 %8579</td><td>53779 58009 %2879 14719 58539 55530</td><td>56859 %5319 %06&#x27;29 %£0&#x27;89 %90&#x27;69</td><td>%99&#x27;89 %8289 %19&#x27;89 %6769 110:00 %1969 71131</td></tr><tr><td>Bd g 5947</td><td>35939 55330 %9149</td><td>61299 %/9.69 352799 53750 %66&#x27;99 53229 55589</td><td>%80&#x27;0L %87&#x27;99 142 %09&#x27;89</td><td>61812 %99 %811 11111 1/11 111 55306</td></tr><tr><td>sgrsesssts VIESA</td><td>Jn010IE 1Nde JTAAAA</td><td>AUIUAIAI Vleeece PIAAN JAAA 1N-L TNSH AARI</td><td>J1N010. JAAAA VIEIA 1Nde</td><td>MUUUANAN eeee PIAAI AAAA 1N-La TNSH AARI</td></tr></table>

parse/train/ryxnHhRqFm/ryxnHhRqFm.md

@@ -0,0 +1,333 @@
+# GLOBAL-TO-LOCAL MEMORY POINTER NETWORKS FOR TASK-ORIENTED DIALOGUE
+
+Chien-Sheng $\mathbf { W _ { u } } ^ { \dagger } \ast$ , Richard Socher‡ & Caiming Xiong‡
+
+‡Salesforce Research   
+{rsocher,cxiong}@salesforce.com   
+†The Hong Kong University of Science and Technology   
+jason.wu@connect.ust.hk
+
+# ABSTRACT
+
+End-to-end task-oriented dialogue is challenging since knowledge bases are usually large, dynamic and hard to incorporate into a learning framework. We propose the global-to-local memory pointer (GLMP) networks to address this issue. In our model, a global memory encoder and a local memory decoder are proposed to share external knowledge. The encoder encodes dialogue history, modifies global contextual representation, and generates a global memory pointer. The decoder first generates a sketch response with unfilled slots. Next, it passes the global memory pointer to filter the external knowledge for relevant information, then instantiates the slots via the local memory pointers. We empirically show that our model can improve copy accuracy and mitigate the common out-of-vocabulary problem. As a result, GLMP is able to improve over the previous state-of-theart models in both simulated bAbI Dialogue dataset and human-human Stanford Multi-domain Dialogue dataset on automatic and human evaluation.
+
+# 1 INTRODUCTION
+
+Task-oriented dialogue systems aim to achieve specific user goals such as restaurant reservation or navigation inquiry within a limited dialogue turns via natural language. Traditional pipeline solutions are composed of natural language understanding, dialogue management and natural language generation (Young et al., 2013; Wen et al., 2017), where each module is designed separately and expensively. In order to reduce human effort and scale up between domains, end-to-end dialogue systems, which input plain text and directly output system responses, have shown promising results based on recurrent neural networks (Zhao et al., 2017; Lei et al., 2018) and memory networks (Sukhbaatar et al., 2015). These approaches have the advantages that the dialogue states are latent without hand-crafted labels and eliminate the needs to model the dependencies between modules and interpret knowledge bases (KB) manually.
+
+However, despite the improvement by modeling KB with memory network (Bordes & Weston, 2017; Madotto et al., 2018), end-to-end systems usually suffer from effectively incorporating external KB into the system response generation. The main reason is that a large, dynamic KB is equal to a noisy input and hard to encode and decode, which makes the generation unstable. Different from chit-chat scenario, this problem is especially harmful in task-oriented one, since the information in KB is usually the expected entities in the response. For example, in Table 1 the driver will expect to get the correct address to the gas station other than a random place such as a hospital. Therefore, pointer networks (Vinyals et al., 2015) or copy mechanism (Gu et al., 2016) is crucial to successfully generate system responses because directly copying essential words from the input source to the output not only reduces the generation difficulty, but it is also more like a human behavior. For example, in Table 1, when human want to reply others the Valero’s address, they will need to “copy” the information from the table to their response as well.
+
+Therefore, in the paper, we propose the global-to-local memory pointer (GLMP) networks, which is composed of a global memory encoder, a local memory decoder, and a shared external knowledge. Unlike existing approaches with copy ability (Gulcehre et al., 2016; Gu et al., 2016; Eric &
+
+Table 1: An in-car assistant example on the navigation domain. The left part is the KB information and the right part is the conversation between a driver and our system.   
+
+<table><tr><td>Point of interest (poi)</td><td>Distance</td><td>Traffic</td><td>Poi type</td><td>Address</td></tr><tr><td>Toms house</td><td>3 miles</td><td>heavy</td><td>friend&#x27;s house</td><td>580Van Ness Ave</td></tr><tr><td>Coupa</td><td>2 miles</td><td>moderate</td><td>coffee or tea place</td><td>394Van NessAve</td></tr><tr><td>Pandaexpress</td><td>2 miles</td><td>no</td><td>Chineserestaurant</td><td>842Arrowhead Way</td></tr><tr><td>Stanford expresscare</td><td>5 miles</td><td>no</td><td>hospital</td><td>214 El Camino Real</td></tr><tr><td>Valero</td><td>4 miles</td><td>heavy</td><td>gas station</td><td>200 Alester Ave</td></tr><tr><td>Starbucks</td><td>1 miles</td><td>heavy</td><td>coffee or teaplace</td><td>792 Bedoin St</td></tr></table>
+
+<table><tr><td>Driver</td><td>I need gas</td></tr><tr><td>System</td><td>GLMP:Thereisa gasstation locally Valero is 4 milesaway Gold: Valero is 4 miles away</td></tr><tr><td>Driver</td><td>What is theaddress？</td></tr><tr><td>System</td><td>GLMP:Valero is locatedat200 Alester Ave Gold: Valero is at 200 Alester Ave</td></tr><tr><td>Driver</td><td>Thank you!</td></tr></table>
+
+Manning, 2017; Madotto et al., 2018), which the only information passed to decoder is the encoder hidden states, our model shares the external knowledge and leverages the encoder and the external knowledge to learn a global memory pointer and global contextual representation. Global memory pointer modifies the external knowledge by softly filtering words that are not necessary for copying. Afterward, instead of generating system responses directly, the local memory decoder first uses a sketch RNN to obtain sketch responses without slot values but sketch tags, which can be considered as learning a latent dialogue management to generate dialogue action template. Then the decoder generates local memory pointers to copy words from external knowledge and instantiate sketch tags.
+
+We empirically show that GLMP can achieve superior performance using the combination of global and local memory pointers. In simulated out-of-vocabulary (OOV) tasks in the bAbI dialogue dataset (Bordes & Weston, 2017), GLMP achieves $9 2 . 0 \%$ per-response accuracy and surpasses existing end-to-end approaches by $7 . 5 \%$ in full dialogue. In the human-human dialogue dataset (Eric et al., 2017), GLMP is able to surpass the previous state of the art on both automatic and human evaluation, which further confirms the effectiveness of our double pointers usage.
+
+# 2 GLMP MODEL
+
+Our model 1 is composed of three parts: global memory encoder, external knowledge, and local memory decoder, as shown in Figure 1(a). The dialogue history $X = ( x _ { 1 } , \ldots , x _ { n } ) $ and the KB information $B \ = \ ( b _ { 1 } , \ldots , b _ { l } )$ are the input, and the system response $Y = ( y _ { 1 } , \dots y _ { m } ) $ is the expected output, where $n , l , m$ are the corresponding lengths. First, the global memory encoder uses a context RNN to encode dialogue history and writes its hidden states into the external knowledge. Then the last hidden state is used to read the external knowledge and generate the global memory pointer at the same time. On the other hand, during the decoding stage, the local memory decoder first generates sketch responses by a sketch RNN. Then the global memory pointer and the sketch RNN hidden state are passed to the external knowledge as a filter and a query. The local memory pointer returns from the external knowledge can copy text from the external knowledge to replace the sketch tags and obtain the final system response.
+
+# 2.1 EXTERNAL KNOWLEDGE
+
+Our external knowledge contains the global contextual representation that is shared with the encoder and the decoder. To incorporate external knowledge into a learning framework, end-to-end memory networks (MN) are used to store word-level information for both structural KB (KB memory) and temporal-dependent dialogue history (dialogue memory), as shown in Figure 1(b). In addition, the MN is well-known for its multiple hop reasoning ability (Sukhbaatar et al., 2015), which is appealing to strengthen copy mechanism.
+
+Global contextual representation. In the KB memory module, each element $b _ { i } \in B$ is represented in the triplet format as (Subject, Relation, Object) structure, which is a common format used to represent KB nodes (Miller et al., 2016; Eric et al., 2017). For example, the KB in the Table 1 will be denoted as {(Tom’s house, distance, 3 miles), ..., (Starbucks, address, 792 Bedoin $S t ) \}$ . On the other hand, the dialogue context $X$ is stored in the dialogue memory module, where the speaker and temporal encoding are included as in Bordes & Weston (2017) like a triplet format. For instance, the first utterance from the driver in the Table 1 will be denoted as $\{ ( \mathbb { S } u s e r , t u r n I , I ) ,$ , (\$user, turn1, need), $( \mathbb { S } u s e r , \ t u r n I , \ g a s ) \}$ . For the two memory modules, a bag-of-word representation is used as the memory embeddings. During the inference time, we copy the object word once a memory position is pointed to, for example, 3 miles will be copied if the triplet (Toms house, distance, 3 miles) is selected. We denote $O b j e c t ( . )$ function as getting the object word from a triplet.
+
+![](images/c8f60b9c4b57e7e89923b80b7e27951d97d0ddd2e1035dfc258040b7cc13d06d.jpg)  
+Figure 1: The proposed (a) global-to-local memory pointer networks for task-oriented dialogue systems and the (b) external knowledge architecture.
+
+Knowledge read and write. Our external knowledge is composed of a set of trainable embedding matrices $\boldsymbol { C } = ( C ^ { 1 } , \ldots , C ^ { K + 1 } )$ , where $C ^ { k } \in \mathbb { R } ^ { | V | \times d _ { e m b } }$ , $K$ is the maximum memory hop in the MN, $| V |$ is the vocabulary size and $d _ { e m b }$ is the embedding dimension. We denote memory in the external knowledge as $M = [ B ; X ] = ( m _ { 1 } , \ldots , m _ { n + l } ) ,$ , where $m _ { i }$ is one of the triplet components mentioned. To read the memory, the external knowledge needs a initial query vector $q ^ { 1 }$ . Moreover, it can loop over $K$ hops and computes the attention weights at each hop $k$ using
+
+$$
+p _ { i } ^ { k } = \mathrm { S o f t m a x } ( ( q ^ { k } ) ^ { T } c _ { i } ^ { k } ) ,
+$$
+
+where $c _ { i } ^ { k } = B ( C ^ { k } ( m _ { i } ) ) \in \mathbb { R } ^ { d _ { e m b } }$ is the embedding in $i ^ { t h }$ memory position using the embedding matrix $C ^ { k }$ , $q ^ { k }$ is the query vector for hop $k$ , and $B ( . )$ is the bag-of-word function. Note that $p ^ { k } \in$ $\mathbb { R } ^ { n + l }$ is a soft memory attention that decides the memory relevance with respect to the query vector. Then, the model reads out the memory $o ^ { k }$ by the weighted sum over $c ^ { k + \mathbf { \hat { 1 } } }$ and update the query vector $q ^ { k + 1 }$ . Formally,
+
+$$
+o ^ { k } = \sum _ { i } p _ { i } ^ { k } c _ { i } ^ { k + 1 } , \quad q ^ { k + 1 } = q ^ { k } + o ^ { k } .
+$$
+
+# 2.2 GLOBAL MEMORY ENCODER
+
+In Figure 2(a), a context RNN is used to model the sequential dependency and encode the context $X$ . Then the hidden states are written into the external knowledge as shown in Figure 1(b). Afterward, the last encoder hidden state serves as the query to read the external knowledge and get two outputs, the global memory pointer and the memory readout. Intuitively, since it is hard for MN architectures to model the dependencies between memories (Wu et al., 2018), which is a serious drawback especially in conversational related tasks, writing the hidden states to the external knowledge can provide sequential and contextualized information. With meaningful representation, our pointers can correctly copy out words from external knowledge, and the common OOV challenge can be mitigated. In addition, using the encoded dialogue context as a query can encourage our external knowledge to read out memory information related to the hidden dialogue states or user intention. Moreover, the global memory pointer that learns a global memory distribution is passed to the decoder along with the encoded dialogue history and KB information.
+
+Context RNN. A bi-directional gated recurrent unit (GRU) (Chung et al., 2014) is used to encode dialogue history into the hidden states $H = ( h _ { 1 } ^ { e } , \ldots , h _ { 1 } ^ { e } )$ , and the last hidden state $h _ { n } ^ { e }$ is used to query the external knowledge as the encoded dialogue history. In addition, the hidden states $H$ are written into the dialogue memory module in the external knowledge by summing up the original memory representation with the corresponding hidden states. In formula,
+
+$$
+c _ { i } ^ { k } = c _ { i } ^ { k } + h _ { m _ { i } } ^ { e } \quad \mathrm { i f } \quad m _ { i } \in X \mathrm { a n d } \forall k \in [ 1 , K + 1 ] ,
+$$
+
+Global memory pointer. Global memory pointer $G = ( g _ { 1 } , \dots , g _ { n + l } )$ is a vector containing real values between 0 and 1. Unlike conventional attention mechanism that all the weights sum to one, each element in $G$ is an independent probability. We first query the external knowledge using $h _ { n } ^ { e }$ until the last hop, and instead of applying the Softmax function as in (1), we perform an inner product followed by the Sigmoid function. The memory distribution we obtained is the global memory pointer $G$ , which is passed to the decoder. To further strengthen the global pointing ability, we add an auxiliary loss to train the global memory pointer as a multi-label classification task. We show in the ablation study that adding this additional supervision does improve the performance. Lastly, the memory readout $q ^ { K + 1 }$ is used as the encoded KB information.
+
+![](images/84a38933bb34698d01854f932903cce5a8a771fb337ce457030c01c03dd0b74a.jpg)  
+Figure 2: The proposed (a) global memory encoder and the (b) local memory decoder architecture.
+
+In the auxiliary task, we define the label $G ^ { l a b e l } = ( g _ { 1 } ^ { l } , \ldots , g _ { n + l } ^ { l } )$ by checking whether the object words in the memory exists in the expected system response $Y$ . Then the global memory pointer is trained using binary cross-entropy loss $L o s s _ { g }$ between $G$ and $G ^ { l a b e l }$ . In formula,
+
+$$
+\begin{array} { r l } & { g _ { i } = \mathrm { S i g m o i d } ( ( q ^ { K } ) ^ { T } c _ { i } ^ { K } ) , \quad g _ { i } ^ { l } = \left\{ \begin{array} { l l } { 1 } & { \mathrm { i f } O b j e c t ( m _ { i } ) \in Y } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right. , } \\ & { \quad L o s s _ { g } = - \sum _ { i = 1 } ^ { n + l } [ g _ { i } ^ { l } \times \log g _ { i } + ( 1 - g _ { i } ^ { l } ) \times \log { ( 1 - g _ { i } ) } ] . } \end{array}
+$$
+
+# 2.3 LOCAL MEMORY DECODER
+
+Given the encoded dialogue history $h _ { n } ^ { e }$ , the encoded KB information $q ^ { K + 1 }$ , and the global memory pointer $G$ , our local memory decoder first initializes its sketch RNN using the concatenation of $h _ { n } ^ { e }$ and $q ^ { K + 1 }$ , and generates a sketch response that excludes slot values but includes the sketch tags. For example, sketch RNN will generate “@poi is $@$ distance away”, instead of “Starbucks is 1 mile away.” At each decoding time step, the hidden state of the sketch RNN is used for two purposes: 1) predict the next token in vocabulary, which is the same as standard sequence-to-sequence (S2S) learning; 2) serve as the vector to query the external knowledge. If a sketch tag is generated, the global memory pointer is passed to the external knowledge, and the expected output word will be picked up from the local memory pointer. Otherwise, the output word is the word that generated by the sketch RNN. For example in Figure 2(b), a $\ @ \mathrm { p o i }$ tag is generated at the first time step, therefore, the word Starbucks is picked up from the local memory pointer as the system output word.
+
+Sketch RNN. We use a GRU to generate a sketch response $Y ^ { s } = ( y _ { 1 } ^ { s } , \ldots , y _ { m } ^ { s } ) $ without real slot values. The sketch RNN learns to generate a dynamic dialogue action template based on the encoded dialogue $( h _ { n } ^ { e } )$ and KB information $( q ^ { K + 1 } )$ . At each decoding time step $t$ , the sketch RNN hidden state $\hat { h } _ { t } ^ { d }$ and its output distribution $P _ { t } ^ { v o c a b }$ are defined as
+
+$$
+h _ { t } ^ { d } = \mathrm { { G R U } } ( C ^ { 1 } ( \hat { y } _ { t - 1 } ^ { s } ) , h _ { t - 1 } ^ { d } ) , \quad P _ { t } ^ { v o c a b } = \mathrm { { S o f t m a x } } ( W h _ { t } ^ { d } )
+$$
+
+We use the standard cross-entropy loss to train the sketch RNN, we define $L o s s _ { v }$ as.
+
+$$
+L o s s _ { v } = \sum _ { t = 1 } ^ { m } - \log ( P _ { t } ^ { v o c a b } ( y _ { t } ^ { s } ) ) .
+$$
+
+We replace the slot values in $Y$ into sketch tags based on the provided entity table. The sketch tags $S T$ are all the possible slot types that start with a special token, for example, $@$ address stands for all the addresses and $@$ distance stands for all the distance information.
+
+Local memory pointer. Local memory pointer $L = ( L _ { 1 } , \dots , L _ { m } )$ contains a sequence of pointers. At each time step $t$ , the global memory pointer $G$ first modify the global contextual representation using its attention weights,
+
+$$
+c _ { i } ^ { k } = c _ { i } ^ { k } \times g _ { i } , \quad \forall i \in [ 1 , n + l ] \mathrm { a n d } \forall k \in [ 1 , K + 1 ] ,
+$$
+
+and then the sketch RNN hidden state $h _ { t } ^ { d }$ queries the external knowledge. The memory attention in the last hop is the corresponding local memory pointer $L _ { t }$ , which is represented as the memory distribution at time step $t$ . To train the local memory pointer, a supervision on top of the last hop memory attention in the external knowledge is added. We first define the position label of local memory pointer $L ^ { l a b e l }$ at the decoding time step $t$ as
+
+$$
+L _ { t } ^ { l a b e l } = \left\{ { \begin{array} { l l } { m a x ( z ) } & { { \mathrm { i f ~ } } \exists z { \mathrm { ~ s . t . ~ } } y _ { t } = O b j e c t ( m _ { z } ) , } \\ { n + l + 1 } & { { \mathrm { o t h e r w i s e . } } } \end{array} } \right.
+$$
+
+The position $n { + } l { + } 1$ is a null token in the memory that allows us to calculate loss function even if $y _ { t }$ does not exist in the external knowledge. Then, the loss between $L$ and $L ^ { l a b e l }$ is defined as
+
+$$
+L o s s _ { l } = \sum _ { t = 1 } ^ { m } - \log ( L _ { t } ( L _ { t } ^ { l a b e l } ) ) .
+$$
+
+Furthermore, a record $R \in \mathbb { R } ^ { n + l }$ is utilized to prevent from copying same entities multiple times. All the elements in $R$ are initialized as 1 in the beginning. During the decoding stage, if a memory position has been pointed to, its corresponding position in $R$ will be masked out. During the inference time, $\hat { y } _ { t }$ is defined as
+
+$$
+\begin{array} { r } { \hat { y } _ { t } = \left\{ \begin{array} { l l } { \arg \operatorname* { m a x } \bigl ( P _ { t } ^ { v o c a b } \bigr ) } & { \mathrm { i f ~ } \arg \operatorname* { m a x } \bigl ( P _ { t } ^ { v o c a b } \bigr ) \notin S T , } \\ { O b j e c t \bigl ( m _ { \arg \operatorname* { m a x } \left( L _ { t } \odot R \right) } \bigr ) } & { \mathrm { o t h e r w i s e } , } \end{array} \right. } \end{array}
+$$
+
+where $\odot$ is the element-wise multiplication. Lastly, all the parameters are jointly trained by minimizing the weighted-sum of three losses $( \alpha , \beta , \gamma$ are hyper-parameters):
+
+$$
+\begin{array} { r } { L o s s = \alpha L o s s _ { g } + \beta L o s s _ { v } + \gamma L o s s _ { l } } \end{array}
+$$
+
+# 3 EXPERIMENTS
+
+# 3.1 DATASETS
+
+We use two public multi-turn task-oriented dialogue datasets to evaluate our model: the bAbI dialogue (Bordes & Weston, 2017) and Stanford multi-domain dialogue (SMD) (Eric et al., 2017). The bAbI dialogue includes five simulated tasks in the restaurant domain. Task 1 to 4 are about calling API calls, modifying API calls, recommending options, and providing additional information, respectively. Task 5 is the union of tasks 1-4. There are two test sets for each task: one follows the same distribution as the training set and the other has OOV entity values. On the other hand, SMD is a human-human, multi-domain dialogue dataset. It has three distinct domains: calendar scheduling, weather information retrieval, and point-of-interest navigation. The key difference between these two datasets is, the former has longer dialogue turns but the regular user and system behaviors, the latter has few conversational turns but variant responses, and the KB information is much more complicated.
+
+# 3.2 TRAINING DETAILS
+
+The model is trained end-to-end using Adam optimizer (Kingma & Ba, 2015), and learning rate annealing starts from $1 e ^ { - 3 }$ to $1 e ^ { - 4 }$ . The number of hop $K$ is set to 1,3,6 to compare the performance difference. The weights $\alpha , \beta , \gamma$ summing up the three losses are set to 1. All the embeddings are initialized randomly, and a simple greedy strategy is used without beam-search during the decoding stage. The hyper-parameters such as hidden size and dropout rate are tuned with grid-search over the development set (per-response accuracy for bAbI Dialogue and BLEU score for the SMD). In addition, to increase model generalization and simulate OOV setting, we randomly mask a small number of input source tokens into an unknown token. The model is implemented in PyTorch and the hyper-parameters used for each task and the dataset statistics are reported in the Appendix.
+
+Table 2: Per-response accuracy and completion rate (in the parentheses) on bAbI dialogues. GLMP achieves the least out-of-vocabulary performance drop. Baselines are reported from Query Reduction Network (Seo et al., 2017), End-to-end Memory Network (Bordes & Weston, 2017), Gated Memory Network (Liu & Perez, 2017), Point to Unknown Word (Gulcehre et al., 2016), and Memory-to-Sequence (Madotto et al., 2018).   
+
+<table><tr><td>Task</td><td>QRN</td><td>MN</td><td>GMN</td><td>S2S+Attn</td><td>Ptr-Unk</td><td>Mem2Seq</td><td>GLMPK1</td><td>GLMPK3</td><td>GLMP K6</td></tr><tr><td>T1</td><td>99.4 (-)</td><td>99.9 (99.6)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td></tr><tr><td>T2</td><td>99.5 (-)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td></tr><tr><td>T3</td><td>74.8 (-)</td><td>74.9 (2.0)</td><td>74.9 (0)</td><td>74.8 (0)</td><td>85.1 (19.0)</td><td>94.7 (62.1)</td><td>96.3 (75.6)</td><td>96.0 (69.4)</td><td>96.0 (68.7)</td></tr><tr><td>T4</td><td>57.2 (-)</td><td>59.5 (3.0)</td><td>57.2 (0)</td><td>57.2 (0)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td></tr><tr><td>T5</td><td>99.6 (-)</td><td>96.1 (49.4)</td><td>96.3 (52.5)</td><td>98.4 (87.3)</td><td>99.4 (91.5)</td><td>97.9 (69.6)</td><td>99.2 (88.5)</td><td>99.0 (86.5)</td><td>99.2 (89.7)</td></tr><tr><td>T1oov</td><td>83.1(-)</td><td>72.3(0)</td><td>82.4(0)</td><td>81.7(0)</td><td>92.5 (54.7)</td><td>94.0 (62.2)</td><td>100 (100)</td><td>100 (100)</td><td>99.3 (95.9)</td></tr><tr><td>T2 o0v</td><td>78.9 (-)</td><td>78.9 (0)</td><td>78.9 (0)</td><td>78.9 (0)</td><td>83.2 (0)</td><td>86.5 (12.4)</td><td>100 (100)</td><td>100 (100)</td><td>99.4 (94.6)</td></tr><tr><td>T300v</td><td>75.2 (-)</td><td>74.4 (0)</td><td>75.3 (0)</td><td>75.3 (0)</td><td>82.9 (13.4)</td><td>90.3 (38.7)</td><td>95.5 (65.7)</td><td>96.7 (72.9)</td><td>95.9 (67.7)</td></tr><tr><td>T4 o0v</td><td>56.9 (-)</td><td>57.6 (0)</td><td>57.0 (0)</td><td>57.0 (0)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td></tr><tr><td>T5o0v</td><td>67.8(-)</td><td>65.5 (0)</td><td>66.7 (0)</td><td>65.7 (0)</td><td>73.6 (0)</td><td>84.5 (2.3)</td><td>92.0 (21.7)</td><td>91.0 (17.7)</td><td>91.8 (21.4)</td></tr></table>
+
+Table 3: In SMD dataset, our model achieves highest BLEU score and entity F1 score over baselines, including previous state-of-the-art result from Madotto et al. (2018). (Models with \* are reported from Eric et al. (2017), where the problem is simplified to the canonicalized forms.)   
+Automatic Evaluation   
+
+<table><tr><td></td><td>Rule-Based*</td><td>KVR*</td><td>S2S</td><td>S2S + Attn</td><td>Ptr-Unk</td><td>Mem2Seq</td><td>GLMPK1</td><td>GLMPK3</td><td>GLMPK6</td></tr><tr><td>BLEU</td><td>6.6</td><td>13.2</td><td>8.4</td><td>9.3</td><td>8.3</td><td>12.6</td><td>13.83</td><td>14.79</td><td>12.37</td></tr><tr><td>Entity F1</td><td>43.8</td><td>48.0</td><td>10.3</td><td>19.9</td><td>22.7</td><td>33.4</td><td>57.25</td><td>59.97</td><td>53.54</td></tr><tr><td>Schedule F1</td><td>61.3</td><td>62.9</td><td>9.7</td><td>23.4</td><td>26.9</td><td>49.3</td><td>68.74</td><td>69.56</td><td>69.38</td></tr><tr><td>Weather F1</td><td>39.5</td><td>47.0</td><td>14.1</td><td>25.6</td><td>26.7</td><td>32.8</td><td>60.87</td><td>62.58</td><td>55.89</td></tr><tr><td>Navigation F1</td><td>40.4</td><td>41.3</td><td>7.0</td><td>10.8</td><td>14.9</td><td>20.0</td><td>48.62</td><td>52.98</td><td>43.08</td></tr></table>
+
+Human Evaluation   
+
+<table><tr><td></td><td>Mem2Seq</td><td>GLMP</td><td>Human</td></tr><tr><td>Appropriate</td><td>3.89</td><td>4.15</td><td>4.6</td></tr><tr><td>Humanlike</td><td>3.80</td><td>4.02</td><td>4.54</td></tr></table>
+
+# 3.3 RESULTS
+
+bAbI Dialogue. In Table 2, we follow Bordes & Weston (2017) to compare the performance based on per-response accuracy and task-completion rate. Note that for utterance retrieval methods, such as QRN, MN, and GMN, cannot correctly recommend options (T3) and provide additional information (T4), and a poor generalization ability is observed in OOV setting, which has around $30 \%$ performance difference in Task 5. Although previous generation-based approaches (Ptr-Unk, Mem2Seq) have mitigated the gap by incorporating copy mechanism, the simplest cases such as generating and modifying API calls (T1, T2) still face a $6 . 1 7 \%$ OOV performance drop. On the other hand, GLMP achieves a highest $9 2 . 0 \%$ task-completion rate in full dialogue task and surpasses other baselines by a big margin especially in the OOV setting. No per-response accuracy loss for T1, T2, T4 using only the single hop, and only decreases $7 . 9 \%$ in task 5.
+
+Stanford Multi-domain Dialogue. For human-human dialogue scenario, we follow previous dialogue works (Eric et al., 2017; Zhao et al., 2017; Madotto et al., 2018) to evaluate our system on two automatic evaluation metrics, BLEU and entity F1 score 2. As shown in Table 3, GLMP achieves a highest 14.79 BLEU and $5 9 . 9 7 \%$ entity F1 score, which is a slight improvement in BLEU but a huge gain in entity F1. In fact, for unsupervised evaluation metrics in task-oriented dialogues, we argue that the entity F1 might be a more comprehensive evaluation metric than per-response accuracy or BLEU, as shown in Eric et al. (2017) that humans are able to choose the right entities but have very diversified responses. Note that the results of rule-based and KVR are not directly comparable because they simplified the task by mapping the expression of entities to a canonical form using named entity recognition and linking 3.
+
+Table 4: Ablation study using single hop model.   
+
+<table><tr><td rowspan="2"></td><td colspan="5">bAbI Dialogue OOV Per-response Accuracy</td><td rowspan="2">SMD Entity F1</td></tr><tr><td></td><td>T2</td><td>T3</td><td>T4</td><td>T5</td></tr><tr><td>GLMP</td><td>T1 100 (-)</td><td>100 (-)</td><td>95.5 (-)</td><td>100 (-)</td><td>92.0(-)</td><td>All 57.25 (-)</td></tr><tr><td>GLMP w/o H</td><td>90.4 (-9.6)</td><td>85.6 (-14.4)</td><td>95.4 (-0.1)</td><td>100 (-0)</td><td>86.2 (-5.3)</td><td>47.96 (-9.29)</td></tr><tr><td>GLMP w/o G</td><td>100 (-0)</td><td>91.7(-8.3)</td><td>95.5(-0)</td><td>100 (-0)</td><td>92.4 (+0.4)</td><td>45.78 (-11.47)</td></tr></table>
+
+Moreover, human evaluation of the generated responses is reported. We compare our work with previous state-of-the-art model $\mathrm { M e m } \bar { 2 } \mathrm { S e q } ^ { 4 }$ and the original dataset responses as well. We randomly select 200 different dialogue scenarios from the test set to evaluate three different responses. Amazon Mechanical Turk is used to evaluate system appropriateness and human-likeness on a scale from 1 to 5. As the results shown in Table 3, we see that GLMP outperforms Mem2Seq in both measures, which is coherent to previous observation. We also see that human performance on this assessment sets the upper bound on scores, as expected. More details about the human evaluation are reported in the Appendix.
+
+Ablation Study. The contributions of the global memory pointer $G$ and the memory writing of dialogue history $H$ are shown in Table 4. We compare the results using GLMP with $K = 1$ in bAbI OOV setting and SMD. GLMP without $H$ means that the context RNN in the global memory encoder does not write the hidden states into the external knowledge. As one can observe, our model without $H$ has $5 . 3 \%$ more loss in the full dialogue task. On the other hand, GLMP without $G$ means that we do not use the global memory pointer to modify the external knowledge, and an $1 1 . 4 7 \%$ entity F1 drop can be observed in SMD dataset. Note that a $0 . 4 \%$ increase can be observed in task 5, it suggests that the use of global memory pointer may impose too strong prior entity probability. Even if we only report one experiment in the table, this OOV generalization problem can be mitigated by increasing the dropout ratio during training.
+
+Visualization and Qualitative Evaluation. Analyzing the attention weights has been frequently used to interpret deep learning models. In Figure 3, we show the attention vector in the last hop for each generation time step. Y-axis is the external knowledge that we can copy, including the KB information and the dialogue history. Based on the question “what is the address?” asked by the driver in the last turn, the gold answer and our generated response are on the top, and the global memory pointer $G$ is shown in the left column. One can observe that in the right column, the final memory pointer successfully copy the entity chevron in step 0 and its address 783 Arcadia $P l$ in step 3 to fill in the sketch utterance. On the other hand, the memory attention without global weighting is reported in the middle column. One can find that even if the attention weights focus on several point of interests and addresses in step 0 and step 3, the global memory pointer can mitigate the issue as expected. More dialogue visualization and generated results including several negative examples and error analysis are reported in the Appendix.
+
+# 4 RELATED WORKS
+
+Task-oriented dialogue systems. Machine learning based dialogue systems are mainly explored by following two different approaches: modularized and end-to-end. For the modularized systems (Williams & Young, 2007; Wen et al., 2017), a set of modules for natural language understanding (Young et al., 2013; Chen et al., 2016), dialogue state tracking (Lee & Stent, 2016; Zhong et al., 2018), dialogue management (Su et al., 2016), and natural language generation (Sharma et al., 2016) are used. These approaches achieve good stability via combining domain-specific knowledge and slot-filling techniques, but additional human labels are needed. On the other hand, end-to-end approaches have shown promising results recently. Some works view the task as a next utterance retrieval problem, for examples, recurrent entity networks share parameters between RNN (Wu et al., 2017), query reduction networks modify query between layers (Seo et al., 2017), and memory networks (Bordes & Weston, 2017; Liu & Perez, 2017; Wu et al., 2018) perform multi-hop design to strengthen reasoning ability. In addition, some approaches treat the task as a sequence generation problem. Lei et al. (2018) incorporates explicit dialogue states tracking into a delexicalized sequence generation. Serban et al. (2016); Zhao et al. (2017) use recurrent neural networks to generate final responses and achieve good results as well. Although it may increase the search space, these approaches can encourage more flexible and diverse system responses by generating utterances token-by-token.
+
+![](images/3f44f5b17cdfa02ad309742c36ff6cac1567bac341b4996807944890355da418.jpg)  
+Figure 3: Memory attention visualization in the SMD navigation domain. Left column is the global memory pointer $G$ , middle column is the memory pointer without global weighting, and the right column is the final memory pointer.
+
+Pointer network. Vinyals et al. (2015) uses attention as a pointer to select a member of the input source as the output. Such copy mechanisms have also been used in other natural language processing tasks, such as question answering (Dehghani et al., 2017; He et al., 2017), neural machine translation (Gulcehre et al., 2016; Gu et al., 2016), language modeling (Merity et al., 2017), and text summarization (See et al., 2017). In task-oriented dialogue tasks, Eric & Manning (2017) first demonstrated the potential of the copy-augmented Seq2Seq model, which shows that generationbased methods with simple copy strategy can surpass retrieval-based ones. Later, Eric et al. (2017) augmented the vocabulary distribution by concatenating KB attention, which at the same time increases the output dimension. Recently, Madotto et al. (2018) combines end-to-end memory network into sequence generation, which shows that the multi-hop mechanism in MN can be utilized to improve copy attention. These models outperform utterance retrieval methods by copying relevant entities from the KBs.
+
+Others. Zhao et al. (2017) proposes entity indexing and Wu et al. (2018) introduces recorded delexicalization to simplify the problem by record entity tables manually. In addition, our approach utilized recurrent structures to query external memory can be viewed as the memory controller in Memory augmented neural networks (MANN) (Graves et al., 2014; 2016). Similarly, memory encoders have been used in neural machine translation (Wang et al., 2016) and meta-learning applications (Kaiser et al., 2017). However, different from other models that use a single matrix representation for reading and writing, GLMP leverages end-to-end memory networks to perform multiple hop attention, which is similar to the stacking self-attention strategy in the Transformer (Vaswani et al., 2017).
+
+# 5 CONCLUSION
+
+In the work, we present an end-to-end trainable model called global-to-local memory pointer networks for task-oriented dialogues. The global memory encoder and the local memory decoder are designed to incorporate the shared external knowledge into the learning framework. We empirically show that the global and the local memory pointer are able to effectively produce system responses even in the out-of-vocabulary scenario, and visualize how global memory pointer helps as well. As a result, our model achieves state-of-the-art results in both the simulated and the human-human dialogue datasets, and holds potential for extending to other tasks such as question answering and text summarization.
+
+# REFERENCES
+
+Antoine Bordes and Jason Weston. Learning end-to-end goal-oriented dialog. International Conference on Learning Representations, abs/1605.07683, 2017.
+
+Yun-Nung Chen, Dilek Hakkani-Tur, Jianfeng Gao, and Li Deng. End-to-end memory networks ¨ with knowledge carryover for multi-turn spoken language understanding. 2016.
+
+Junyoung Chung, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. NIPS Deep Learning and Representation Learning Workshop, 2014.
+
+Mostafa Dehghani, Sascha Rothe, Enrique Alfonseca, and Pascal Fleury. Learning to attend, copy, and generate for session-based query suggestion. In Proceedings of the 2017 ACM on Conference on Information and Knowledge Management, CIKM ’17, pp. 1747–1756, New York, NY, USA, 2017. ACM. ISBN 978-1-4503-4918-5. doi: 10.1145/3132847.3133010. URL http://doi. acm.org/10.1145/3132847.3133010.
+
+Mihail Eric and Christopher Manning. A copy-augmented sequence-to-sequence architecture gives good performance on task-oriented dialogue. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, pp. 468–473, Valencia, Spain, April 2017. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/E17-2075.
+
+Mihail Eric, Lakshmi Krishnan, Francois Charette, and Christopher D. Manning. Key-value retrieval networks for task-oriented dialogue. In Proceedings of the 18th Annual SIGdial Meeting on Discourse and Dialogue, pp. 37–49. Association for Computational Linguistics, 2017. URL http://aclweb.org/anthology/W17-5506.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, 2014.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio G ´ omez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, ´ et al. Hybrid computing using a neural network with dynamic external memory. Nature, 538 (7626):471–476, 2016.
+
+Jiatao Gu, Zhengdong Lu, Hang Li, and Victor O.K. Li. Incorporating copying mechanism in sequence-to-sequence learning. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1631–1640, Berlin, Germany, August 2016. Association for Computational Linguistics. URL http://www.aclweb.org/ anthology/P16-1154.
+
+Caglar Gulcehre, Sungjin Ahn, Ramesh Nallapati, Bowen Zhou, and Yoshua Bengio. Pointing the unknown words. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 140–149, Berlin, Germany, August 2016. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/ P16-1014.
+
+Shizhu He, Cao Liu, Kang Liu, and Jun Zhao. Generating natural answers by incorporating copying and retrieving mechanisms in sequence-to-sequence learning. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 199– 208, Vancouver, Canada, July 2017. Association for Computational Linguistics. URL http: //aclweb.org/anthology/P17-1019.
+
+Lukasz Kaiser, Ofir Nachum, Aurko Roy, and Samy Bengio. Learning to remember rare events. International Conference on Learning Representations, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 2015.
+
+Sungjin Lee and Amanda Stent. Task lineages: Dialog state tracking for flexible interaction. In Proceedings of the 17th Annual Meeting of the Special Interest Group on Discourse and Dialogue, pp. 11–21, 2016.
+
+Wenqiang Lei, Xisen Jin, Min-Yen Kan, Zhaochun Ren, Xiangnan He, and Dawei Yin. Sequicity: Simplifying task-oriented dialogue systems with single sequence-to-sequence architectures. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1437–1447, 2018.
+
+Fei Liu and Julien Perez. Gated end-to-end memory networks. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, pp. 1–10, Valencia, Spain, April 2017. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/E17-1001.
+
+Andrea Madotto, Chien-Sheng Wu, and Pascale Fung. Mem2seq: Effectively incorporating knowledge bases into end-to-end task-oriented dialog systems. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1468–1478. Association for Computational Linguistics, 2018. URL http://aclweb.org/ anthology/P18-1136.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. International Conference on Learning Representations, 2017.
+
+Alexander Miller, Adam Fisch, Jesse Dodge, Amir-Hossein Karimi, Antoine Bordes, and Jason Weston. Key-value memory networks for directly reading documents. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 1400–1409, Austin, Texas, November 2016. Association for Computational Linguistics. URL https://aclweb. org/anthology/D16-1147.
+
+Abigail See, Peter J. Liu, and Christopher D. Manning. Get to the point: Summarization with pointer-generator networks. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1073–1083, Vancouver, Canada, July 2017. Association for Computational Linguistics. URL http://aclweb.org/ anthology/P17-1099.
+
+Minjoon Seo, Sewon Min, Ali Farhadi, and Hannaneh Hajishirzi. Query-reduction networks for question answering. International Conference on Learning Representations, 2017.
+
+Iulian Vlad Serban, Alessandro Sordoni, Yoshua Bengio, Aaron C Courville, and Joelle Pineau. Building end-to-end dialogue systems using generative hierarchical neural network models. In AAAI, pp. 3776–3784, 2016.
+
+Shikhar Sharma, Jing He, Kaheer Suleman, Hannes Schulz, and Philip Bachman. Natural language generation in dialogue using lexicalized and delexicalized data. International Conference on Learning Representations, 2016.
+
+Pei-Hao Su, Milica Gasic, Nikola Mrksic, Lina Rojas-Barahona, Stefan Ultes, David Vandyke, Tsung-Hsien Wen, and Steve Young. On-line active reward learning for policy optimisation in spoken dialogue systems. Association for Computational Linguistics, 2016.
+
+Sainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end memory networks. In Advances in neural information processing systems, pp. 2440–2448, 2015.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 6000–6010, 2017.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 2692–2700. Curran Associates, Inc., 2015. URL http://papers.nips. cc/paper/5866-pointer-networks.pdf.
+
+Mingxuan Wang, Zhengdong Lu, Hang Li, and Qun Liu. Memory-enhanced decoder for neural machine translation. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 278–286, Austin, Texas, November 2016. Association for Computational Linguistics. URL https://aclweb.org/anthology/D16-1027.
+
+Tsung-Hsien Wen, Milica Gasic, Nikola Mrksic, Lina Maria Rojas-Barahona, Pei hao Su, Stefan Ultes, David Vandyke, and Steve J. Young. A network-based end-to-end trainable task-oriented dialogue system. In EACL, 2017.
+
+Jason D Williams and Steve Young. Partially observable markov decision processes for spoken dialog systems. Computer Speech & Language, 21(2):393–422, 2007.
+
+Chien-Sheng Wu, Andrea Madotto, Genta Winata, and Pascale Fung. End-to-end recurrent entity network for entity-value independent goal-oriented dialog learning. In Dialog System Technology Challenges Workshop, DSTC6, 2017.
+
+Chien-Sheng Wu, Andrea Madotto, Genta Winata, and Pascale Fung. End-to-end dynamic query memory network for entity-value independent task-oriented dialog. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6154–6158, April 2018.
+
+Steve Young, Milica Gasiˇ c, Blaise Thomson, and Jason D Williams. Pomdp-based statistical spoken ´ dialog systems: A review. Proceedings of the IEEE, 101(5):1160–1179, 2013.
+
+Tiancheng Zhao, Allen Lu, Kyusong Lee, and Maxine Eskenazi. Generative encoder-decoder models for task-oriented spoken dialog systems with chatting capability. In Proceedings of the 18th Annual SIGdial Meeting on Discourse and Dialogue, pp. 27–36. Association for Computational Linguistics, August 2017. URL http://aclweb.org/anthology/W17-5505.
+
+Victor Zhong, Caiming Xiong, and Richard Socher. Global-locally self-attentive dialogue state tracker. In Association for Computational Linguistics, 2018.
+
+A TABLES
+
+A.1 TRAINING PARAMETERS
+
+Table 5: Selected hyper-parameters in each dataset for different hops. The values is the embedding dimension and the GRU hidden size, and the values between parenthesis is the dropout rate. For all the models we used learning rate equal to 0.001, with a decay rate of 0.5.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>T1</td><td rowspan=1 colspan=1>T2</td><td rowspan=1 colspan=1>T3</td><td rowspan=1 colspan=1>T4</td><td rowspan=1 colspan=1>T5</td><td rowspan=1 colspan=1>SMD</td></tr><tr><td rowspan=1 colspan=1>GLMP K1</td><td rowspan=1 colspan=1>64 (0.1)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.7)</td><td rowspan=1 colspan=1>128 (0.3)</td><td rowspan=1 colspan=1>128 (0.2)</td></tr><tr><td rowspan=1 colspan=1>GLMP K3</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.7)</td><td rowspan=1 colspan=1>128 (0.1)</td><td rowspan=1 colspan=1>128 (0.2)</td></tr><tr><td rowspan=1 colspan=1>GLMP K6</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.5)</td><td rowspan=1 colspan=1>64 (0.5)</td><td rowspan=1 colspan=1>128 (0.1)</td><td rowspan=1 colspan=1>128 (0.3)</td></tr></table>
+
+# A.2 DATASET STATISTICS
+
+Table 6: Dataset statistics for 2 datasets.   
+
+<table><tr><td rowspan=2 colspan=1>Task</td><td rowspan=2 colspan=1>1</td><td rowspan=2 colspan=1>2</td><td rowspan=2 colspan=1>3</td><td rowspan=2 colspan=1>4</td><td rowspan=2 colspan=1>5</td><td rowspan=1 colspan=3>SMD</td></tr><tr><td rowspan=1 colspan=3>Calendar  Weather  Navigation</td></tr><tr><td rowspan=1 colspan=1>Avg. User turns</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>6.5</td><td rowspan=1 colspan=1>6.4</td><td rowspan=1 colspan=1>3.5</td><td rowspan=1 colspan=1>12.9</td><td rowspan=1 colspan=3>2.6</td></tr><tr><td rowspan=1 colspan=1>Avg. Sys turns</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>9.5</td><td rowspan=1 colspan=1>9.9</td><td rowspan=1 colspan=1>3.5</td><td rowspan=1 colspan=1>18.4</td><td rowspan=1 colspan=3>2.6</td></tr><tr><td rowspan=1 colspan=1>Avg. KB results</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>24</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>23.7</td><td rowspan=1 colspan=3>66.1</td></tr><tr><td rowspan=1 colspan=1>Avg. Syswords</td><td rowspan=1 colspan=1>6.3</td><td rowspan=1 colspan=1>6.2</td><td rowspan=1 colspan=1>7.2</td><td rowspan=1 colspan=1>5.7</td><td rowspan=1 colspan=1>6.5</td><td rowspan=1 colspan=3>8.6</td></tr><tr><td rowspan=1 colspan=1>Max. Sys words</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=3>87</td></tr><tr><td rowspan=1 colspan=1>Nb. Slot Types</td><td rowspan=1 colspan=3>7</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>Nb. Distinct Slot values</td><td rowspan=1 colspan=3>1</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>79</td><td rowspan=1 colspan=1>65</td><td rowspan=1 colspan=1>140</td></tr><tr><td rowspan=1 colspan=1>Vocabulary</td><td rowspan=1 colspan=5>3747</td><td rowspan=1 colspan=3>1601</td></tr><tr><td rowspan=1 colspan=1>Train dialogues</td><td rowspan=1 colspan=5>1000</td><td rowspan=1 colspan=3>2425</td></tr><tr><td rowspan=1 colspan=1>Val dialogues</td><td rowspan=1 colspan=5>1000</td><td rowspan=1 colspan=3>302</td></tr><tr><td rowspan=1 colspan=1>Test dialogues</td><td rowspan=1 colspan=5>1000+1000OOV</td><td rowspan=1 colspan=3>304</td></tr><tr><td rowspan=1 colspan=1>Total Nb. Dialogues</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>1034</td><td rowspan=1 colspan=1>997</td><td rowspan=1 colspan=1>1000</td></tr></table>
+
+# A.3 HUMAN EVALUATION
+
+![](images/32f2f462831d343fe847f6b9bc63c74965fb2e0045c58dc442b732d6a36ae113.jpg)  
+Figure 4: Appropriateness and human-likeness scores according to 200 dialogue scenarios.
+
+Appropriateness 5: Correct grammar, correct logic, correct dialogue flow, and correct entity provided
+
+4: Correct dialogue flow, logic and grammar but has slightly mistakes in entity provided   
+3: Noticeable mistakes about grammar or logic or entity provided but acceptable   
+2: Poor grammar, logic and entity provided   
+1: Wrong grammar, wrong logic, wrong dialogue flow, and wrong entity provided
+
+Human-Likeness (Naturalness)
+
+5: The utterance is $100 \%$ like what a person will say   
+4: The utterance is $7 5 \%$ like what a person will say   
+3: The utterance is $50 \%$ like what a person will say   
+2: The utterance is $2 5 \%$ like what a person will say   
+1: The utterance is $0 \%$ like what a person will say
+
+# B ERROR ANALYSIS
+
+For bAbI dialogues, the mistakes are mainly from task 3, which is recommending restaurants based on their rating from high to low. We found that sometimes the system will keep sending those restaurants with the higher score even if the user rejected them in the previous turns. On the other hand, SMD is more challenging for response generation. First, we found that the model makes mistakes when the KB has several options corresponding to the user intention. For example, once the user has more than one doctor appointment in the table, the model can barely recognize. In addition, since we do not include the domain specific and user intention supervision, wrong delexicalized responses may be generated, which results in an incorrect entity copy. Lastly, we found that the copied entities may not be matched to the generated sketch tags. For example, an address tag may result in a distance entity copy. We leave the space of improvement to future works.
+
+# C ADDITIONAL DISCUSSION
+
+One of the reviewers suggested us to compare our work to some existing dialogue framework such as PyDial 5. To the best of our knowledge, in the PyDial framework, it requires to have the dialogue acts labels for the NLU module and the belief states labels for the belief tracker module. The biggest challenge is we do not have such labels in the SMD and bAbI datasets. Moreover, the semi tracker in PyDial is rule-based, which need to re-write rules whenever it encounters a new domain or new datasets. Even its dialogue management module could be a learning solution like policy networks, the input of the policy network is still the hand-crafted state features and labels. Therefore, without the rules and labels predefined in the NLU and belief tracker modules, PyDial could not learn a good policy network.
+
+Truly speaking, based on the data we have (not very big size) and the current state-of-the-art machine learning algorithms and models, we believe that a well and carefully constructed task-oriented dialogue system using PyDial in a known domain using human rules (in NLU and Belief Tracker) with policy networks may outperform the end-to-end systems (more robust). However, in this paper, without additional human labels and human rules, we want to explore the potential and the advantage of end-to-end systems. Besides easy to train, for multi-domain cases, or even zero-shot domain cases, we believe end-to-end approaches will have better adaptability compared to any rule-based systems.
+
+# D VISUALIZATION
+
+![](images/290fc9b752ca9f088989291e947524043742482693f523d5a431cf559f6fa452.jpg)  
+Delexicalized Generation: the nearest @poi_type is @poi , @distance away at @address   
+Figure 5: Memory attention visualization from the SMD navigation domain.
+
+![](images/6354b5c9c9402d6735ba6bc5ca70e3f77537da6faf9df8adc2bd33482cdfb65a.jpg)  
+Figure 6: Memory attention visualization from the SMD navigation domain.
+
+![](images/15c4d03605a8a1e7ed7b6312db2a378d33bdcebc2906a1e405eeb101f3e9783a.jpg)  
+Figure 7: Memory attention visualization from the SMD navigation domain.
+
+![](images/11cb76abe5b46e80e5e9cf8fbc0f98a3087371d226357cd1d0287b107804f7ae.jpg)  
+Figure 8: Memory attention visualization from the SMD navigation domain.
+
+![](images/9fd7edc83846eeabd0ba0c75a732d513120cabacc045690eef78ef8e5256f37c.jpg)  
+Figure 9: Memory attention visualization from the SMD schedule domain.
+
+![](images/e8d491b0b50c946d05eac9ba5ebd9b2f067345f9eb6daf7f57cd5ddbb981cdfe.jpg)  
+Figure 10: Memory attention visualization from the SMD schedule domain.
+
+![](images/f3abd5eb76208bb8596b053c1b1809dd91e70ff21e9131a470dbfbc7ed36f374.jpg)  
+Figure 11: Memory attention visualization from the SMD schedule domain.
+
+![](images/93ed72e4a27efe7be96d8427dabcc7e7d917560b9a2b70cd7b3936ba04076d0f.jpg)  
+Figure 12: Memory attention visualization from the SMD schedule domain.
+
+![](images/609472f7f7de07187a25923dc536ca32a492cd679fc7710ba1a8af54a8f8b3ed.jpg)![](images/73ec96be661cfd6a535ae39da198630b532ea825b95011cd90ba7dd470abeb3b.jpg)
+
+![](images/3a4d0271aaa2c87b3ca5f2b504d7052d3e849ccdbbea2f2d2d63fd68342b9b25.jpg)  
+Figure 13: Memory attention visualization from the SMD weather domain.
+
+![](images/deb8c2c960a252ed33c1049dfcf767ee899e858e067e63538eac1565fc6f0c8b.jpg)
+
+![](images/63641c08852c6b92db3bbaa859246b0ede4afd893e98a96c582479e50d4089dc.jpg)  
+Figure 14: Memory attention visualization from the SMD weather domain.
+
+![](images/0e608b243cec3843dc3c063e35ea9ad30b654bf8613a5f83fd87892b6b57a537.jpg)

parse/train/ryxnHhRqFm/ryxnHhRqFm_content_list.json

@@ -0,0 +1,1707 @@
+[
+    {
+        "type": "text",
+        "text": "GLOBAL-TO-LOCAL MEMORY POINTER NETWORKS FOR TASK-ORIENTED DIALOGUE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chien-Sheng $\\mathbf { W _ { u } } ^ { \\dagger } \\ast$ , Richard Socher‡ & Caiming Xiong‡ ",
+        "bbox": [
+            183,
+            169,
+            571,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "‡Salesforce Research   \n{rsocher,cxiong}@salesforce.com   \n†The Hong Kong University of Science and Technology   \njason.wu@connect.ust.hk ",
+        "bbox": [
+            184,
+            186,
+            550,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            279,
+            544,
+            294
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "End-to-end task-oriented dialogue is challenging since knowledge bases are usually large, dynamic and hard to incorporate into a learning framework. We propose the global-to-local memory pointer (GLMP) networks to address this issue. In our model, a global memory encoder and a local memory decoder are proposed to share external knowledge. The encoder encodes dialogue history, modifies global contextual representation, and generates a global memory pointer. The decoder first generates a sketch response with unfilled slots. Next, it passes the global memory pointer to filter the external knowledge for relevant information, then instantiates the slots via the local memory pointers. We empirically show that our model can improve copy accuracy and mitigate the common out-of-vocabulary problem. As a result, GLMP is able to improve over the previous state-of-theart models in both simulated bAbI Dialogue dataset and human-human Stanford Multi-domain Dialogue dataset on automatic and human evaluation. ",
+        "bbox": [
+            233,
+            308,
+            764,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            334,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Task-oriented dialogue systems aim to achieve specific user goals such as restaurant reservation or navigation inquiry within a limited dialogue turns via natural language. Traditional pipeline solutions are composed of natural language understanding, dialogue management and natural language generation (Young et al., 2013; Wen et al., 2017), where each module is designed separately and expensively. In order to reduce human effort and scale up between domains, end-to-end dialogue systems, which input plain text and directly output system responses, have shown promising results based on recurrent neural networks (Zhao et al., 2017; Lei et al., 2018) and memory networks (Sukhbaatar et al., 2015). These approaches have the advantages that the dialogue states are latent without hand-crafted labels and eliminate the needs to model the dependencies between modules and interpret knowledge bases (KB) manually. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            680
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, despite the improvement by modeling KB with memory network (Bordes & Weston, 2017; Madotto et al., 2018), end-to-end systems usually suffer from effectively incorporating external KB into the system response generation. The main reason is that a large, dynamic KB is equal to a noisy input and hard to encode and decode, which makes the generation unstable. Different from chit-chat scenario, this problem is especially harmful in task-oriented one, since the information in KB is usually the expected entities in the response. For example, in Table 1 the driver will expect to get the correct address to the gas station other than a random place such as a hospital. Therefore, pointer networks (Vinyals et al., 2015) or copy mechanism (Gu et al., 2016) is crucial to successfully generate system responses because directly copying essential words from the input source to the output not only reduces the generation difficulty, but it is also more like a human behavior. For example, in Table 1, when human want to reply others the Valero’s address, they will need to “copy” the information from the table to their response as well. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Therefore, in the paper, we propose the global-to-local memory pointer (GLMP) networks, which is composed of a global memory encoder, a local memory decoder, and a shared external knowledge. Unlike existing approaches with copy ability (Gulcehre et al., 2016; Gu et al., 2016; Eric & ",
+        "bbox": [
+            176,
+            862,
+            825,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/9bbc74943e80ba331c29ff1c14a7733b52298b89d76245181a622af2a101e0f1.jpg",
+        "table_caption": [
+            "Table 1: An in-car assistant example on the navigation domain. The left part is the KB information and the right part is the conversation between a driver and our system. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Point of interest (poi)</td><td>Distance</td><td>Traffic</td><td>Poi type</td><td>Address</td></tr><tr><td>Toms house</td><td>3 miles</td><td>heavy</td><td>friend&#x27;s house</td><td>580Van Ness Ave</td></tr><tr><td>Coupa</td><td>2 miles</td><td>moderate</td><td>coffee or tea place</td><td>394Van NessAve</td></tr><tr><td>Pandaexpress</td><td>2 miles</td><td>no</td><td>Chineserestaurant</td><td>842Arrowhead Way</td></tr><tr><td>Stanford expresscare</td><td>5 miles</td><td>no</td><td>hospital</td><td>214 El Camino Real</td></tr><tr><td>Valero</td><td>4 miles</td><td>heavy</td><td>gas station</td><td>200 Alester Ave</td></tr><tr><td>Starbucks</td><td>1 miles</td><td>heavy</td><td>coffee or teaplace</td><td>792 Bedoin St</td></tr></table>",
+        "bbox": [
+            176,
+            133,
+            534,
+            191
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/f2d15f82857a72117da970fbe60029b5e28d8620b22c11126d6787533f5e68ee.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Driver</td><td>I need gas</td></tr><tr><td>System</td><td>GLMP:Thereisa gasstation locally Valero is 4 milesaway Gold: Valero is 4 miles away</td></tr><tr><td>Driver</td><td>What is theaddress？</td></tr><tr><td>System</td><td>GLMP:Valero is locatedat200 Alester Ave Gold: Valero is at 200 Alester Ave</td></tr><tr><td>Driver</td><td>Thank you!</td></tr></table>",
+        "bbox": [
+            545,
+            133,
+            821,
+            191
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Manning, 2017; Madotto et al., 2018), which the only information passed to decoder is the encoder hidden states, our model shares the external knowledge and leverages the encoder and the external knowledge to learn a global memory pointer and global contextual representation. Global memory pointer modifies the external knowledge by softly filtering words that are not necessary for copying. Afterward, instead of generating system responses directly, the local memory decoder first uses a sketch RNN to obtain sketch responses without slot values but sketch tags, which can be considered as learning a latent dialogue management to generate dialogue action template. Then the decoder generates local memory pointers to copy words from external knowledge and instantiate sketch tags. ",
+        "bbox": [
+            174,
+            208,
+            823,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We empirically show that GLMP can achieve superior performance using the combination of global and local memory pointers. In simulated out-of-vocabulary (OOV) tasks in the bAbI dialogue dataset (Bordes & Weston, 2017), GLMP achieves $9 2 . 0 \\%$ per-response accuracy and surpasses existing end-to-end approaches by $7 . 5 \\%$ in full dialogue. In the human-human dialogue dataset (Eric et al., 2017), GLMP is able to surpass the previous state of the art on both automatic and human evaluation, which further confirms the effectiveness of our double pointers usage. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 GLMP MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            430,
+            331,
+            445
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our model 1 is composed of three parts: global memory encoder, external knowledge, and local memory decoder, as shown in Figure 1(a). The dialogue history $X = ( x _ { 1 } , \\ldots , x _ { n } ) $ and the KB information $B \\ = \\ ( b _ { 1 } , \\ldots , b _ { l } )$ are the input, and the system response $Y = ( y _ { 1 } , \\dots y _ { m } ) $ is the expected output, where $n , l , m$ are the corresponding lengths. First, the global memory encoder uses a context RNN to encode dialogue history and writes its hidden states into the external knowledge. Then the last hidden state is used to read the external knowledge and generate the global memory pointer at the same time. On the other hand, during the decoding stage, the local memory decoder first generates sketch responses by a sketch RNN. Then the global memory pointer and the sketch RNN hidden state are passed to the external knowledge as a filter and a query. The local memory pointer returns from the external knowledge can copy text from the external knowledge to replace the sketch tags and obtain the final system response. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            614
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 EXTERNAL KNOWLEDGE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            387,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our external knowledge contains the global contextual representation that is shared with the encoder and the decoder. To incorporate external knowledge into a learning framework, end-to-end memory networks (MN) are used to store word-level information for both structural KB (KB memory) and temporal-dependent dialogue history (dialogue memory), as shown in Figure 1(b). In addition, the MN is well-known for its multiple hop reasoning ability (Sukhbaatar et al., 2015), which is appealing to strengthen copy mechanism. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            741
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Global contextual representation. In the KB memory module, each element $b _ { i } \\in B$ is represented in the triplet format as (Subject, Relation, Object) structure, which is a common format used to represent KB nodes (Miller et al., 2016; Eric et al., 2017). For example, the KB in the Table 1 will be denoted as {(Tom’s house, distance, 3 miles), ..., (Starbucks, address, 792 Bedoin $S t ) \\}$ . On the other hand, the dialogue context $X$ is stored in the dialogue memory module, where the speaker and temporal encoding are included as in Bordes & Weston (2017) like a triplet format. For instance, the first utterance from the driver in the Table 1 will be denoted as $\\{ ( \\mathbb { S } u s e r , t u r n I , I ) ,$ , (\\$user, turn1, need), $( \\mathbb { S } u s e r , \\ t u r n I , \\ g a s ) \\}$ . For the two memory modules, a bag-of-word representation is used as the memory embeddings. During the inference time, we copy the object word once a memory position is pointed to, for example, 3 miles will be copied if the triplet (Toms house, distance, 3 miles) is selected. We denote $O b j e c t ( . )$ function as getting the object word from a triplet. ",
+        "bbox": [
+            173,
+            747,
+            825,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/c8f60b9c4b57e7e89923b80b7e27951d97d0ddd2e1035dfc258040b7cc13d06d.jpg",
+        "image_caption": [
+            "Figure 1: The proposed (a) global-to-local memory pointer networks for task-oriented dialogue systems and the (b) external knowledge architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            103,
+            816,
+            308
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Knowledge read and write. Our external knowledge is composed of a set of trainable embedding matrices $\\boldsymbol { C } = ( C ^ { 1 } , \\ldots , C ^ { K + 1 } )$ , where $C ^ { k } \\in \\mathbb { R } ^ { | V | \\times d _ { e m b } }$ , $K$ is the maximum memory hop in the MN, $| V |$ is the vocabulary size and $d _ { e m b }$ is the embedding dimension. We denote memory in the external knowledge as $M = [ B ; X ] = ( m _ { 1 } , \\ldots , m _ { n + l } ) ,$ , where $m _ { i }$ is one of the triplet components mentioned. To read the memory, the external knowledge needs a initial query vector $q ^ { 1 }$ . Moreover, it can loop over $K$ hops and computes the attention weights at each hop $k$ using ",
+        "bbox": [
+            173,
+            371,
+            825,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d9159253bc0d238dddfbe4a82aa16bfee09dc27736b68e94aff302d904c2859.jpg",
+        "text": "$$\np _ { i } ^ { k } = \\mathrm { S o f t m a x } ( ( q ^ { k } ) ^ { T } c _ { i } ^ { k } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            460,
+            581,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $c _ { i } ^ { k } = B ( C ^ { k } ( m _ { i } ) ) \\in \\mathbb { R } ^ { d _ { e m b } }$ is the embedding in $i ^ { t h }$ memory position using the embedding matrix $C ^ { k }$ , $q ^ { k }$ is the query vector for hop $k$ , and $B ( . )$ is the bag-of-word function. Note that $p ^ { k } \\in$ $\\mathbb { R } ^ { n + l }$ is a soft memory attention that decides the memory relevance with respect to the query vector. Then, the model reads out the memory $o ^ { k }$ by the weighted sum over $c ^ { k + \\mathbf { \\hat { 1 } } }$ and update the query vector $q ^ { k + 1 }$ . Formally, ",
+        "bbox": [
+            174,
+            481,
+            825,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/736ebc7b5d2f85067fb952a8339c3c0387734c7126f851beb585f619066d9d51.jpg",
+        "text": "$$\no ^ { k } = \\sum _ { i } p _ { i } ^ { k } c _ { i } ^ { k + 1 } , \\quad q ^ { k + 1 } = q ^ { k } + o ^ { k } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            551,
+            624,
+            585
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 GLOBAL MEMORY ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            602,
+            416,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2(a), a context RNN is used to model the sequential dependency and encode the context $X$ . Then the hidden states are written into the external knowledge as shown in Figure 1(b). Afterward, the last encoder hidden state serves as the query to read the external knowledge and get two outputs, the global memory pointer and the memory readout. Intuitively, since it is hard for MN architectures to model the dependencies between memories (Wu et al., 2018), which is a serious drawback especially in conversational related tasks, writing the hidden states to the external knowledge can provide sequential and contextualized information. With meaningful representation, our pointers can correctly copy out words from external knowledge, and the common OOV challenge can be mitigated. In addition, using the encoded dialogue context as a query can encourage our external knowledge to read out memory information related to the hidden dialogue states or user intention. Moreover, the global memory pointer that learns a global memory distribution is passed to the decoder along with the encoded dialogue history and KB information. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Context RNN. A bi-directional gated recurrent unit (GRU) (Chung et al., 2014) is used to encode dialogue history into the hidden states $H = ( h _ { 1 } ^ { e } , \\ldots , h _ { 1 } ^ { e } )$ , and the last hidden state $h _ { n } ^ { e }$ is used to query the external knowledge as the encoded dialogue history. In addition, the hidden states $H$ are written into the dialogue memory module in the external knowledge by summing up the original memory representation with the corresponding hidden states. In formula, ",
+        "bbox": [
+            173,
+            801,
+            825,
+            872
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/400a9d5e63908ceded909c87b206a445c523d47f645df7da63be4a39d155c3f8.jpg",
+        "text": "$$\nc _ { i } ^ { k } = c _ { i } ^ { k } + h _ { m _ { i } } ^ { e } \\quad \\mathrm { i f } \\quad m _ { i } \\in X \\mathrm { a n d } \\forall k \\in [ 1 , K + 1 ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            875,
+            668,
+            892
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Global memory pointer. Global memory pointer $G = ( g _ { 1 } , \\dots , g _ { n + l } )$ is a vector containing real values between 0 and 1. Unlike conventional attention mechanism that all the weights sum to one, each element in $G$ is an independent probability. We first query the external knowledge using $h _ { n } ^ { e }$ until the last hop, and instead of applying the Softmax function as in (1), we perform an inner product followed by the Sigmoid function. The memory distribution we obtained is the global memory pointer $G$ , which is passed to the decoder. To further strengthen the global pointing ability, we add an auxiliary loss to train the global memory pointer as a multi-label classification task. We show in the ablation study that adding this additional supervision does improve the performance. Lastly, the memory readout $q ^ { K + 1 }$ is used as the encoded KB information. ",
+        "bbox": [
+            173,
+            895,
+            828,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/84a38933bb34698d01854f932903cce5a8a771fb337ce457030c01c03dd0b74a.jpg",
+        "image_caption": [
+            "Figure 2: The proposed (a) global memory encoder and the (b) local memory decoder architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            104,
+            810,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            353,
+            825,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the auxiliary task, we define the label $G ^ { l a b e l } = ( g _ { 1 } ^ { l } , \\ldots , g _ { n + l } ^ { l } )$ by checking whether the object words in the memory exists in the expected system response $Y$ . Then the global memory pointer is trained using binary cross-entropy loss $L o s s _ { g }$ between $G$ and $G ^ { l a b e l }$ . In formula, ",
+        "bbox": [
+            174,
+            457,
+            823,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb84213b183d63ad4ac6cf15731320321e97727e1e0ae2d129f4a9ad3d79986f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { g _ { i } = \\mathrm { S i g m o i d } ( ( q ^ { K } ) ^ { T } c _ { i } ^ { K } ) , \\quad g _ { i } ^ { l } = \\left\\{ \\begin{array} { l l } { 1 } & { \\mathrm { i f } O b j e c t ( m _ { i } ) \\in Y } \\\\ { 0 } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. , } \\\\ & { \\quad L o s s _ { g } = - \\sum _ { i = 1 } ^ { n + l } [ g _ { i } ^ { l } \\times \\log g _ { i } + ( 1 - g _ { i } ^ { l } ) \\times \\log { ( 1 - g _ { i } ) } ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            508,
+            699,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 LOCAL MEMORY DECODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            588,
+            401,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the encoded dialogue history $h _ { n } ^ { e }$ , the encoded KB information $q ^ { K + 1 }$ , and the global memory pointer $G$ , our local memory decoder first initializes its sketch RNN using the concatenation of $h _ { n } ^ { e }$ and $q ^ { K + 1 }$ , and generates a sketch response that excludes slot values but includes the sketch tags. For example, sketch RNN will generate “@poi is $@$ distance away”, instead of “Starbucks is 1 mile away.” At each decoding time step, the hidden state of the sketch RNN is used for two purposes: 1) predict the next token in vocabulary, which is the same as standard sequence-to-sequence (S2S) learning; 2) serve as the vector to query the external knowledge. If a sketch tag is generated, the global memory pointer is passed to the external knowledge, and the expected output word will be picked up from the local memory pointer. Otherwise, the output word is the word that generated by the sketch RNN. For example in Figure 2(b), a $\\ @ \\mathrm { p o i }$ tag is generated at the first time step, therefore, the word Starbucks is picked up from the local memory pointer as the system output word. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Sketch RNN. We use a GRU to generate a sketch response $Y ^ { s } = ( y _ { 1 } ^ { s } , \\ldots , y _ { m } ^ { s } ) $ without real slot values. The sketch RNN learns to generate a dynamic dialogue action template based on the encoded dialogue $( h _ { n } ^ { e } )$ and KB information $( q ^ { K + 1 } )$ . At each decoding time step $t$ , the sketch RNN hidden state $\\hat { h } _ { t } ^ { d }$ and its output distribution $P _ { t } ^ { v o c a b }$ are defined as ",
+        "bbox": [
+            173,
+            773,
+            823,
+            832
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a929b94655efba8d17d96eee5079958095488f8297023fe3421f03e54f52ab01.jpg",
+        "text": "$$\nh _ { t } ^ { d } = \\mathrm { { G R U } } ( C ^ { 1 } ( \\hat { y } _ { t - 1 } ^ { s } ) , h _ { t - 1 } ^ { d } ) , \\quad P _ { t } ^ { v o c a b } = \\mathrm { { S o f t m a x } } ( W h _ { t } ^ { d } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            838,
+            691,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use the standard cross-entropy loss to train the sketch RNN, we define $L o s s _ { v }$ as. ",
+        "bbox": [
+            173,
+            864,
+            728,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32d49bc98643121fc7c19f29329531842e93fbbbecea4757c7dff7f12a1910c9.jpg",
+        "text": "$$\nL o s s _ { v } = \\sum _ { t = 1 } ^ { m } - \\log ( P _ { t } ^ { v o c a b } ( y _ { t } ^ { s } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            887,
+            609,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We replace the slot values in $Y$ into sketch tags based on the provided entity table. The sketch tags $S T$ are all the possible slot types that start with a special token, for example, $@$ address stands for all the addresses and $@$ distance stands for all the distance information. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Local memory pointer. Local memory pointer $L = ( L _ { 1 } , \\dots , L _ { m } )$ contains a sequence of pointers. At each time step $t$ , the global memory pointer $G$ first modify the global contextual representation using its attention weights, ",
+        "bbox": [
+            173,
+            151,
+            823,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/16b2b3491dff8f327f189fbaed50e2c3d2354186d76b1bcf08f6927bf27a9563.jpg",
+        "text": "$$\nc _ { i } ^ { k } = c _ { i } ^ { k } \\times g _ { i } , \\quad \\forall i \\in [ 1 , n + l ] \\mathrm { a n d } \\forall k \\in [ 1 , K + 1 ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            200,
+            671,
+            218
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and then the sketch RNN hidden state $h _ { t } ^ { d }$ queries the external knowledge. The memory attention in the last hop is the corresponding local memory pointer $L _ { t }$ , which is represented as the memory distribution at time step $t$ . To train the local memory pointer, a supervision on top of the last hop memory attention in the external knowledge is added. We first define the position label of local memory pointer $L ^ { l a b e l }$ at the decoding time step $t$ as ",
+        "bbox": [
+            173,
+            226,
+            825,
+            296
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92a9c8dafb7024fadc3cf5d3dadbcf5432481d1a58306d721d659f8b55a1397d.jpg",
+        "text": "$$\nL _ { t } ^ { l a b e l } = \\left\\{ { \\begin{array} { l l } { m a x ( z ) } & { { \\mathrm { i f ~ } } \\exists z { \\mathrm { ~ s . t . ~ } } y _ { t } = O b j e c t ( m _ { z } ) , } \\\\ { n + l + 1 } & { { \\mathrm { o t h e r w i s e . } } } \\end{array} } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            303,
+            666,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The position $n { + } l { + } 1$ is a null token in the memory that allows us to calculate loss function even if $y _ { t }$ does not exist in the external knowledge. Then, the loss between $L$ and $L ^ { l a b e l }$ is defined as ",
+        "bbox": [
+            173,
+            344,
+            825,
+            372
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7af6176a4fe893a2cd42cfc1137cfe7109e4ee757010222d2974a682a4a116b2.jpg",
+        "text": "$$\nL o s s _ { l } = \\sum _ { t = 1 } ^ { m } - \\log ( L _ { t } ( L _ { t } ^ { l a b e l } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            378,
+            606,
+            420
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, a record $R \\in \\mathbb { R } ^ { n + l }$ is utilized to prevent from copying same entities multiple times. All the elements in $R$ are initialized as 1 in the beginning. During the decoding stage, if a memory position has been pointed to, its corresponding position in $R$ will be masked out. During the inference time, $\\hat { y } _ { t }$ is defined as ",
+        "bbox": [
+            173,
+            425,
+            825,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3553cc38fd534edcd45def8e6b64e6c490884294a1a51e4b7e5814d29c59f4eb.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { y } _ { t } = \\left\\{ \\begin{array} { l l } { \\arg \\operatorname* { m a x } \\bigl ( P _ { t } ^ { v o c a b } \\bigr ) } & { \\mathrm { i f ~ } \\arg \\operatorname* { m a x } \\bigl ( P _ { t } ^ { v o c a b } \\bigr ) \\notin S T , } \\\\ { O b j e c t \\bigl ( m _ { \\arg \\operatorname* { m a x } \\left( L _ { t } \\odot R \\right) } \\bigr ) } & { \\mathrm { o t h e r w i s e } , } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            488,
+            702,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ is the element-wise multiplication. Lastly, all the parameters are jointly trained by minimizing the weighted-sum of three losses $( \\alpha , \\beta , \\gamma$ are hyper-parameters): ",
+        "bbox": [
+            173,
+            530,
+            821,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6c45ed33547a38453b1a544a5a506d84ad366e45567083ab45b63132b69fab1b.jpg",
+        "text": "$$\n\\begin{array} { r } { L o s s = \\alpha L o s s _ { g } + \\beta L o s s _ { v } + \\gamma L o s s _ { l } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            565,
+            625,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            601,
+            326,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            287,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use two public multi-turn task-oriented dialogue datasets to evaluate our model: the bAbI dialogue (Bordes & Weston, 2017) and Stanford multi-domain dialogue (SMD) (Eric et al., 2017). The bAbI dialogue includes five simulated tasks in the restaurant domain. Task 1 to 4 are about calling API calls, modifying API calls, recommending options, and providing additional information, respectively. Task 5 is the union of tasks 1-4. There are two test sets for each task: one follows the same distribution as the training set and the other has OOV entity values. On the other hand, SMD is a human-human, multi-domain dialogue dataset. It has three distinct domains: calendar scheduling, weather information retrieval, and point-of-interest navigation. The key difference between these two datasets is, the former has longer dialogue turns but the regular user and system behaviors, the latter has few conversational turns but variant responses, and the KB information is much more complicated. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            811
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            349,
+            843
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The model is trained end-to-end using Adam optimizer (Kingma & Ba, 2015), and learning rate annealing starts from $1 e ^ { - 3 }$ to $1 e ^ { - 4 }$ . The number of hop $K$ is set to 1,3,6 to compare the performance difference. The weights $\\alpha , \\beta , \\gamma$ summing up the three losses are set to 1. All the embeddings are initialized randomly, and a simple greedy strategy is used without beam-search during the decoding stage. The hyper-parameters such as hidden size and dropout rate are tuned with grid-search over the development set (per-response accuracy for bAbI Dialogue and BLEU score for the SMD). In addition, to increase model generalization and simulate OOV setting, we randomly mask a small number of input source tokens into an unknown token. The model is implemented in PyTorch and the hyper-parameters used for each task and the dataset statistics are reported in the Appendix. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0b962497527a623aa5b6c9b832dbd103eb00fb55395e28db9402e241b51f171.jpg",
+        "table_caption": [
+            "Table 2: Per-response accuracy and completion rate (in the parentheses) on bAbI dialogues. GLMP achieves the least out-of-vocabulary performance drop. Baselines are reported from Query Reduction Network (Seo et al., 2017), End-to-end Memory Network (Bordes & Weston, 2017), Gated Memory Network (Liu & Perez, 2017), Point to Unknown Word (Gulcehre et al., 2016), and Memory-to-Sequence (Madotto et al., 2018). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>QRN</td><td>MN</td><td>GMN</td><td>S2S+Attn</td><td>Ptr-Unk</td><td>Mem2Seq</td><td>GLMPK1</td><td>GLMPK3</td><td>GLMP K6</td></tr><tr><td>T1</td><td>99.4 (-)</td><td>99.9 (99.6)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td></tr><tr><td>T2</td><td>99.5 (-)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td></tr><tr><td>T3</td><td>74.8 (-)</td><td>74.9 (2.0)</td><td>74.9 (0)</td><td>74.8 (0)</td><td>85.1 (19.0)</td><td>94.7 (62.1)</td><td>96.3 (75.6)</td><td>96.0 (69.4)</td><td>96.0 (68.7)</td></tr><tr><td>T4</td><td>57.2 (-)</td><td>59.5 (3.0)</td><td>57.2 (0)</td><td>57.2 (0)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td></tr><tr><td>T5</td><td>99.6 (-)</td><td>96.1 (49.4)</td><td>96.3 (52.5)</td><td>98.4 (87.3)</td><td>99.4 (91.5)</td><td>97.9 (69.6)</td><td>99.2 (88.5)</td><td>99.0 (86.5)</td><td>99.2 (89.7)</td></tr><tr><td>T1oov</td><td>83.1(-)</td><td>72.3(0)</td><td>82.4(0)</td><td>81.7(0)</td><td>92.5 (54.7)</td><td>94.0 (62.2)</td><td>100 (100)</td><td>100 (100)</td><td>99.3 (95.9)</td></tr><tr><td>T2 o0v</td><td>78.9 (-)</td><td>78.9 (0)</td><td>78.9 (0)</td><td>78.9 (0)</td><td>83.2 (0)</td><td>86.5 (12.4)</td><td>100 (100)</td><td>100 (100)</td><td>99.4 (94.6)</td></tr><tr><td>T300v</td><td>75.2 (-)</td><td>74.4 (0)</td><td>75.3 (0)</td><td>75.3 (0)</td><td>82.9 (13.4)</td><td>90.3 (38.7)</td><td>95.5 (65.7)</td><td>96.7 (72.9)</td><td>95.9 (67.7)</td></tr><tr><td>T4 o0v</td><td>56.9 (-)</td><td>57.6 (0)</td><td>57.0 (0)</td><td>57.0 (0)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td><td>100 (100)</td></tr><tr><td>T5o0v</td><td>67.8(-)</td><td>65.5 (0)</td><td>66.7 (0)</td><td>65.7 (0)</td><td>73.6 (0)</td><td>84.5 (2.3)</td><td>92.0 (21.7)</td><td>91.0 (17.7)</td><td>91.8 (21.4)</td></tr></table>",
+        "bbox": [
+            176,
+            172,
+            823,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/051987b8d6a6a19a56033fb351a86d5376d419a91e098ac1f5761dcd29d0ba5a.jpg",
+        "table_caption": [
+            "Table 3: In SMD dataset, our model achieves highest BLEU score and entity F1 score over baselines, including previous state-of-the-art result from Madotto et al. (2018). (Models with \\* are reported from Eric et al. (2017), where the problem is simplified to the canonicalized forms.) ",
+            "Automatic Evaluation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Rule-Based*</td><td>KVR*</td><td>S2S</td><td>S2S + Attn</td><td>Ptr-Unk</td><td>Mem2Seq</td><td>GLMPK1</td><td>GLMPK3</td><td>GLMPK6</td></tr><tr><td>BLEU</td><td>6.6</td><td>13.2</td><td>8.4</td><td>9.3</td><td>8.3</td><td>12.6</td><td>13.83</td><td>14.79</td><td>12.37</td></tr><tr><td>Entity F1</td><td>43.8</td><td>48.0</td><td>10.3</td><td>19.9</td><td>22.7</td><td>33.4</td><td>57.25</td><td>59.97</td><td>53.54</td></tr><tr><td>Schedule F1</td><td>61.3</td><td>62.9</td><td>9.7</td><td>23.4</td><td>26.9</td><td>49.3</td><td>68.74</td><td>69.56</td><td>69.38</td></tr><tr><td>Weather F1</td><td>39.5</td><td>47.0</td><td>14.1</td><td>25.6</td><td>26.7</td><td>32.8</td><td>60.87</td><td>62.58</td><td>55.89</td></tr><tr><td>Navigation F1</td><td>40.4</td><td>41.3</td><td>7.0</td><td>10.8</td><td>14.9</td><td>20.0</td><td>48.62</td><td>52.98</td><td>43.08</td></tr></table>",
+        "bbox": [
+            176,
+            364,
+            821,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/b529f84983b6753a44021b9314a5734204a1d8364d8efabf868f01c9a41a96b2.jpg",
+        "table_caption": [
+            "Human Evaluation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Mem2Seq</td><td>GLMP</td><td>Human</td></tr><tr><td>Appropriate</td><td>3.89</td><td>4.15</td><td>4.6</td></tr><tr><td>Humanlike</td><td>3.80</td><td>4.02</td><td>4.54</td></tr></table>",
+        "bbox": [
+            179,
+            450,
+            823,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            502,
+            825,
+            559
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            277,
+            590
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "bAbI Dialogue. In Table 2, we follow Bordes & Weston (2017) to compare the performance based on per-response accuracy and task-completion rate. Note that for utterance retrieval methods, such as QRN, MN, and GMN, cannot correctly recommend options (T3) and provide additional information (T4), and a poor generalization ability is observed in OOV setting, which has around $30 \\%$ performance difference in Task 5. Although previous generation-based approaches (Ptr-Unk, Mem2Seq) have mitigated the gap by incorporating copy mechanism, the simplest cases such as generating and modifying API calls (T1, T2) still face a $6 . 1 7 \\%$ OOV performance drop. On the other hand, GLMP achieves a highest $9 2 . 0 \\%$ task-completion rate in full dialogue task and surpasses other baselines by a big margin especially in the OOV setting. No per-response accuracy loss for T1, T2, T4 using only the single hop, and only decreases $7 . 9 \\%$ in task 5. ",
+        "bbox": [
+            173,
+            602,
+            825,
+            741
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Stanford Multi-domain Dialogue. For human-human dialogue scenario, we follow previous dialogue works (Eric et al., 2017; Zhao et al., 2017; Madotto et al., 2018) to evaluate our system on two automatic evaluation metrics, BLEU and entity F1 score 2. As shown in Table 3, GLMP achieves a highest 14.79 BLEU and $5 9 . 9 7 \\%$ entity F1 score, which is a slight improvement in BLEU but a huge gain in entity F1. In fact, for unsupervised evaluation metrics in task-oriented dialogues, we argue that the entity F1 might be a more comprehensive evaluation metric than per-response accuracy or BLEU, as shown in Eric et al. (2017) that humans are able to choose the right entities but have very diversified responses. Note that the results of rule-based and KVR are not directly comparable because they simplified the task by mapping the expression of entities to a canonical form using named entity recognition and linking 3. ",
+        "bbox": [
+            173,
+            747,
+            825,
+            887
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/58f91e317ae63d147fd35cf65838cd1ef603d98cc2c3a29c5c7954b8273f0de4.jpg",
+        "table_caption": [
+            "Table 4: Ablation study using single hop model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"5\">bAbI Dialogue OOV Per-response Accuracy</td><td rowspan=\"2\">SMD Entity F1</td></tr><tr><td></td><td>T2</td><td>T3</td><td>T4</td><td>T5</td></tr><tr><td>GLMP</td><td>T1 100 (-)</td><td>100 (-)</td><td>95.5 (-)</td><td>100 (-)</td><td>92.0(-)</td><td>All 57.25 (-)</td></tr><tr><td>GLMP w/o H</td><td>90.4 (-9.6)</td><td>85.6 (-14.4)</td><td>95.4 (-0.1)</td><td>100 (-0)</td><td>86.2 (-5.3)</td><td>47.96 (-9.29)</td></tr><tr><td>GLMP w/o G</td><td>100 (-0)</td><td>91.7(-8.3)</td><td>95.5(-0)</td><td>100 (-0)</td><td>92.4 (+0.4)</td><td>45.78 (-11.47)</td></tr></table>",
+        "bbox": [
+            256,
+            117,
+            741,
+            183
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moreover, human evaluation of the generated responses is reported. We compare our work with previous state-of-the-art model $\\mathrm { M e m } \\bar { 2 } \\mathrm { S e q } ^ { 4 }$ and the original dataset responses as well. We randomly select 200 different dialogue scenarios from the test set to evaluate three different responses. Amazon Mechanical Turk is used to evaluate system appropriateness and human-likeness on a scale from 1 to 5. As the results shown in Table 3, we see that GLMP outperforms Mem2Seq in both measures, which is coherent to previous observation. We also see that human performance on this assessment sets the upper bound on scores, as expected. More details about the human evaluation are reported in the Appendix. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            313
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ablation Study. The contributions of the global memory pointer $G$ and the memory writing of dialogue history $H$ are shown in Table 4. We compare the results using GLMP with $K = 1$ in bAbI OOV setting and SMD. GLMP without $H$ means that the context RNN in the global memory encoder does not write the hidden states into the external knowledge. As one can observe, our model without $H$ has $5 . 3 \\%$ more loss in the full dialogue task. On the other hand, GLMP without $G$ means that we do not use the global memory pointer to modify the external knowledge, and an $1 1 . 4 7 \\%$ entity F1 drop can be observed in SMD dataset. Note that a $0 . 4 \\%$ increase can be observed in task 5, it suggests that the use of global memory pointer may impose too strong prior entity probability. Even if we only report one experiment in the table, this OOV generalization problem can be mitigated by increasing the dropout ratio during training. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            459
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Visualization and Qualitative Evaluation. Analyzing the attention weights has been frequently used to interpret deep learning models. In Figure 3, we show the attention vector in the last hop for each generation time step. Y-axis is the external knowledge that we can copy, including the KB information and the dialogue history. Based on the question “what is the address?” asked by the driver in the last turn, the gold answer and our generated response are on the top, and the global memory pointer $G$ is shown in the left column. One can observe that in the right column, the final memory pointer successfully copy the entity chevron in step 0 and its address 783 Arcadia $P l$ in step 3 to fill in the sketch utterance. On the other hand, the memory attention without global weighting is reported in the middle column. One can find that even if the attention weights focus on several point of interests and addresses in step 0 and step 3, the global memory pointer can mitigate the issue as expected. More dialogue visualization and generated results including several negative examples and error analysis are reported in the Appendix. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            354,
+            671
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Task-oriented dialogue systems. Machine learning based dialogue systems are mainly explored by following two different approaches: modularized and end-to-end. For the modularized systems (Williams & Young, 2007; Wen et al., 2017), a set of modules for natural language understanding (Young et al., 2013; Chen et al., 2016), dialogue state tracking (Lee & Stent, 2016; Zhong et al., 2018), dialogue management (Su et al., 2016), and natural language generation (Sharma et al., 2016) are used. These approaches achieve good stability via combining domain-specific knowledge and slot-filling techniques, but additional human labels are needed. On the other hand, end-to-end approaches have shown promising results recently. Some works view the task as a next utterance retrieval problem, for examples, recurrent entity networks share parameters between RNN (Wu et al., 2017), query reduction networks modify query between layers (Seo et al., 2017), and memory networks (Bordes & Weston, 2017; Liu & Perez, 2017; Wu et al., 2018) perform multi-hop design to strengthen reasoning ability. In addition, some approaches treat the task as a sequence generation problem. Lei et al. (2018) incorporates explicit dialogue states tracking into a delexicalized sequence generation. Serban et al. (2016); Zhao et al. (2017) use recurrent neural networks to generate final responses and achieve good results as well. Although it may increase the search space, these approaches can encourage more flexible and diverse system responses by generating utterances token-by-token. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            896
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3f44f5b17cdfa02ad309742c36ff6cac1567bac341b4996807944890355da418.jpg",
+        "image_caption": [
+            "Figure 3: Memory attention visualization in the SMD navigation domain. Left column is the global memory pointer $G$ , middle column is the memory pointer without global weighting, and the right column is the final memory pointer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            108,
+            792,
+            597
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            672,
+            823,
+            702
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Pointer network. Vinyals et al. (2015) uses attention as a pointer to select a member of the input source as the output. Such copy mechanisms have also been used in other natural language processing tasks, such as question answering (Dehghani et al., 2017; He et al., 2017), neural machine translation (Gulcehre et al., 2016; Gu et al., 2016), language modeling (Merity et al., 2017), and text summarization (See et al., 2017). In task-oriented dialogue tasks, Eric & Manning (2017) first demonstrated the potential of the copy-augmented Seq2Seq model, which shows that generationbased methods with simple copy strategy can surpass retrieval-based ones. Later, Eric et al. (2017) augmented the vocabulary distribution by concatenating KB attention, which at the same time increases the output dimension. Recently, Madotto et al. (2018) combines end-to-end memory network into sequence generation, which shows that the multi-hop mechanism in MN can be utilized to improve copy attention. These models outperform utterance retrieval methods by copying relevant entities from the KBs. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Others. Zhao et al. (2017) proposes entity indexing and Wu et al. (2018) introduces recorded delexicalization to simplify the problem by record entity tables manually. In addition, our approach utilized recurrent structures to query external memory can be viewed as the memory controller in Memory augmented neural networks (MANN) (Graves et al., 2014; 2016). Similarly, memory encoders have been used in neural machine translation (Wang et al., 2016) and meta-learning applications (Kaiser et al., 2017). However, different from other models that use a single matrix representation for reading and writing, GLMP leverages end-to-end memory networks to perform multiple hop attention, which is similar to the stacking self-attention strategy in the Transformer (Vaswani et al., 2017). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            208,
+            318,
+            224
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the work, we present an end-to-end trainable model called global-to-local memory pointer networks for task-oriented dialogues. The global memory encoder and the local memory decoder are designed to incorporate the shared external knowledge into the learning framework. We empirically show that the global and the local memory pointer are able to effectively produce system responses even in the out-of-vocabulary scenario, and visualize how global memory pointer helps as well. As a result, our model achieves state-of-the-art results in both the simulated and the human-human dialogue datasets, and holds potential for extending to other tasks such as question answering and text summarization. ",
+        "bbox": [
+            174,
+            241,
+            825,
+            352
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            375,
+            285,
+            390
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Antoine Bordes and Jason Weston. Learning end-to-end goal-oriented dialog. International Conference on Learning Representations, abs/1605.07683, 2017. ",
+        "bbox": [
+            174,
+            398,
+            821,
+            426
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yun-Nung Chen, Dilek Hakkani-Tur, Jianfeng Gao, and Li Deng. End-to-end memory networks ¨ with knowledge carryover for multi-turn spoken language understanding. 2016. ",
+        "bbox": [
+            173,
+            438,
+            823,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. NIPS Deep Learning and Representation Learning Workshop, 2014. ",
+        "bbox": [
+            174,
+            477,
+            823,
+            520
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mostafa Dehghani, Sascha Rothe, Enrique Alfonseca, and Pascal Fleury. Learning to attend, copy, and generate for session-based query suggestion. In Proceedings of the 2017 ACM on Conference on Information and Knowledge Management, CIKM ’17, pp. 1747–1756, New York, NY, USA, 2017. ACM. ISBN 978-1-4503-4918-5. doi: 10.1145/3132847.3133010. URL http://doi. acm.org/10.1145/3132847.3133010. ",
+        "bbox": [
+            173,
+            530,
+            825,
+            601
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mihail Eric and Christopher Manning. A copy-augmented sequence-to-sequence architecture gives good performance on task-oriented dialogue. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, pp. 468–473, Valencia, Spain, April 2017. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/E17-2075. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            683
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mihail Eric, Lakshmi Krishnan, Francois Charette, and Christopher D. Manning. Key-value retrieval networks for task-oriented dialogue. In Proceedings of the 18th Annual SIGdial Meeting on Discourse and Dialogue, pp. 37–49. Association for Computational Linguistics, 2017. URL http://aclweb.org/anthology/W17-5506. ",
+        "bbox": [
+            173,
+            693,
+            825,
+            750
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, 2014. ",
+        "bbox": [
+            174,
+            761,
+            730,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio G ´ omez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, ´ et al. Hybrid computing using a neural network with dynamic external memory. Nature, 538 (7626):471–476, 2016. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            842
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiatao Gu, Zhengdong Lu, Hang Li, and Victor O.K. Li. Incorporating copying mechanism in sequence-to-sequence learning. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1631–1640, Berlin, Germany, August 2016. Association for Computational Linguistics. URL http://www.aclweb.org/ anthology/P16-1154. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Caglar Gulcehre, Sungjin Ahn, Ramesh Nallapati, Bowen Zhou, and Yoshua Bengio. Pointing the unknown words. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 140–149, Berlin, Germany, August 2016. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/ P16-1014. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shizhu He, Cao Liu, Kang Liu, and Jun Zhao. Generating natural answers by incorporating copying and retrieving mechanisms in sequence-to-sequence learning. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 199– 208, Vancouver, Canada, July 2017. Association for Computational Linguistics. URL http: //aclweb.org/anthology/P17-1019. ",
+        "bbox": [
+            173,
+            183,
+            825,
+            253
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lukasz Kaiser, Ofir Nachum, Aurko Roy, and Samy Bengio. Learning to remember rare events. International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            261,
+            821,
+            290
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            173,
+            299,
+            823,
+            328
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sungjin Lee and Amanda Stent. Task lineages: Dialog state tracking for flexible interaction. In Proceedings of the 17th Annual Meeting of the Special Interest Group on Discourse and Dialogue, pp. 11–21, 2016. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            378
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wenqiang Lei, Xisen Jin, Min-Yen Kan, Zhaochun Ren, Xiangnan He, and Dawei Yin. Sequicity: Simplifying task-oriented dialogue systems with single sequence-to-sequence architectures. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1437–1447, 2018. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fei Liu and Julien Perez. Gated end-to-end memory networks. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, pp. 1–10, Valencia, Spain, April 2017. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/E17-1001. ",
+        "bbox": [
+            173,
+            453,
+            825,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrea Madotto, Chien-Sheng Wu, and Pascale Fung. Mem2seq: Effectively incorporating knowledge bases into end-to-end task-oriented dialog systems. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1468–1478. Association for Computational Linguistics, 2018. URL http://aclweb.org/ anthology/P18-1136. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            588
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            173,
+            597,
+            823,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander Miller, Adam Fisch, Jesse Dodge, Amir-Hossein Karimi, Antoine Bordes, and Jason Weston. Key-value memory networks for directly reading documents. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 1400–1409, Austin, Texas, November 2016. Association for Computational Linguistics. URL https://aclweb. org/anthology/D16-1147. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abigail See, Peter J. Liu, and Christopher D. Manning. Get to the point: Summarization with pointer-generator networks. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1073–1083, Vancouver, Canada, July 2017. Association for Computational Linguistics. URL http://aclweb.org/ anthology/P17-1099. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Minjoon Seo, Sewon Min, Ali Farhadi, and Hannaneh Hajishirzi. Query-reduction networks for question answering. International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            169,
+            792,
+            823,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Iulian Vlad Serban, Alessandro Sordoni, Yoshua Bengio, Aaron C Courville, and Joelle Pineau. Building end-to-end dialogue systems using generative hierarchical neural network models. In AAAI, pp. 3776–3784, 2016. ",
+        "bbox": [
+            173,
+            830,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shikhar Sharma, Jing He, Kaheer Suleman, Hannes Schulz, and Philip Bachman. Natural language generation in dialogue using lexicalized and delexicalized data. International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pei-Hao Su, Milica Gasic, Nikola Mrksic, Lina Rojas-Barahona, Stefan Ultes, David Vandyke, Tsung-Hsien Wen, and Steve Young. On-line active reward learning for policy optimisation in spoken dialogue systems. Association for Computational Linguistics, 2016. ",
+        "bbox": [
+            176,
+            103,
+            820,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end memory networks. In Advances in neural information processing systems, pp. 2440–2448, 2015. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 6000–6010, 2017. ",
+        "bbox": [
+            174,
+            193,
+            821,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 2692–2700. Curran Associates, Inc., 2015. URL http://papers.nips. cc/paper/5866-pointer-networks.pdf. ",
+        "bbox": [
+            174,
+            244,
+            825,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mingxuan Wang, Zhengdong Lu, Hang Li, and Qun Liu. Memory-enhanced decoder for neural machine translation. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 278–286, Austin, Texas, November 2016. Association for Computational Linguistics. URL https://aclweb.org/anthology/D16-1027. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Hsien Wen, Milica Gasic, Nikola Mrksic, Lina Maria Rojas-Barahona, Pei hao Su, Stefan Ultes, David Vandyke, and Steve J. Young. A network-based end-to-end trainable task-oriented dialogue system. In EACL, 2017. ",
+        "bbox": [
+            174,
+            375,
+            821,
+            417
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason D Williams and Steve Young. Partially observable markov decision processes for spoken dialog systems. Computer Speech & Language, 21(2):393–422, 2007. ",
+        "bbox": [
+            168,
+            426,
+            823,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chien-Sheng Wu, Andrea Madotto, Genta Winata, and Pascale Fung. End-to-end recurrent entity network for entity-value independent goal-oriented dialog learning. In Dialog System Technology Challenges Workshop, DSTC6, 2017. ",
+        "bbox": [
+            174,
+            464,
+            823,
+            507
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chien-Sheng Wu, Andrea Madotto, Genta Winata, and Pascale Fung. End-to-end dynamic query memory network for entity-value independent task-oriented dialog. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6154–6158, April 2018. ",
+        "bbox": [
+            174,
+            515,
+            823,
+            559
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Steve Young, Milica Gasiˇ c, Blaise Thomson, and Jason D Williams. Pomdp-based statistical spoken ´ dialog systems: A review. Proceedings of the IEEE, 101(5):1160–1179, 2013. ",
+        "bbox": [
+            173,
+            566,
+            823,
+            597
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tiancheng Zhao, Allen Lu, Kyusong Lee, and Maxine Eskenazi. Generative encoder-decoder models for task-oriented spoken dialog systems with chatting capability. In Proceedings of the 18th Annual SIGdial Meeting on Discourse and Dialogue, pp. 27–36. Association for Computational Linguistics, August 2017. URL http://aclweb.org/anthology/W17-5505. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Victor Zhong, Caiming Xiong, and Richard Socher. Global-locally self-attentive dialogue state tracker. In Association for Computational Linguistics, 2018. ",
+        "bbox": [
+            173,
+            670,
+            821,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A TABLES ",
+        "bbox": [
+            176,
+            102,
+            277,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 TRAINING PARAMETERS ",
+        "bbox": [
+            174,
+            133,
+            387,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Selected hyper-parameters in each dataset for different hops. The values is the embedding dimension and the GRU hidden size, and the values between parenthesis is the dropout rate. For all the models we used learning rate equal to 0.001, with a decay rate of 0.5. ",
+        "bbox": [
+            174,
+            170,
+            825,
+            213
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/9d778774021f54f7959aa60aff3c19acd0a3fa6b756fe272940f70a194cf523b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>T1</td><td rowspan=1 colspan=1>T2</td><td rowspan=1 colspan=1>T3</td><td rowspan=1 colspan=1>T4</td><td rowspan=1 colspan=1>T5</td><td rowspan=1 colspan=1>SMD</td></tr><tr><td rowspan=1 colspan=1>GLMP K1</td><td rowspan=1 colspan=1>64 (0.1)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.7)</td><td rowspan=1 colspan=1>128 (0.3)</td><td rowspan=1 colspan=1>128 (0.2)</td></tr><tr><td rowspan=1 colspan=1>GLMP K3</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.7)</td><td rowspan=1 colspan=1>128 (0.1)</td><td rowspan=1 colspan=1>128 (0.2)</td></tr><tr><td rowspan=1 colspan=1>GLMP K6</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.3)</td><td rowspan=1 colspan=1>64 (0.5)</td><td rowspan=1 colspan=1>64 (0.5)</td><td rowspan=1 colspan=1>128 (0.1)</td><td rowspan=1 colspan=1>128 (0.3)</td></tr></table>",
+        "bbox": [
+            230,
+            224,
+            766,
+            285
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 DATASET STATISTICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            311,
+            367,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/3558470750a28faa61bebaa77d2bb0307d4541bc68230251728af5c4b2735368.jpg",
+        "table_caption": [
+            "Table 6: Dataset statistics for 2 datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Task</td><td rowspan=2 colspan=1>1</td><td rowspan=2 colspan=1>2</td><td rowspan=2 colspan=1>3</td><td rowspan=2 colspan=1>4</td><td rowspan=2 colspan=1>5</td><td rowspan=1 colspan=3>SMD</td></tr><tr><td rowspan=1 colspan=3>Calendar  Weather  Navigation</td></tr><tr><td rowspan=1 colspan=1>Avg. User turns</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>6.5</td><td rowspan=1 colspan=1>6.4</td><td rowspan=1 colspan=1>3.5</td><td rowspan=1 colspan=1>12.9</td><td rowspan=1 colspan=3>2.6</td></tr><tr><td rowspan=1 colspan=1>Avg. Sys turns</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>9.5</td><td rowspan=1 colspan=1>9.9</td><td rowspan=1 colspan=1>3.5</td><td rowspan=1 colspan=1>18.4</td><td rowspan=1 colspan=3>2.6</td></tr><tr><td rowspan=1 colspan=1>Avg. KB results</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>24</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>23.7</td><td rowspan=1 colspan=3>66.1</td></tr><tr><td rowspan=1 colspan=1>Avg. Syswords</td><td rowspan=1 colspan=1>6.3</td><td rowspan=1 colspan=1>6.2</td><td rowspan=1 colspan=1>7.2</td><td rowspan=1 colspan=1>5.7</td><td rowspan=1 colspan=1>6.5</td><td rowspan=1 colspan=3>8.6</td></tr><tr><td rowspan=1 colspan=1>Max. Sys words</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=3>87</td></tr><tr><td rowspan=1 colspan=1>Nb. Slot Types</td><td rowspan=1 colspan=3>7</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>Nb. Distinct Slot values</td><td rowspan=1 colspan=3>1</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>79</td><td rowspan=1 colspan=1>65</td><td rowspan=1 colspan=1>140</td></tr><tr><td rowspan=1 colspan=1>Vocabulary</td><td rowspan=1 colspan=5>3747</td><td rowspan=1 colspan=3>1601</td></tr><tr><td rowspan=1 colspan=1>Train dialogues</td><td rowspan=1 colspan=5>1000</td><td rowspan=1 colspan=3>2425</td></tr><tr><td rowspan=1 colspan=1>Val dialogues</td><td rowspan=1 colspan=5>1000</td><td rowspan=1 colspan=3>302</td></tr><tr><td rowspan=1 colspan=1>Test dialogues</td><td rowspan=1 colspan=5>1000+1000OOV</td><td rowspan=1 colspan=3>304</td></tr><tr><td rowspan=1 colspan=1>Total Nb. Dialogues</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>4000</td><td rowspan=1 colspan=1>1034</td><td rowspan=1 colspan=1>997</td><td rowspan=1 colspan=1>1000</td></tr></table>",
+        "bbox": [
+            178,
+            375,
+            820,
+            566
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 HUMAN EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            594,
+            370,
+            608
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/32f2f462831d343fe847f6b9bc63c74965fb2e0045c58dc442b732d6a36ae113.jpg",
+        "image_caption": [
+            "Figure 4: Appropriateness and human-likeness scores according to 200 dialogue scenarios. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            308,
+            628,
+            687,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Appropriateness 5: Correct grammar, correct logic, correct dialogue flow, and correct entity provided ",
+        "bbox": [
+            174,
+            896,
+            723,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4: Correct dialogue flow, logic and grammar but has slightly mistakes in entity provided   \n3: Noticeable mistakes about grammar or logic or entity provided but acceptable   \n2: Poor grammar, logic and entity provided   \n1: Wrong grammar, wrong logic, wrong dialogue flow, and wrong entity provided ",
+        "bbox": [
+            174,
+            103,
+            751,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Human-Likeness (Naturalness) ",
+        "bbox": [
+            174,
+            167,
+            380,
+            180
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5: The utterance is $100 \\%$ like what a person will say   \n4: The utterance is $7 5 \\%$ like what a person will say   \n3: The utterance is $50 \\%$ like what a person will say   \n2: The utterance is $2 5 \\%$ like what a person will say   \n1: The utterance is $0 \\%$ like what a person will say ",
+        "bbox": [
+            174,
+            181,
+            517,
+            251
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B ERROR ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            314,
+            357,
+            330
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For bAbI dialogues, the mistakes are mainly from task 3, which is recommending restaurants based on their rating from high to low. We found that sometimes the system will keep sending those restaurants with the higher score even if the user rejected them in the previous turns. On the other hand, SMD is more challenging for response generation. First, we found that the model makes mistakes when the KB has several options corresponding to the user intention. For example, once the user has more than one doctor appointment in the table, the model can barely recognize. In addition, since we do not include the domain specific and user intention supervision, wrong delexicalized responses may be generated, which results in an incorrect entity copy. Lastly, we found that the copied entities may not be matched to the generated sketch tags. For example, an address tag may result in a distance entity copy. We leave the space of improvement to future works. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            553,
+            428,
+            569
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "One of the reviewers suggested us to compare our work to some existing dialogue framework such as PyDial 5. To the best of our knowledge, in the PyDial framework, it requires to have the dialogue acts labels for the NLU module and the belief states labels for the belief tracker module. The biggest challenge is we do not have such labels in the SMD and bAbI datasets. Moreover, the semi tracker in PyDial is rule-based, which need to re-write rules whenever it encounters a new domain or new datasets. Even its dialogue management module could be a learning solution like policy networks, the input of the policy network is still the hand-crafted state features and labels. Therefore, without the rules and labels predefined in the NLU and belief tracker modules, PyDial could not learn a good policy network. ",
+        "bbox": [
+            173,
+            602,
+            825,
+            728
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Truly speaking, based on the data we have (not very big size) and the current state-of-the-art machine learning algorithms and models, we believe that a well and carefully constructed task-oriented dialogue system using PyDial in a known domain using human rules (in NLU and Belief Tracker) with policy networks may outperform the end-to-end systems (more robust). However, in this paper, without additional human labels and human rules, we want to explore the potential and the advantage of end-to-end systems. Besides easy to train, for multi-domain cases, or even zero-shot domain cases, we believe end-to-end approaches will have better adaptability compared to any rule-based systems. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            847
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            343,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/290fc9b752ca9f088989291e947524043742482693f523d5a431cf559f6fa452.jpg",
+        "image_caption": [
+            "Delexicalized Generation: the nearest @poi_type is @poi , @distance away at @address ",
+            "Figure 5: Memory attention visualization from the SMD navigation domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            320,
+            147,
+            691,
+            460
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/6354b5c9c9402d6735ba6bc5ca70e3f77537da6faf9df8adc2bd33482cdfb65a.jpg",
+        "image_caption": [
+            "Figure 6: Memory attention visualization from the SMD navigation domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            315,
+            516,
+            691,
+            833
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/15c4d03605a8a1e7ed7b6312db2a378d33bdcebc2906a1e405eeb101f3e9783a.jpg",
+        "image_caption": [
+            "Figure 7: Memory attention visualization from the SMD navigation domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            307,
+            132,
+            691,
+            450
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/11cb76abe5b46e80e5e9cf8fbc0f98a3087371d226357cd1d0287b107804f7ae.jpg",
+        "image_caption": [
+            "Figure 8: Memory attention visualization from the SMD navigation domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            546,
+            691,
+            863
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/9fd7edc83846eeabd0ba0c75a732d513120cabacc045690eef78ef8e5256f37c.jpg",
+        "image_caption": [
+            "Figure 9: Memory attention visualization from the SMD schedule domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            382,
+            132,
+            691,
+            450
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/e8d491b0b50c946d05eac9ba5ebd9b2f067345f9eb6daf7f57cd5ddbb981cdfe.jpg",
+        "image_caption": [
+            "Figure 10: Memory attention visualization from the SMD schedule domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            366,
+            546,
+            691,
+            864
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/f3abd5eb76208bb8596b053c1b1809dd91e70ff21e9131a470dbfbc7ed36f374.jpg",
+        "image_caption": [
+            "Figure 11: Memory attention visualization from the SMD schedule domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            357,
+            131,
+            691,
+            450
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/93ed72e4a27efe7be96d8427dabcc7e7d917560b9a2b70cd7b3936ba04076d0f.jpg",
+        "image_caption": [
+            "Figure 12: Memory attention visualization from the SMD schedule domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            357,
+            546,
+            689,
+            864
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/73ec96be661cfd6a535ae39da198630b532ea825b95011cd90ba7dd470abeb3b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            457,
+            195,
+            691,
+            911
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/3a4d0271aaa2c87b3ca5f2b504d7052d3e849ccdbbea2f2d2d63fd68342b9b25.jpg",
+        "image_caption": [
+            "Figure 13: Memory attention visualization from the SMD weather domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            186,
+            452,
+            909
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            602,
+            183,
+            740,
+            910
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/deb8c2c960a252ed33c1049dfcf767ee899e858e067e63538eac1565fc6f0c8b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            459,
+            196,
+            602,
+            907
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/63641c08852c6b92db3bbaa859246b0ede4afd893e98a96c582479e50d4089dc.jpg",
+        "image_caption": [
+            "Figure 14: Memory attention visualization from the SMD weather domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            328,
+            190,
+            442,
+            909
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/0e608b243cec3843dc3c063e35ea9ad30b654bf8613a5f83fd87892b6b57a537.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            604,
+            185,
+            741,
+            910
+        ],
+        "page_idx": 18
+    }
+]