Add files using upload-large-folder tool

parse/train/BJgnXpVYwS/BJgnXpVYwS.md

@@ -0,0 +1,774 @@
+# WHY GRADIENT CLIPPING ACCELERATES TRAINING: A THEORETICAL JUSTIFICATION FOR ADAPTIVITY
+
+Jingzhao Zhang, Tianxing He, Suvrit Sra & Ali Jadbabaie
+
+Massachusetts Institute of Technology   
+Cambridge, MA 02139, USA   
+{jzhzhang, tianxing, suvrit, jadbabai}@mit.edu
+
+# ABSTRACT
+
+We provide a theoretical explanation for the effectiveness of gradient clipping in training deep neural networks. The key ingredient is a new smoothness condition derived from practical neural network training examples. We observe that gradient smoothness, a concept central to the analysis of first-order optimization algorithms that is often assumed to be a constant, demonstrates significant variability along the training trajectory of deep neural networks. Further, this smoothness positively correlates with the gradient norm, and contrary to standard assumptions in the literature, it can grow with the norm of the gradient. These empirical observations limit the applicability of existing theoretical analyses of algorithms that rely on a fixed bound on smoothness. These observations motivate us to introduce a novel relaxation of gradient smoothness that is weaker than the commonly used Lipschitz smoothness assumption. Under the new condition, we prove that two popular methods, namely, gradient clipping and normalized gradient, converge arbitrarily faster than gradient descent with fixed stepsize. We further explain why such adaptively scaled gradient methods can accelerate empirical convergence and verify our results empirically in popular neural network training settings.
+
+# 1 INTRODUCTION
+
+We study optimization algorithms for neural network training and aim to resolve the mystery of why adaptive methods converge fast. Specifically, we study gradient-based methods for minimizing a differentiable nonconvex function $f : \mathbb { R } ^ { d }  \bar { \mathbb { R } }$ , where $f ( x )$ can potentially be stochastic, i.e., $f ( x ) = \mathbb { E } _ { \xi } [ F ( x , \xi ) ]$ . Such choices of $f$ cover a wide range of problems in machine learning, and their study motivates a vast body of current optimization literature.
+
+A widely used (and canonical) approach for minimizing $f$ is the (stochastic) gradient descent (GD) algorithm. Despite its simple form, GD often achieves superior empirical (Wilson et al., 2017) performances and theoretical (Carmon et al., 2017) guarantees. However, in many tasks such as reinforcement learning and natural language processing (NLP), adaptive gradient methods (e.g., Adagrad (Duchi et al., 2011), ADAM (Kingma and Ba, 2014), and RMSProp (Tieleman and Hinton, 2012)) outperform SGD. Despite their superior empirical performance, our understanding of the fast convergence of adaptive methods is limited. Previous analysis has shown that adaptive methods are more robust to variation in hyper-parameters (Ward et al., 2018) and adapt to sparse gradients (Duchi et al., 2011) (a more detailed literature review is in Appendix A). However, in practice, the gradient updates are dense, and even after extensively tuning the SGD hyperparameters, it still converges much slower than adaptive methods in NLP tasks.
+
+We analyze the convergence of clipped gradient descent and provide an explanation for its fast convergence. Even though gradient clipping is a standard practice in tasks such as language models (e.g. Merity et al., 2018; Gehring et al., 2017; Peters et al., 2018), it lacks a firm theoretical grounding. Goodfellow et al. (2016); Pascanu et al. (2013; 2012) discuss the gradient explosion problem in recurrent models and consider clipping as an intuitive work around. We formalize this intuition and prove that clipped GD can converge arbitrarily faster than fixed-step gradient descent. This result is shown to hold under a novel smoothness condition that is strictly weaker than the standard Lipschitzgradient assumption pervasive in the literature. Hence our analysis captures many functions that are not globally Lipschitz smooth. Importantly, the proposed smoothness condition is derived on the basis of extensive NLP training experiments, which are precisely the same type of experiments for which adaptive gradient methods empirically perform superior to gradient methods.
+
+By identifying a a new smoothness condition through experiments and then using it to analyze the convergence of adaptively-scaled methods, we reduce the following gap between theory and practice. On one hand, powerful techniques such as Nesterov’s momentum and variance reduction theoretically accelerate convex and nonconvex optimization. But, at least for now, they seem to have limited applicability in deep learning (Defazio and Bottou, 2018). On the other hand, some widely used techniques (e.g., heavy-ball momentum, adaptivity) lack theoretical acceleration guarantees. We suspect that a major reason here is the misalignment of the theoretical assumptions with practice. Our work demonstrates that the concept of acceleration critically relies on the problem assumptions and that the standard global Lipschitz-gradient condition may not hold in the case of some applications and thus must be relaxed to admit a wider class of objective functions.
+
+# 1.1 CONTRIBUTIONS
+
+In light of the above background, the main contributions of this paper are the following:
+
+Inspired and supported by neural network training experiments, we introduce a new smoothness condition that allows the local smoothness constant to increase with the gradient norm. This condition is strictly weaker than the pervasive Lipschitz-gradient assumption. We provide a convergence rate for clipped GD under our smoothness assumption (Theorem 3). We prove an upper-bound (Theorem 6) and a lower-bound (Theorem 4) on the convergence rate of GD under our relaxed smoothness assumption. The lower-bound demonstrates that GD with fixed step size can be arbitrarily slower than clipped GD. We provide upper bounds for stochastic clipped GD (Theorem 7) and SGD (Theorem 8). Again, stochastic clipped GD can be arbitrarily faster than SGD with a fixed step size.
+
+We support our proposed theory with realistic neural network experiments. First, in the state of art LSTM language modeling (LM) setting, we observe the function smoothness has a strong correlation with gradient norm (see Figure 2). This aligns with the known fact that gradient clipping accelerates LM more effectively compared to computer vision (CV) tasks. Second, our experiments in CV and LM demonstrate that clipping accelerates training error convergence and allows the training trajectory to cross non-smooth regions of the loss landscape. Furthermore, gradient clipping can also achieve good generalization performance even in image classification (e.g., $9 5 . 2 \%$ test accuracy in 200 epochs for ResNet20 on Cifar10). Please see Section 5 for more details.
+
+# 2 A NEW RELAXED SMOOTHNESS CONDITION
+
+In this section, we motivate and develop a relaxed smoothness condition that is weaker (and thus, more general) than the usual global Lipschitz smoothness assumption. We start with the traditional definition of smoothness.
+
+# 2.1 FUNCTION SMOOTHNESS (LIPSCHITZ GRADIENTS)
+
+Recall that $f$ denotes the objective function that we want to minimize. We say that $f$ is $L$ -smooth if
+
+$$
+\begin{array} { r } { \| \nabla f ( x ) - \nabla f ( y ) \| \leq L \| x - y \| , \quad \mathrm { f o r ~ a l l ~ } x , y \in \mathbb { R } ^ { d } . } \end{array}
+$$
+
+For twice differentiable functions, condition (1) is equivalent to $\| \nabla ^ { 2 } f ( x ) \| \leq L , \forall x \in \mathbb { R } ^ { d }$ . This smoothness condition enables many important theoretical results. For example, Carmon et al. (2017) show that GD with $h = 1 / L$ is up to a constant optimal for optimizing smooth nonconvex functions.
+
+But the usual $L$ -smoothness assumption (1) also has its limitations. Assuming existence of a global constant $L$ that upper bounds the variation of the gradient is very restrictive. For example, simple polynomials such as $f ( x ) = x ^ { 3 }$ break the assumption. One workaround is to assume that $L$ exists in a compact region, and either prove that the iterates do not escape the region or run projectionbased algorithms. However, such assumptions can make $L$ very large and slow down the theoretical convergence rate. In Section 4, we will show that a slow rate is unavoidable for gradient descent with fixed step size, whereas clipped gradient descent can greatly improve the dependency on $L$ .
+
+The above limitations force fixed-step gradient descent (which is tailored for Lipschitz smooth functions) to converge slowly in many tasks. In Figure 1, we plot the estimated function smoothness at different iterations during training neural networks. We find that function smoothness varies greatly at different iterations. From Figure 1, we further find that local smoothness positively correlates with the full gradient norm, especially in the language modeling experiment. A natural question is:
+
+Can we find a fine-grained smoothness condition under which we can design theoretically and empirically fast algorithms at the same time?
+
+To answer this question, we introduce the relaxed smoothness condition in the next section, which is developed on the basis of extensive experiments— Figure 1 provides an illustrative example.
+
+![](images/9d05bb6168e0956a20c95d567abf3e64a789884ebd862ee8ef4e8eacb6daaf44.jpg)  
+Figure 1: Gradient norm vs local gradient Lipschitz constant on a log-scale along the training trajectory for AWD-LSTM (Merity et al., 2018) on PTB dataset. The colorbar indicates the number of iterations during training. More experiments can be found in Section 5. Experiment details are in Appendix H.
+
+# 2.2 A NEW RELAXED SMOOTHNESS CONDITION
+
+We observe strong positive correlation between function smoothness and gradient norm in language modeling experiments (Figure 1(a)). This observation leads us to propose the following smoothness condition that allows local smoothness to grow with function gradients.
+
+Definition 1. A second order differentiable function $f$ is $( L _ { 0 } , L _ { 1 } )$ -smooth if
+
+$$
+\begin{array} { r } { \| \nabla ^ { 2 } f ( x ) \| \leq L _ { 0 } + L _ { 1 } \| \nabla f ( x ) \| . } \end{array}
+$$
+
+Definition 1 strictly relaxes the usual (and widely used) $L$ -smoothness. There are two ways to interpret the relaxation: First, when we focus on a compact region, we can balance the constants $L _ { 0 }$ and $L _ { 1 }$ such that $L _ { 0 } \ll L$ while $L _ { 1 } \ll L$ . Second, there exist functions that are $( L _ { 0 } , L _ { 1 } )$ -smooth globally, but not $L$ -smooth. Hence the constant $L$ for $L$ -smoothness gets larger as the compact set increases but $L _ { 0 }$ and $L _ { 1 }$ stay fixed. An example is given in Lemma 2.
+
+Remark 1. It is worth noting that we do not need the Hessian operator norm and gradient norm to necessarily satisfy the linear relation (2). As long as these norms are positively correlated, gradient clipping can be shown to achieve faster rate than fixed step size gradient descent. We use the linear relationship (2) for simplicity of exposition.
+
+Lemma 2. Let smooth for som $f$ the and variate but not lynomial -smooth. $\begin{array} { r } { f ( x ) = \sum _ { i = 1 } ^ { d } a _ { i } x ^ { i } } \end{array}$ . When $d \geq 3 ,$ , then $f$ is $( L _ { 0 } , L _ { 1 } )$ $L _ { 0 }$ $L _ { 1 }$ $L$
+
+Proof. The first claim follows from $\begin{array} { r } { \operatorname* { l i m } _ { x \to \infty } \left| \frac { f ^ { \prime } ( x ) } { f ^ { \prime \prime } ( x ) } \right| = \operatorname* { l i m } _ { x \to - \infty } \left| \frac { f ^ { \prime } ( x ) } { f ^ { \prime \prime } ( x ) } \right| = \infty } \end{array}$ . The second claim follows by the unboundedness of $f ^ { \prime \prime } ( x )$ .
+
+# 2.3 SMOOTHNESS IN NEURAL NETWORKS
+
+We saw that our smoothness condition relaxes the traditional smoothness assumption and is motivated empirically (Figure 1). Below we develop some intuition for this phenomenon. We conjecture that the proposed positive correlation results from the common components in expressions of the gradient and the Hessian. We illustrate the reasoning behind this conjecture by considering an $\ell$ - layer linear network with quadratic loss—a similar computation also holds for nonlinear networks.
+
+The $L _ { 2 }$ regression loss of a deep linear network is $\mathcal { L } ( Y , f ( X ) ) : = \| Y - W _ { \ell } \cdot \cdot \cdot W _ { 1 } X \| ^ { 2 } .$ , where $Y$ denotes labels, $X$ denotes the input data matrix, and $W _ { i }$ denotes the weights in the $i ^ { \mathrm { { t h } } }$ layer. By (Lemma 4.3 Kawaguchi, 2016), we know that
+
+$$
+\nabla _ { \mathsf { v e c } ( w _ { i } ) } \mathcal { L } ( Y , f ( X ) ) = ( ( W _ { \ell } \cdots W _ { i + 1 } ) \otimes ( W _ { i - 1 } \cdots W _ { 2 } W _ { 1 } X ) ^ { T } ) ^ { T } \operatorname { v e c } ( f ( X ) - Y ) ,
+$$
+
+where $\mathrm { v e c } ( \cdot )$ flattens a matrix in $\mathbb { R } ^ { m \times n }$ into a vector in $\mathbb { R } ^ { m n }$ ; $\otimes$ denotes the Kronecker product. For constants $i , j$ such that $\ell \geq j > i > 0$ , the second order derivative
+
+$$
+\begin{array} { r l } & { \nabla _ { \mathrm { v e c } ( w _ { j } ) } \nabla _ { \mathrm { v e c } ( w _ { i } ) } \mathcal { L } ( Y , f ( X ) ) = } \\ & { \qquad ( ( W _ { \ell } \cdot \cdot \cdot W _ { i + 1 } ) \otimes ( W _ { i - 1 } \cdot \cdot \cdot W _ { 2 } W _ { 1 } X ) ^ { T } ) ^ { T } ( ( W _ { \ell } \cdot \cdot \cdot W _ { j + 1 } ) \otimes ( W _ { j - 1 } \cdot \cdot \cdot W _ { 2 } W _ { 1 } X ) ^ { T } ) + } \\ & { \qquad ( ( W _ { j - 1 } \cdot \cdot \cdot W _ { i + 1 } ) \otimes ( W _ { i - 1 } \cdot \cdot \cdot W _ { 2 } W _ { 1 } X ) ) ( I \otimes ( ( f ( X ) - Y ) W _ { \ell } \cdot \cdot \cdot W _ { j + 1 } ) ) . } \end{array}
+$$
+
+When $j = i$ , the second term equals 0. Based on the above expressions, we notice that the gradient norm and Hessian norm may be positively correlated due to the following two observations. First, the gradient and the Hessian share many components such as the matrix product of weights across layers. Second, if one naively upper bounds the norm using Cauchy-Schwarz, then both upperbounds would be monotonically increasing with respect to $\| W _ { i } \|$ and $\| f ( X ) - Y \|$ .
+
+# 3 PROBLEMS SETUP AND ALGORITHMS
+
+In this section, we state the optimization problems and introduce gradient based algorithms for them that work under the new smoothness condition (2). Convergence analysis follows in Section 4.
+
+Recall that we wish to solve the nonconvex optimization problem $\operatorname* { m i n } _ { x \in \mathbb { R } ^ { d } } f ( x )$ . Since in general this problem is intractable, following common practice we also seek an $\epsilon$ -stationary point, i.e., a point $x$ such that $\| \nabla f ( x ) \| \leq \epsilon$ . Furthermore, we make the following assumptions to regularize the function class studied and subsequently provide nonasymptotic convergence rate analysis.
+
+Assumption 1. The function $f$ is lower bounded by $f ^ { * } > - \infty$ .
+
+Assumption 2. The function $f$ is twice differentiable.
+
+Assumption 3 $( ( L _ { 0 } , L _ { 1 } )$ -smoothness). The function $f$ is $( L _ { 0 } , L _ { 1 } )$ -smooth, i.e., there exist positive constants $L _ { 0 }$ and $L _ { 1 }$ such that $\| \nabla ^ { 2 } f ( x ) \| \leq L _ { 0 } + L _ { 1 } \| \nabla f ( x ) \|$ —see condition (2).
+
+The first assumption is standard. Twice differentiability in Assumption 2 can relaxed to first-order differentiability by modifying the definition of $( L _ { 0 } , L _ { 1 } )$ -smoothness as
+
+$$
+\begin{array} { r } { \operatorname* { l i m } _ { \delta \to \vec { 0 } } \frac { \| \nabla f ( x ) - \nabla f ( x + \delta ) \| } { \| \delta \| } \leq L _ { 1 } \| \nabla f ( x ) \| + L _ { 0 } . } \end{array}
+$$
+
+The above inequality implies $\nabla f ( x )$ is locally Lipschitz, and hence almost everywhere differentiable. Therefore, all our results can go through by handling the integrations more carefully. But to avoid complications and simplify exposition, we assume that the function is twice differentiable.
+
+To further relax the global assumptions, by showing that GD and clipped GD are monotonically decreasing in function value, we require the above assumptions to hold just in a neighborhood determined by the sublevel set $S ^ { 1 }$ for a given initialization $x _ { 0 }$ , where
+
+$$
+f ( y ) \leq f ( x _ { 0 } ) , { \mathrm { ~ a n d ~ } } \| x - y \| \leq 1 \} .
+$$
+
+# 3.1 GRADIENT DESCENT ALGORITHMS
+
+In this section, we review a few well-known variants of gradient based algorithms that we analyze. We start with the ordinary gradient descent with a fixed step size $\eta$ ,
+
+$$
+\boldsymbol { x } _ { k + 1 } = \boldsymbol { x } _ { k } - \eta \nabla f ( \boldsymbol { x } _ { k } ) .
+$$
+
+This algorithm (pedantically, its stochastic version) is widely used in neural network training. Many modifications of it have been proposed to stabilize or accelerate training. One such technique of particular importance is clipped gradient descent, which performs the following updates:
+
+$$
+\begin{array} { r } { x _ { k + 1 } = x _ { k } - h _ { c } \nabla f ( x _ { k } ) , \quad \mathrm { w h e r e ~ } h _ { c } : = \operatorname* { m i n } \{ \eta _ { c } , \frac { \gamma \eta _ { c } } { \| \nabla f ( x ) \| } \} . } \end{array}
+$$
+
+Another algorithm that is less common in practice but has attracted theoretical interest is normalized gradient descent. The updates for normalized GD method can be written as
+
+$$
+\begin{array} { r } { x _ { k + 1 } = x _ { k } - h _ { n } \nabla f ( x _ { k } ) , \quad \mathrm { w h e r e ~ } h _ { n } : = \frac { \eta _ { n } } { \| \nabla f ( x ) \| + \beta } . } \end{array}
+$$
+
+The stochastic version of the above algorithms replace the gradient with a stochastic estimator.
+
+We note that Clipped GD and NGD are almost equivalent. Indeed, for any given $\eta _ { n }$ and $\beta$ , if we set $\gamma \eta _ { c } = \eta _ { n }$ and $\eta _ { c } = \eta _ { n } / \beta$ , then we have
+
+$$
+\begin{array} { r } { \frac { 1 } { 2 } h _ { c } \leq h _ { n } \leq 2 h _ { c } . } \end{array}
+$$
+
+Therefore, clipped GD is equivalent to NGD up to a constant factor in the step size choice. Consequently, the nonconvex convergence rates in Section 4 and Section 4.2 for clipped GD also apply to NGD. We omit repeating the theorem statements and the analysis for conciseness.
+
+# 4 THEORETICAL ANALYSIS
+
+In this section, we analyze the oracle complexities of GD and clipped GD under our relaxed smoothness condition. All the proofs are in the appendix. We highlight the key theoretical challenges that needed to overcome in Appendix B (e.g., due to absence of Lipschitz-smoothness, already the firststep of analysis, the so-called “descent lemma” fails).
+
+Since we are analyzing the global iteration complexity, let us recall the formal definition being used. We follow the notation from Carmon et al. (2017). For a deterministic sequence $\{ x _ { k } \} _ { k \in \mathbb { N } }$ , define the complexity of $\{ x _ { k } \} _ { k \in \mathbb { N } }$ for a function $f$ as
+
+$$
+T _ { \epsilon } ( \{ x _ { t } \} _ { t \in \mathbb { N } } , f ) : = \operatorname* { i n f } \{ t \in \mathbb { N } | \| \nabla f ( x _ { t } ) \| \le \epsilon \} .
+$$
+
+For a random process $\{ x _ { k } \} _ { k \in \mathbb { N } }$ , we define the complexity of $\{ x _ { k } \} _ { k \in \mathbb { N } }$ for function $f$ as
+
+$$
+\begin{array} { r } { T _ { \epsilon } ( \{ x _ { t } \} _ { t \in \mathbb { N } } , f ) : = \operatorname* { i n f } \biggr \{ t \in \mathbb { N } | \mathrm { P r o b } ( \| \nabla f ( x _ { k } ) \| \ge \epsilon \mathrm { ~ f o r ~ a l l ~ } k \le t ) \le \frac { 1 } { 2 } \biggr \} . } \end{array}
+$$
+
+In particular, if the condition is never satisfied, then the complexity is $\infty$ . Given an algorithm $A _ { \theta }$ , where $\theta$ denotes hyperparameters such as step size and momentum coefficient, we denote $A _ { \theta } [ f , x _ { 0 } ]$ as the sequence of (potentially stochastic) iterates generated by $A$ when operating on $f$ with initialization $x _ { 0 }$ . Finally, we define the iteration complexity of an algorithm class parameterized by $p$ hyperparameters, $\overset { \cdot } { A } \overset { \cdot } { = } \{ A _ { \theta } \} _ { \theta \in \mathbb { R } ^ { p } }$ on a function class $\mathcal { F }$ as
+
+$$
+{ \mathcal { N } } ( A , { \mathcal { F } } , \epsilon ) : = \operatorname* { i n f } _ { A _ { \theta } \in A } \operatorname* { s u p } _ { x _ { 0 } \in \mathbb { R } ^ { d } , f \in { \mathcal { F } } } T _ { \epsilon } ( A _ { \theta } [ f , x _ { 0 } ] , f ) .
+$$
+
+The definition in the stochastic setting simply replaces the expression (7) with the expression (8). In the rest of the paper, “iteration complexity” refers to the quantity defined above.
+
+# 4.1 CONVERGENCE IN THE DETERMINISTIC SETTING
+
+In this section, we present the convergence rates for GD and clipped GD under deterministic setting.   
+We start by analyzing the clipped GD algorithm with update defined in equation (5).
+
+Theorem 3. Let $\mathcal { F }$ denote the class of functions that satisfy Assumptions 1, 2, and $^ 3$ in set $s$ defined in (3). Recall $f ^ { * }$ is a global lower bound for function value. With $\begin{array} { r } { \dot { \eta _ { c } } = \frac { 1 } { 1 0 L _ { 0 } } , \gamma = \operatorname* { m i n } \{ \frac { 1 } { \eta _ { c } } , \frac { \tilde { 1 } } { 1 0 L _ { 1 } \eta _ { c } } \} } \end{array}$ , we can prove that the iteration complexity of clipped $G D$ (Algorithm 5) is upper bounded by
+
+$$
+\frac { 2 0 L _ { 0 } ( f ( x _ { 0 } ) - f ^ { * } ) } { \epsilon ^ { 2 } } + \frac { 2 0 \operatorname * { m a x } \{ 1 , L _ { 1 } ^ { 2 } \} ( f ( x _ { 0 } ) - f ^ { * } ) } { L _ { 0 } } \ .
+$$
+
+The proof of Theorem 3 is included in Appendix C.
+
+Now, we discuss the convergence of vanilla GD. The standard GD is known to converge to first order $\epsilon$ -stationary points in $\mathcal { O } ( ( \bar { L ( } f ( x _ { 0 } ) - f ^ { * } ) ) \epsilon ^ { - 2 } )$ iterations for $( L , 0 ) -$ smooth nonconvex functions. By Theorem 1 of Carmon et al. (2017), this rate is up to a constant optimal.
+
+However, we will show below that gradient descent is suboptimal under our relaxed $( L _ { 0 } , L _ { 1 } )$ - smoothness condition. In particular, to prove the convergence rate for gradient descent with fixed step size, we need to permit it benefit from an additional assumption on gradient norms.
+
+Assumption 4. Given an initialization $x _ { 0 }$ , we assume that
+
+This assumption is in fact necessary, as our next theorem reveals.
+
+Theorem 4. Let $\mathcal { F }$ be the class of objectives satisfying Assumptions 1, 2, 3, and 4 with fixed constants $L _ { 0 } \ge 1 , L _ { 1 } \ge 1 , M > 1$ . The iteration complexity for the fixed-step gradient descent algorithms parameterized by step size $h$ is at least
+
+$$
+\frac { L _ { 1 } M ( f ( x _ { 0 } ) - f ^ { * } - 5 \epsilon / 8 ) } { 8 \epsilon ^ { 2 } ( \log M + 1 ) } .
+$$
+
+The proof can be found in Appendix D.
+
+Remark 5. Theorem 1 of Carmon et al. (2017) and Theorem 4 together show that gradient descent with a fixed step size cannot converge to an $\epsilon$ -stationary point faster than $\Omega \left( ( L _ { 1 } M / \log ( M ) + L _ { 0 } ) ( f ( x _ { 0 } ) { \stackrel { . } { - } } f ^ { * } ) \epsilon ^ { - 2 } \right)$ . Recall that clipped GD algorithm converges as $\mathcal { O } \left( L _ { 0 } ( f ( x _ { 0 } ) - f ^ { * } ) \epsilon ^ { - 2 } + L _ { 1 } ^ { 2 } ( f ( x _ { 0 } ) - f ^ { * } ) L _ { 0 } ^ { - 1 } \right)$ . Therefore, clipped GD can be arbitrarily faster than GD when $L _ { 1 } M$ is large, or in other words, when the problem has a poor initialization.
+
+Below, we provide an iteration upper bound for the fixed-step gradient descent update (4).
+
+Theorem 6. Suppose assumptions 1, 2, 3 and $^ { 4 }$ hold in set $s$ defined in (3). If we pick parameters such that $\begin{array} { r } { h = \frac { 1 } { \left( 2 ( M L _ { 1 } + L _ { 0 } ) \right) } } \end{array}$ , then we can prove that the iteration complexity of $G D$ with a fixed step size defined in Algorithm 4 is upper bounded by
+
+$$
+4 ( M L _ { 1 } + L _ { 0 } ) ( f ( x _ { 0 } ) - f ^ { \ast } ) \epsilon ^ { - 2 } .
+$$
+
+Please refer to Appendix $\mathrm { E }$ for the proof. Theorem 6 shows that gradient descent with a fixed step size converges in $\bar { \mathcal { O } } ( ( M L _ { 1 } + L _ { 0 } ) ( \bar { f } ( x _ { 0 } ) - f ^ { * } ) / \epsilon ^ { 2 } )$ iterations. This suggests that the lower bound in Remark 5 is tight up to a log factor in $M$ .
+
+# 4.2 CONVERGENCE IN THE STOCHASTIC SETTING
+
+In the stochastic setting, we assume GD and clipped GD have access to an unbiased stochastic gradient $\nabla { \hat { f } } ( x )$ instead of the exact gradient $\nabla f ( x )$ . For simplicity, we denote $g _ { k } \ = \ \nabla \hat { f } ( x _ { k } )$ below. To prove convergence, we need the following assumption.
+
+Assumption 5. There exists $\tau > 0$ , such that $\| \nabla { \hat { f } } ( x ) - \nabla f ( x ) \| \leq \tau$ almost surely.
+
+Bounded noise can be relaxed to sub-gaussian noise if the noise is symmetric. Furthermore, up to our knowledge, this is the first stochastic nonconvex analysis of adaptive methods that does not require the gradient norm $\| \nabla f ( x ) \|$ to be bounded globally.
+
+The main result of this section is the following convergence guarantee for stochastic clipped GD (based on the stochastic version of the update (5)).
+
+Theorem 7. Let Assumptions 1–3 and $5$ hold globally with $L _ { 1 } \quad > \quad 0$ . Let $\begin{array} { r l } { h } & { { } = } \end{array}$ $\begin{array} { r } { \operatorname* { m i n } \bigr \{ \frac { 1 } { 1 6 \eta L _ { 1 } ( \lVert g _ { k } \rVert + \tau ) } , \eta \bigr \} } \end{array}$ where $\begin{array} { r } { \eta \ = \ \operatorname* { m i n } \bigr \{ \frac { 1 } { 2 0 L _ { 0 } } , \frac { 1 } { 1 2 8 L _ { 1 } \tau } , \frac { 1 } { \sqrt { T } } \bigr \} } \end{array}$ . Then we can show that iteration complexity for stochastic clipped $G D$ after of update (5) is upper bounded by
+
+$$
+\begin{array} { c } { { \Delta \operatorname* { m a x } \{ \displaystyle \frac { 1 2 8 L _ { 1 } } { \epsilon } , \frac { 4 \Delta } { \epsilon ^ { 4 } } , \frac { 8 0 L _ { 0 } + 5 1 2 L _ { 1 } \tau } { \epsilon ^ { 2 } } \} , } } \\ { { \Delta = \big ( f ( x _ { 0 } ) - f ^ { * } + \big ( 5 L _ { 0 } + 2 L _ { 1 } \tau \big ) \tau ^ { 2 } + 9 \tau L _ { 0 } ^ { 2 } / L _ { 1 } \big ) . } } \end{array}
+$$
+
+In comparison, we have the following upper bound for ordinary SGD.
+
+Theorem 8. Let Assumptions $I { - } 3 ,$ , and 5 hold globally with $L _ { 1 } > 0$ . Let $\begin{array} { r } { h = \operatorname* { m i n } \{ \frac { 1 } { \sqrt { T } } , \frac { 1 } { L _ { 1 } ( M + \tau ) } \} } \end{array}$ Then the iteration complexity for the stochastic version of $G D$ (4) is upper bounded by
+
+We cannot provide a lower bound for this algorithm. In fact, lower bound is not known for SGD even in the global smoothness setting. However, the deterministic lower bound in Theorem 4 is still valid, though probably loose. Therefore, the convergence of SGD still requires additional assumption and can again be arbitrarily slower compared to clipped SGD when $M$ is large.
+
+![](images/787914712b864132ab352fe73cd796ba31239f16993e05604bd712f4f343585f.jpg)
+
+Figure 2: Gradient norm vs smoothness on log scale for LM training. The dot color indicates the iteration number. Darker ones correspond to earlier iterations. Note that the spans of $_ { x }$ and $^ { \prime \prime }$ axis are not fixed.
+
+![](images/d70016e843770b36a2307fbfeb5f5fede62bac4822fab934687c7df17f416aec.jpg)  
+Figure 3: Gradient norm vs smoothness on log scale for ResNet20 training. The dot color indicates the iteration number.
+
+# 5 EXPERIMENTS
+
+In this section, we summarize our empirical findings on the positive correlation between gradient norm and local smoothness. We then show that clipping accelerates convergence during neural network training. Our experiments are based on two tasks: language modeling and image classification. We run language modeling on the Penn Treebank (PTB) (Mikolov et al., 2010) dataset with AWD-LSTM models (Merity et al., 2018)2. We train ResNet20 (He et al., 2016) on the Cifar10 dataset (Krizhevsky and Hinton, 2009). Details about the smoothness estimation and experimental setups are in Appendix H. An additional synthetic experiment is discussed in Appendix I.
+
+First, our experiments test whether the local smoothness constant increases with the gradient norm, as suggested by the relaxed smoothness conditions defined in (2) (Section 2). To do so, we evaluate both quantities at points generated by the optimization procedure. We then scatter the local smoothness constants against the gradient norms in Figure 2 and Figure 3. Note that the plots are on a log-scale. A linear scale plot is shown in Appendix Figure 5.
+
+We notice that the correlation exists in the default training procedure for language modeling (see Figure 2a) but not in the default training for image classification (see Figure 3a). This difference aligns with the fact that gradient clipping is widely used in language modeling but is less popular in ResNet training, offering empirical support to our theoretical findings.
+
+We further investigate the cause of correlation. The plots in Figures 2 and 3 show that correlation appears when the models are trained with clipped GD and large learning rates. We propose the following explanation. Clipping enables the training trajectory to stably traverse non-smooth regions. Hence, we can observe that gradient norms and smoothness are positively correlated in Figures 2a and 3c. Without clipping, the optimizer has to adopt a small learning rate and stays in a region where local smoothness does not vary much, otherwise the sequence diverges, and a different learning rate is used. Therefore, in other plots of Figures 2 and 3, the correlation is much weaker.
+
+As positive correlations are present in both language modeling and image classification experiments with large step sizes, our next set of experiments checks whether clipping helps accelerate convergence as predicted by our theory. From Figure 4, we find that clipping indeed accelerates convergence. Because gradient clipping is a standard practice in language modeling, the LSTM models trained with clipping achieve the best validation performance and the fastest training loss convergence as expected. For image classification, surprisingly, clipped GD also achieves the fastest convergence and matches the test performance of SGD $+$ momentum. These plots show that clipping can accelerate convergence and achieve good test performance at the same time.
+
+![](images/9e4d337c612b117620776a0dbb4872f33f755f209ec629c5ea936a75e04971f4.jpg)  
+Figure 4: Training and validation loss obtained with different training methods for LSTM and ResNet training. The validation loss plots the cross entropy. The training loss additionally includes the weight regularization term. In the legend, $\cdot \mathrm { l r } 3 0 \mathrm { c l i p } 0 . 2 5 $ denotes that clipped SGD uses step size 30 and that the $L _ { 2 }$ norm of the stochastic gradient is clipped by 0.25. In ResNet training, we threshold the stochastic gradient norm at 0.25 when clipping is applied.
+
+# 6 DISCUSSION
+
+Much progress has been made to close the gap between upper and lower oracle complexities for first order smooth optimization. The works dedicated to this goal provide important insights and tools for us to understand the optimization procedures. However, there is another gap that separates theoretically accelerated algorithms from empirically fast algorithms.
+
+Our work aims to close this gap. Specifically, we propose a relaxed smoothness assumption that is supported by empirical evidence. We analyze a simple but widely used optimization technique known as gradient clipping and provide theoretical guarantees that clipping can accelerate gradient descent. This phenomenon aligns remarkably well with empirical observations.
+
+There is still much to be explored in this direction. First, though our smoothness condition relaxes the usual Lipschitz assumption, it is unclear if there is an even better condition that also matches the experimental observations while also enabling a clean theoretical analysis. Second, we only study convergence of clipped gradient descent. Studying the convergence properties of other techniques such as momentum, coordinate-wise learning rates (more generally, preconditioning), and variance reduction is also interesting. Finally, the most important question is: “can we design fast algorithms based on relaxed conditions that achieve faster convergence in neural network training?”
+
+Our experiments also have noteworthy implications. First, though advocating clipped gradient descent in ResNet training is not a main point of this work, it is interesting to note that gradient descent and clipped gradient descent with large step sizes can achieve a similar test performance as momentum-SGD. Second, we learned that the performance of the baseline algorithm can actually beat some recently proposed algorithms. Therefore, when we design or learn about new algorithms, we need to pay extra attention to check whether the baseline algorithms are properly tuned.
+
+# 7 ACKNOWLEDGEMENT
+
+SS acknowledges support from an NSF-CAREER Award (Number 1846088) and an Amazon Research Award. AJ acknowledges support from an MIT-IBM-Exploratory project on adaptive, robust, and collaborative optimization.
+
+# REFERENCES
+
+N. Agarwal, B. Bullins, X. Chen, E. Hazan, K. Singh, C. Zhang, and Y. Zhang. The case for fullmatrix adaptive regularization. arXiv preprint arXiv:1806.02958, 2018.   
+Z. Allen-Zhu. Katyusha: The first direct acceleration of stochastic gradient methods. The Journal of Machine Learning Research, 18(1):8194–8244, 2017.   
+L. Armijo. Minimization of functions having Lipschitz continuous first partial derivatives. Pacific Journal of mathematics, 16(1):1–3, 1966.   
+F. Bach and E. Moulines. Non-strongly-convex smooth stochastic approximation with convergence rate $o ( 1 / n )$ . In Advances in Neural Information Processing Systems, pages 773–781, 2013.   
+A. Beck and M. Teboulle. A fast iterative shrinkage-thresholding algorithm for linear inverse problems. SIAM journal on imaging sciences, 2(1):183–202, 2009.   
+Y. Carmon, J. C. Duchi, O. Hinder, and A. Sidford. Lower bounds for finding stationary points i. arXiv preprint arXiv:1710.11606, 2017.   
+Y. Carmon, J. C. Duchi, O. Hinder, and A. Sidford. Accelerated methods for nonconvex optimization. SIAM Journal on Optimization, 28(2):1751–1772, 2018.   
+X. Chen, S. Liu, R. Sun, and M. Hong. On the convergence of a class of adam-type algorithms for non-convex optimization. arXiv preprint arXiv:1808.02941, 2018.   
+K. Cho, B. van Merrienboer, C¸ . G ¨ ulc¸ehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio. ¨ Learning phrase representations using rnn encoder–decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 1724–1734, Doha, Qatar, Oct. 2014. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/D14-1179.   
+Z. Dai, Z. Yang, Y. Yang, J. G. Carbonell, Q. V. Le, and R. Salakhutdinov. Transformer-XL: Attentive language models beyond a fixed-length context. CoRR, abs/1901.02860, 2019. URL http://arxiv.org/abs/1901.02860.   
+A. Defazio and L. Bottou. On the ineffectiveness of variance reduced optimization for deep learning. arXiv preprint arXiv:1812.04529, 2018.   
+A. Defazio, F. Bach, and S. Lacoste-Julien. SAGA: A fast incremental gradient method with support for non-strongly convex composite objectives. In NIPS, pages 1646–1654, 2014.   
+J. Duchi, E. Hazan, and Y. Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011.   
+C. Fang, C. J. Li, Z. Lin, and T. Zhang. Spider: Near-optimal non-convex optimization via stochastic path integrated differential estimator. arXiv preprint arXiv:1807.01695, 2018.   
+J. Gehring, M. Auli, D. Grangier, D. Yarats, and Y. N. Dauphin. Convolutional sequence to sequence learning. ArXiv e-prints, May 2017.   
+S. Ghadimi and G. Lan. Optimal stochastic approximation algorithms for strongly convex stochastic composite optimization i: A generic algorithmic framework. SIAM Journal on Optimization, 22 (4):1469–1492, 2012.   
+S. Ghadimi and G. Lan. Accelerated gradient methods for nonconvex nonlinear and stochastic programming. Mathematical Programming, 156(1-2):59–99, 2016.   
+P. Gong and J. Ye. Linear convergence of variance-reduced stochastic gradient without strong convexity. arXiv preprint arXiv:1406.1102, 2014.   
+I. Goodfellow, Y. Bengio, and A. Courville. Deep learning. MIT press, 2016.   
+E. Hazan, K. Levy, and S. Shalev-Shwartz. Beyond convexity: Stochastic quasi-convex optimization. In Advances in Neural Information Processing Systems, pages 1594–1602, 2015.   
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.   
+S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.   
+C. Jin, P. Netrapalli, and M. I. Jordan. Accelerated gradient descent escapes saddle points faster than gradient descent. In Conference On Learning Theory, pages 1042–1085, 2018.   
+R. Johnson and T. Zhang. Accelerating stochastic gradient descent using predictive variance reduction. In Advances in Neural Information Processing Systems, pages 315–323, 2013.   
+K. Kawaguchi. Deep learning without poor local minima. In Advances in neural information processing systems, pages 586–594, 2016.   
+D. P. Kingma and J. Ba. ADAM: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+J. Konecnˇ y and P. Richt \` arik. Semi-stochastic gradient descent methods. ´ arXiv:1312.1666, 2013.   
+A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.   
+K. Y. Levy. The power of normalization: Faster evasion of saddle points. arXiv preprint arXiv:1611.04831, 2016.   
+X. Li and F. Orabona. On the convergence of stochastic gradient descent with adaptive stepsizes. arXiv preprint arXiv:1805.08114, 2018.   
+H. Lin, J. Mairal, and Z. Harchaoui. A universal catalyst for first-order optimization. In Advances in Neural Information Processing Systems, pages 3384–3392, 2015.   
+S. Merity, N. S. Keskar, and R. Socher. Regularizing and optimizing LSTM language models. In International Conference on Learning Representations, 2018. URL https://openreview. net/forum?id ${ . } = { }$ SyyGPP0TZ.   
+T. Mikolov, M. Karafiat, L. Burget, J. Cernock ´ y, and S. Khudanpur. Recurrent neural network based ´ language model. In INTERSPEECH 2010, 11th Annual Conference of the International Speech Communication Association, Makuhari, Chiba, Japan, September 26-30, 2010, pages 1045–1048, 2010. URL http://www.isca-speech.org/archive/interspeech_2010/i10_ 1045.html.   
+Y. Nesterov. A method of solving a convex programming problem with convergence rate $\mathcal { O } ( 1 / k ^ { 2 } )$ . In Soviet Mathematics Doklady, volume 27, pages 372–376, 1983.   
+Y. Nesterov. Efficiency of coordinate descent methods on huge-scale optimization problems. SIAM Journal on Optimization, 22(2):341–362, 2012.   
+R. Pascanu, T. Mikolov, and Y. Bengio. Understanding the exploding gradient problem. CoRR, abs/1211.5063, 2, 2012.   
+R. Pascanu, T. Mikolov, and Y. Bengio. On the difficulty of training recurrent neural networks. In International conference on machine learning, pages 1310–1318, 2013.   
+M. E. Peters, M. Neumann, M. Iyyer, M. Gardner, C. Clark, K. Lee, and L. Zettlemoyer. Deep contextualized word representations. arXiv preprint arXiv:1802.05365, 2018.   
+B. T. Polyak. Some methods of speeding up the convergence of iteration methods. USSR Computational Mathematics and Mathematical Physics, 4(5):1–17, 1964.   
+B. T. Polyak. Introduction to optimization. optimization software. Inc., Publications Division, New York, 1, 1987.   
+S. J. Reddi, S. Kale, and S. Kumar. On the convergence of ADAM and beyond. arXiv preprint arXiv:1904.09237, 2019.   
+S. Santurkar, D. Tsipras, A. Ilyas, and A. Madry. How does batch normalization help optimization? In Advances in Neural Information Processing Systems, pages 2483–2493, 2018.   
+M. Schmidt, N. Le Roux, and F. Bach. Minimizing finite sums with the stochastic average gradient. Mathematical Programming, 162, 2017.   
+S. Shalev-Shwartz and T. Zhang. Accelerated proximal stochastic dual coordinate ascent for regularized loss minimization. In International Conference on Machine Learning, pages 64–72, 2014.   
+N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15: 1929–1958, 2014. URL http://jmlr.org/papers/v15/srivastava14a.html.   
+M. Staib, S. J. Reddi, S. Kale, S. Kumar, and S. Sra. Escaping saddle points with adaptive gradient methods. arXiv preprint arXiv:1901.09149, 2019.   
+M. Sundermeyer, R. Schluter, and H. Ney. LSTM neural networks for language modeling. In ¨ INTERSPEECH 2012, 13th Annual Conference of the International Speech Communication Association, Portland, Oregon, USA, September 9-13, 2012, pages 194–197, 2012. URL http: //www.isca-speech.org/archive/interspeech_2012/i12_0194.html.   
+I. Sutskever, O. Vinyals, and Q. V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, pages 3104–3112, 2014. URL http://papers.nips.cc/paper/ 5346-sequence-to-sequence-learning-with-neural-networks.   
+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, 4(2):26–31, 2012.   
+L. Wan, M. Zeiler, S. Zhang, Y. L. Cun, and R. Fergus. Regularization of neural networks using DropConnect. In S. Dasgupta and D. McAllester, editors, Proceedings of the 30th International Conference on Machine Learning, volume 28 of Proceedings of Machine Learning Research, pages 1058–1066, Atlanta, Georgia, USA, 17–19 Jun 2013. PMLR. URL http: //proceedings.mlr.press/v28/wan13.html.   
+R. Ward, X. Wu, and L. Bottou. Adagrad stepsizes: Sharp convergence over nonconvex landscapes, from any initialization. arXiv preprint arXiv:1806.01811, 2018.   
+A. C. Wilson, R. Roelofs, M. Stern, N. Srebro, and B. Recht. The marginal value of adaptive gradient methods in machine learning. In Advances in Neural Information Processing Systems, pages 4148–4158, 2017.   
+L. Xiao and T. Zhang. A proximal stochastic gradient method with progressive variance reduction. SIAM Journal on Optimization, 24(4):2057–2075, 2014.   
+T. Young, D. Hazarika, S. Poria, and E. Cambria. Recent trends in deep learning based natural language processing. CoRR, abs/1708.02709, 2017. URL http://arxiv.org/abs/1708. 02709.   
+D. Zhou, Y. Tang, Z. Yang, Y. Cao, and Q. Gu. On the convergence of adaptive gradient methods for nonconvex optimization. arXiv preprint arXiv:1808.05671, 2018a.   
+D. Zhou, P. Xu, and Q. Gu. Stochastic nested variance reduction for nonconvex optimization. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pages 3925–3936. Curran Associates Inc., 2018b.   
+Z. Zhou, Q. Zhang, G. Lu, H. Wang, W. Zhang, and Y. Yu. Adashift: Decorrelation and convergence of adaptive learning rate methods. arXiv preprint arXiv:1810.00143, 2018c.   
+F. Zou and L. Shen. On the convergence of weighted adagrad with momentum for training deep neural networks. arXiv preprint arXiv:1808.03408, 2018.   
+F. Zou, L. Shen, Z. Jie, W. Zhang, and W. Liu. A sufficient condition for convergences of ADAM and RMSProp. arXiv preprint arXiv:1811.09358, 2018.
+
+# A MORE RELATED WORK ON ACCELERATING GRADIENT METHODS
+
+Variance reduction. Many efforts have been made to accelerate gradient-based methods. One elegant approach is variance reduction (e.g. Schmidt et al., 2017; Johnson and Zhang, 2013; Defazio et al., 2014; Bach and Moulines, 2013; Konecnˇ y and Richt \` arik ´ , 2013; Xiao and Zhang, 2014; Gong and Ye, 2014; Fang et al., 2018; Zhou et al., 2018b). This technique aims to solve stochastic and finite sum problems by averaging the noise in the stochastic oracle via utilizing the smoothness of the objectives.
+
+Momentum methods. Another line of work focuses on achieving acceleration with momentum. Polyak (1964) showed that momentum can accelerate optimization for quadratic problems; later, Nesterov (1983) designed a variation that provably accelerate any smooth convex problems. Based on Nesterov’s work, much theoretical progress was made to accelerate different variations of the original smooth convex problems (e.g. Ghadimi and Lan, 2016; 2012; Beck and Teboulle, 2009; Shalev-Shwartz and Zhang, 2014; Jin et al., 2018; Carmon et al., 2018; Allen-Zhu, 2017; Lin et al., 2015; Nesterov, 2012).
+
+Adaptive step sizes. The idea of varying step size in each iteration has long been studied. Armijo (1966) proposed the famous backtracking line search algorithm to choose step size dynamically. Polyak (1987) proposed a strategy to choose step size based on function suboptimality and gradient norm. More recently, Duchi et al. (2011) designed the Adagrad algorithm that can utilize the sparsity in stochastic gradients.
+
+Since 2018, there has been a surge in studying the theoretical properties of adaptive gradient methods. One starting point is (Reddi et al., 2019), which pointed out that ADAM is not convergent and proposed the AMSGrad algorithm to fix the problem. Ward et al. (2018); Li and Orabona (2018) prove that Adagrad converges to stationary point for nonconvex stochastic problems. Zhou et al. (2018a) generalized the result to a class of algorithms named Padam. Zou et al. (2018); Staib et al. (2019); Chen et al. (2018); Zhou et al. (2018c); Agarwal et al. (2018); Zhou et al. (2018b); Zou and Shen (2018) also studied different interesting aspects of convergence of adaptive methods. In addition, Levy (2016) showed that normalized gradient descent may have better convergence rate in presence of injected noise. However, the rate comparison is under dimension dependent setting. Hazan et al. (2015) studied the convergence of normalized gradient descent for quasi-convex functions.
+
+# B CHALLENGES IN THE PROOFS
+
+In this section, we highlight a few key challenges in our proofs. First, the analysis convergence under the relaxed smoothness condition is more difficult than the traditional setup. In particular, classical analyses based on Lipschitz-smooth gradients frequently exploit the descent condition:
+
+$$
+\begin{array} { r } { f ( y ) \leq f ( x ) + \langle \nabla f ( x ) , y - x \rangle + \frac { L } { 2 } \| y - x \| ^ { 2 } . } \end{array}
+$$
+
+However, under our relaxed smoothness condition, the last term will increase exponentially in $\| y - x \| ^ { 2 }$ . To solve this challenge, we bound the distance moved by clipping and apply Gronwall’s ¨ inequality.
+
+Second, our algorithm specific lower bound proved in Theorem 4 is novel and tight up to a log factor.   
+To our knowledge, the worst case examples used have not been studied before.
+
+Last, proving the convergence of adaptive methods in the nonconvex stochastic setting suffers from a fundamental challenge: the stochastic gradient is dependent on the update step size. This problem is usually circumvented by either assuming gradients have bounded norms or by using a lagging-byone step-size to decouple the correlation. The situation is even worse under the relaxed smoothness assumption. In our case, we overcome this challenge by a novel analysis that divides the proof into the large gradient scenario and the small gradient scenario.
+
+# C PROOF OF THEOREM 3
+
+We start by proving a lemma that is repeatedly used in later proofs. The lemma bounds the gradient in a neighborhood of the current point by Gronwall’s inequality (integral form). ¨
+
+Lemma 9. Given $x$ such that $f ( x ) \leq f ( x _ { 0 } )$ , for any $x ^ { + }$ such that $\| x ^ { + } - x \| \leq \operatorname* { m i n } \{ 1 / L _ { 1 } , 1 \}$ , we have $\| \nabla f ( x ^ { + } ) \| \leq 4 ( L _ { 0 } / L _ { 1 } + \| \nabla f ( x ) \| )$ .
+
+Remark 10. Note that the constant “1” comes from the definition of $s$ in (3). If Assumption 3 holds globally, then we do not need to constrain $\| x ^ { + } - x \| \leq 1$ . This version will be used in Theorem 7.
+
+Proof. Let $\gamma ( t )$ be a curve defined below,
+
+$$
+\gamma ( t ) = t ( x ^ { + } - x ) + x , t \in [ 0 , 1 ] .
+$$
+
+Then we have
+
+$$
+\nabla f ( \gamma ( t ) ) = \int _ { 0 } ^ { t } \nabla ^ { ( 2 ) } f ( \gamma ( \tau ) ) ( x ^ { + } - x ) d \tau + \nabla f ( \gamma ( 0 ) ) .
+$$
+
+By Cauchy-Schwarz’s inequality, we get
+
+$$
+\begin{array} { r l r } {  { \| \nabla f ( \gamma ( t ) ) \| \le \| x ^ { + } - x \| \int _ { 0 } ^ { t } \| \nabla ^ { ( 2 ) } f ( \gamma ( \tau ) ) \| d \tau + \| \nabla f ( x ) \| } } \\ & { } & { \le \frac { 1 } { L _ { 1 } } \int _ { 0 } ^ { t } ( L _ { 0 } + L _ { 1 } \| \nabla f ( \gamma ( \tau ) ) \| ) d \tau + \| \nabla f ( x ) \| . } \end{array}
+$$
+
+The second inequality follows by Assumption 3. Then we can apply the integral form of Gronwall’s ¨ inequality and get
+
+$$
+\| \nabla f ( \gamma ( t ) ) \| \leq \frac { L _ { 0 } } { L _ { 1 } } + \| \nabla f ( x ) \| + \int _ { 0 } ^ { t } \left( \frac { L _ { 0 } } { L _ { 1 } } + \| \nabla f ( x ) \| \right) \exp ( t - \tau ) d \tau .
+$$
+
+The Lemma follows by setting $t = 1$ .
+
+# C.1 PROOF OF THE THEOREM
+
+We parameterize the path between $x _ { k }$ and its updated iterate $x _ { k + 1 }$ as follows:
+
+$$
+\gamma ( t ) = t ( x _ { k + 1 } - x _ { k } ) + x _ { k } , \forall t \in [ 0 , 1 ] .
+$$
+
+Since $x _ { k + 1 } = x _ { k } { - h _ { k } \nabla f } ( x _ { k } )$ , using Taylor’s theorem, the triangle inequality, and Cauchy-Schwarz, we obtain
+
+$$
+f ( x _ { k + 1 } ) \leq f ( x _ { k } ) - h _ { k } \| \nabla f ( x _ { k } ) \| ^ { 2 } + \frac { \| x _ { k + 1 } - x _ { k } \| ^ { 2 } } { 2 } \int _ { 0 } ^ { 1 } \| \nabla ^ { 2 } f ( \gamma ( t ) ) \| d t .
+$$
+
+Since
+
+$$
+h _ { k } \leq \frac { \gamma \eta } { \Vert \nabla f ( x ) \Vert } \leq \operatorname* { m i n } \left\{ \frac { 1 } { \Vert \nabla f ( x ) \Vert } , \frac { 1 } { L _ { 1 } \Vert \nabla f ( x _ { k } ) \Vert } \right\} ,
+$$
+
+we know by Lemma 9
+
+$$
+\begin{array} { r } { \| \nabla f ( \gamma ( t ) \| \leq 4 ( \frac { L _ { 0 } } { L _ { 1 } } + \| \nabla f ( x ) \| ) . } \end{array}
+$$
+
+Then by Assumption 3, we obtain the “descent inequality”:
+
+$$
+f ( x _ { k + 1 } ) \leq f ( x _ { k } ) - h _ { k } \| \nabla f ( x _ { k } ) \| ^ { 2 } + \frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } \| \nabla f ( x _ { k } ) \| ^ { 2 } h _ { k } ^ { 2 } .
+$$
+
+Therefore, as long as $h _ { k } \leq 1 / ( 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| )$ (which follows by our choice of $\eta , \gamma )$ , we can quantify the descent to be
+
+$$
+f ( x _ { k + 1 } ) \leq f ( x _ { k } ) - { \frac { h _ { k } \| \nabla f ( x _ { k } ) \| ^ { 2 } } { 2 } } .
+$$
+
+When $\| \nabla f ( x _ { k } ) \| \ge L _ { 0 } / L _ { 1 }$ , we have
+
+$$
+\frac { h _ { k } \| \nabla f ( x _ { k } ) \| ^ { 2 } } { 2 } \geq \frac { L _ { 0 } } { 2 0 \operatorname* { m a x } \{ 1 , L _ { 1 } ^ { 2 } \} } .
+$$
+
+When $\epsilon \leq \| \nabla f ( x _ { k } ) \| \leq L _ { 0 } / L _ { 1 }$ , we have
+
+$$
+\frac { h _ { k } \| \nabla f ( x _ { k } ) \| ^ { 2 } } { 2 } \geq \frac { \| \nabla f ( x _ { k } ) \| ^ { 2 } } { 2 0 L _ { 0 } } \geq \frac { \epsilon ^ { 2 } } { 2 0 L _ { 0 } } .
+$$
+
+Therefore,
+
+$$
+f ( x _ { k + 1 } ) \leq f ( x _ { k } ) - \operatorname* { m i n } \left\{ \frac { L _ { 0 } } { 2 0 \operatorname* { m a x } \{ 1 , L _ { 1 } ^ { 2 } \} } , \frac { \epsilon ^ { 2 } } { 2 0 L _ { 0 } } \right\} .
+$$
+
+Assume that $\epsilon \leq \| \nabla f ( x _ { k } ) \|$ for $k \leq T$ iterations. By doing a telescopic sum, we get
+
+$$
+\sum _ { k = 0 } ^ { T - 1 } f ( x _ { k + 1 } ) - f ( x _ { k } ) \leq - T \operatorname* { m i n } \left\{ \frac { L _ { 0 } } { 2 0 \operatorname* { m a x } \{ 1 , L _ { 1 } ^ { 2 } \} } , \frac { \epsilon ^ { 2 } } { 2 0 L _ { 0 } } \right\} .
+$$
+
+Rearranging we get
+
+$$
+T \leq \frac { 2 0 L _ { 0 } ( f ( x _ { 0 } ) - f ^ { * } ) } { \epsilon ^ { 2 } } + \frac { 2 0 \operatorname* { m a x } \{ 1 , L _ { 1 } ^ { 2 } \} ( f ( x _ { 0 } ) - f ^ { * } ) } { L _ { 0 } } .
+$$
+
+# D PROOF OF THEOREM 4
+
+We will prove a lower bound for the iteration complexity of GD with fixed step size. The high level idea is that if GD converges for all functions satisfying the assumptions, then the step size needs to be small. However, this small step size will lead to very slow convergence for another function.
+
+Recall that the fixed step size GD algorithm is parameterized by the scaler: step size $h$ . First, we show that when $h > \frac { 2 \bar { \log } ( M ) + 2 } { M L _ { 1 } }$ ,
+
+$$
+\operatorname* { s u p } _ { x _ { 0 } \in \mathbb { R } ^ { d } } T _ { \epsilon } ( A _ { h } [ f , x _ { 0 } ] , f ) = \infty
+$$
+
+We start with a function that grows exponentially. Let $L _ { 1 } > 1 , M > 1$ be fixed constants. Pick the initial point $x _ { 0 } = ( \log ( M ) + 1 ) / L _ { 1 }$ . Let the objective be defined as follows,
+
+$$
+f ( x ) = \left\{ \begin{array} { l l } { \frac { e ^ { - L _ { 1 } x } } { L _ { 1 } e } , } & { \mathrm { f o r } x < - \frac { 1 } { L _ { 1 } } , } \\ & { } \\ { \frac { L _ { 1 } x ^ { 2 } } { 2 } + \frac { 1 } { 2 L _ { 1 } } , } & { \mathrm { f o r } x \in [ - \frac { 1 } { L _ { 1 } } , \frac { 1 } { L _ { 1 } } ] , } \\ & { } \\ { \frac { e ^ { L _ { 1 } x } } { L _ { 1 } e } , } & { \mathrm { f o r } x > \frac { 1 } { L _ { 1 } } . } \end{array} \right.
+$$
+
+We notice that the function satisfies the assumptions with constants
+
+$$
+L _ { 0 } = 1 , \quad L _ { 1 } > 1 , \quad M > 1 .
+$$
+
+When $h > 2 x _ { 0 } / M$ , we would have $\vert x _ { 1 } \vert > \vert x _ { 0 } \vert$ . By symmetry of the function and the super-linear growth of the gradient norm, we know that the iterates will diverge. Hence, in order for gradient descent with a fixed step size $h$ to converge, $h$ must be small enough. Formally,
+
+$$
+h \leq \frac { 2 x _ { 0 } } { M } = \frac { 2 \log ( M ) + 2 } { M L _ { 1 } } .
+$$
+
+Second, we show that when $\begin{array} { r } { h \le \frac { 2 \log ( M ) + 2 } { M L _ { 1 } } } \end{array}$ ，
+
+$$
+\operatorname* { s u p } _ { x _ { 0 } \in \mathbb { R } ^ { d } , \atop f \in { \mathcal F } } T _ { \epsilon } ( A _ { h } [ f , x _ { 0 } ] , f ) \geq \Delta L _ { 1 } M / ( 4 \epsilon ^ { 2 } ( \log M + 1 ) )
+$$
+
+Now, let’s look at a different objective that grows slowly.
+
+$$
+f ( x ) = \left\{ \begin{array} { l l } { - 2 \epsilon ( x + 1 ) + \frac { 5 \epsilon } { 4 } , } & { \mathrm { f o r } x < - 1 , } \\ { \frac { \epsilon } { 4 } ( 6 x ^ { 2 } - x ^ { 4 } ) , } & { \mathrm { f o r } x \in [ - 1 , 1 ] , } \\ { 2 \epsilon ( x - 1 ) + \frac { 5 \epsilon } { 4 } , } & { \mathrm { f o r } x > 1 . } \end{array} \right.
+$$
+
+This function is also second order differentiable and satisfies the assumptions with constants in (11). If we set $x _ { 0 } = 1 + \Delta / \epsilon$ for some constant $\Delta > 0$ , we know that $f ( x _ { 0 } ) - f ^ { * } = 2 \Delta + 5 \epsilon / 4$ . With the step size choice $h \leq ( 2 \log M + 2 ) / ( M L _ { 1 } )$ , we know that in each step, $x _ { k + 1 } \geq x _ { k } - ( 4 \epsilon ( \log M +$ $1 ) \bar { ) } / ( L _ { 1 } M )$ . Therefore, for $k \leq \Delta L _ { 1 } M / ( 4 \epsilon ^ { 2 } ( \log M + 1 ) )$ ,
+
+$$
+\| \nabla f ( x _ { k } ) \| = 2 \epsilon .
+$$
+
+After combining these two points, we proved the theorem by definition (9).
+
+# E PROOF OF THEOREM 6
+
+We start by parametrizing the function value along the update,
+
+$$
+f ( \gamma ( t ) ) : = f ( x _ { k } - t h \nabla f ( x _ { k } ) ) , t \in [ 0 , 1 ] .
+$$
+
+Note that with this parametrization, we have $\gamma ( 0 ) = x _ { k } , \gamma ( 1 ) = x _ { k + 1 } .$ Now we would like to argue that if $f ( x _ { k } ) \leq f ( { \bar { x } } _ { 0 } )$ , then $\| \nabla f ( x ( t ) ) \| \leq M , \forall t \leq 1$ . Assume by contradiction that this is not true. Then there exists $\epsilon > 0 , t \in [ 0 , 1 ]$ such that $\| \nabla f ( x ( t ) ) \| \ge M + \epsilon$ . Since $\epsilon$ can be made arbitrarily small below a threshold, we assume $\epsilon < M$ . Denote
+
+$$
+t ^ { * } = \operatorname* { i n f } \{ t \mid \| \nabla f ( x ( t ) ) \| \geq M + \epsilon \} .
+$$
+
+The value $t ^ { * }$ exists by continuity of $\| \nabla f ( x ( t ) ) \|$ as a function of $t$ . Then we know by Assumption 4 that $f ( x ( t ^ { * } ) ) > f ( \dot { x _ { k } } )$ . However, by Taylor expansion, we know that
+
+$$
+\begin{array} { r l } & { f ( x ( t ^ { * } ) ) \leq f ( x _ { k } ) - t h \| \nabla f ( x _ { k } ) \| ^ { 2 } + ( t h ) ^ { 2 } \| \nabla f ( x _ { k } ) \| ^ { 2 } \displaystyle \int _ { 0 } ^ { t } \| \nabla ^ { ( 2 ) } f ( x ( \tau ) ) \| d \tau } \\ & { \qquad \leq f ( x _ { k } ) - t h \| \nabla f ( x _ { k } ) \| ^ { 2 } + ( t h ) ^ { 2 } \| \nabla f ( x _ { k } ) \| ^ { 2 } \displaystyle ( L _ { 1 } ( M + \epsilon ) + L _ { 0 } ) } \\ & { \qquad \leq f ( x _ { k } ) . } \end{array}
+$$
+
+The last inequality follows by $h = 1 / ( 2 ( M L _ { 1 } + L _ { 0 } ) )$ . Hence we get a contradiction and conclude that for all $t \leq 1$ , $\| \nabla f ( x ( t ) ) \| \leq M$ . Therefore, following the above inequality and Assumption 3, we get
+
+$$
+\begin{array} { l } { f ( x _ { k + 1 } ) \leq f ( x _ { k } ) - h \| \nabla f ( x _ { k } ) \| ^ { 2 } + h ^ { 2 } \displaystyle \frac { L _ { 1 } M + L _ { 0 } } { 2 } \| \nabla f ( x _ { k } ) \| ^ { 2 } } \\ { \leq f ( x _ { k } ) - \displaystyle \frac { \epsilon ^ { 2 } } { 4 ( M L _ { 1 } + L _ { 0 } ) } . } \end{array}
+$$
+
+The conclusion follows by the same argument as in Theorem 3 via a telescopic sum over $k$ .
+
+# F PROOF OF THEOREM 7
+
+Recall that we set the following parameters
+
+$$
+\begin{array} { l } { { h _ { k } = \operatorname* { m i n } \{ \frac { 1 } { 1 6 \eta L _ { 1 } ( \left| \left| g _ { k } \right| \right| + \tau ) } , \eta \} } } \\ { { \eta = \operatorname* { m i n } \{ \frac { 1 } { 2 0 L _ { 0 } } , \frac { 1 } { 1 2 8 L _ { 1 } \tau } , \frac { 1 } { \sqrt { T } } \} } } \end{array}
+$$
+
+Similar to proof of Theorem 3, we have
+
+$$
+\begin{array} { r l } {  { \mathbb { E } [ f ( x _ { k + 1 } ) ] \| \leq f ( x _ { k } ) - \mathbb { E } [ h _ { k } \langle g _ { k } , \nabla f ( x _ { k } ) \rangle ] + \frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } \mathbb { E } [ h _ { k } ^ { 2 } \| g _ { k } \| ^ { 2 } ] } } \\ & { \leq f ( x _ { k } ) - \mathbb { E } [ h _ { k } \langle g _ { k } , \nabla f ( x _ { k } ) \rangle ] + \frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } \mathbb { E } [ h _ { k } ^ { 2 } ( \| \nabla f ( x _ { k } ) \| ^ { 2 } } \\ & { \quad + \| g _ { k } - \nabla f ( x _ { k } ) \| ^ { 2 } + 2 \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle ] } \\ & { \leq f ( x _ { k } ) + \mathbb { E } [ - h _ { k } + \frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } h _ { k } ^ { 2 } ] \| \nabla f ( x _ { k } ) \| ^ { 2 } } \\ & { \quad + \mathbb { E } [ h _ { k } ( - 1 + ( 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| ) h _ { k } ) \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle ] } \\ & { \quad + \frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } \mathbb { E } [ h _ { k } ^ { 2 } ( \| g _ { k } - \nabla f ( x _ { k } ) \| ^ { 2 } ) ] } \end{array}
+$$
+
+First we show $\begin{array} { r } { ( 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| ) h _ { k } \leq \frac 1 2 } \end{array}$ . This follows by $\begin{array} { r } { 5 L _ { 0 } h _ { k } \le \frac { 1 } { 4 } , h _ { k } 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| \le } \end{array}$ $h _ { k } 4 L _ { 1 } ( \left\| g _ { k } \right\| + \tau ) \leq \frac 1 4$ . Substitute in (15) and we get
+
+$$
+\begin{array} { r l } & { \mathbb { E } [ f ( x _ { k + 1 } ) \| \le f ( x _ { k } ) + \mathbb { E } [ - \frac { 3 h _ { k } } { 4 } ] \| \nabla f ( x _ { k } ) \| ^ { 2 } } \\ & { \qquad + \underbrace { \mathbb { E } [ - h _ { k } \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle ] } _ { T _ { 1 } } } \\ & { \qquad + \underbrace { \mathbb { E } [ ( 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| ) h _ { k } ^ { 2 } \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle ] } _ { T _ { 2 } } } \\ & { \qquad + \underbrace { \frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } \mathbb { E } [ h _ { k } ^ { 2 } ( \| g _ { k } - \nabla f ( x _ { k } ) \| ^ { 2 } ) ] } _ { T _ { 3 } } } \end{array}
+$$
+
+Then we bound $T _ { 1 } , T _ { 2 } , T _ { 3 }$ in Lemma 11,12,13 and get
+
+$$
+\begin{array} { r l } {  { \mathbb { E } [ f ( x _ { k + 1 } ) ] ] \le f ( x _ { k } ) + \mathbb { E } [ - \frac { h _ { k } } { 4 } ] \| \nabla f ( x _ { k } ) \| ^ { 2 } } } \\ & { \quad + ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \eta ^ { 2 } \tau ^ { 2 } + 9 \eta ^ { 2 } \tau L _ { 0 } ^ { 2 } / L _ { 1 } } \end{array}
+$$
+
+Rearrange and do a telescopic sum, we get
+
+$$
+\begin{array} { r l r } {  { \mathbb { E } [ \sum _ { k \le T } \frac { h _ { k } } { 4 } \| \nabla f ( x _ { k } ) \| ^ { 2 } ] \le f ( x _ { 0 } ) - f ^ { * } + \eta ^ { 2 } T \bigl ( ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \tau ^ { 2 } + 9 \tau L _ { 0 } ^ { 2 } / L _ { 1 } \bigr ) } } \\ & { } & \\ & { } & { \le f ( x _ { 0 } ) - f ^ { * } + \bigl ( ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \tau ^ { 2 } + 9 \tau L _ { 0 } ^ { 2 } / L _ { 1 } \bigr ) } \end{array}
+$$
+
+Furthermore, we know
+
+$$
+\begin{array} { l } { h _ { k } \| \nabla f _ { k } \| ^ { 2 } = \operatorname* { m i n } \lbrace \eta , \frac { 1 } { 1 6 L _ { 1 } ( \| \nabla f _ { k } \| + \tau ) } \rbrace \| \nabla f _ { k } \| ^ { 2 } } \\ { \qquad \geq \operatorname* { m i n } \lbrace \eta , \frac { 1 } { 3 2 L _ { 1 } \| \nabla f _ { k } \| } , \frac { 1 } { 3 2 L _ { 1 } \tau } \rbrace \| \nabla f _ { k } \| ^ { 2 } } \\ { \qquad \geq \operatorname* { m i n } \lbrace \eta , \frac { 1 } { 3 2 L _ { 1 } \| \nabla f _ { k } \| } \rbrace \| \nabla f _ { k } \| ^ { 2 } } \end{array}
+$$
+
+Hence along with $\eta \le T ^ { - 1 / 2 }$ , we get
+
+$$
+\mathbb { E } [ \sum _ { k \le T } \operatorname* { m i n } \{ \eta \| \nabla f _ { k } \| ^ { 2 } , \frac { \| \nabla f _ { k } \| } { 3 2 L _ { 1 } } \} ] \le f ( x _ { 0 } ) - f ^ { * } + ( ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \tau ^ { 2 } + 9 \tau L _ { 0 } ^ { 2 } / L _ { 1 } )
+$$
+
+Let $\begin{array} { r } { \mathcal { U } = \{ k | \eta | \| \nabla f _ { k } \| ^ { 2 } \le \frac { \| \nabla f _ { k } \| } { 1 6 L _ { 1 } } \} } \end{array}$ , we know that
+
+$$
+\mathbb { E } [ \sum _ { k \in \mathcal { U } } \eta \| \nabla f _ { k } \| ^ { 2 } ] \le f ( x _ { 0 } ) - f ^ { * } + ( ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \tau ^ { 2 } + 9 \tau L _ { 0 } ^ { 2 } / L _ { 1 } ) ,
+$$
+
+and
+
+$$
+\mathbb { E } [ \sum _ { k \in \mathcal { U } ^ { c } } \frac { \| \nabla f _ { k } \| } { 3 2 L _ { 1 } } ] \le f ( x _ { 0 } ) - f ^ { * } + ( ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \tau ^ { 2 } + 9 \tau L _ { 0 } ^ { 2 } / L _ { 1 } ) .
+$$
+
+Therefore,
+
+$$
+\begin{array} { r l } & { \mathsf { f } [ \operatorname* { m i n } _ { k } \| \nabla f ( x _ { k } ) \| ] \le \mathbb { E } [ \operatorname* { m i n } \{ \displaystyle \frac { 1 } { | { \cal U } | } \sum _ { k \in { \cal U } } \| \nabla f _ { k } \| ] , \displaystyle \frac { 1 } { | { \cal U } ^ { c } | } \sum _ { k \in { \cal U } ^ { c } } \| \nabla f _ { k } \| \} ] } \\ & { \le \mathbb { E } [ \operatorname* { m i n } \{ \sqrt { \displaystyle \frac { 1 } { | { \cal U } | } \sum _ { k \in { \cal U } } \| \nabla f _ { k } \| ^ { 2 } } , \displaystyle \frac { 1 } { | { \cal U } ^ { c } | } \sum _ { k \in { \cal U } ^ { c } } \| \nabla f _ { k } \| \} ] } \\ & { \le \operatorname* { m a x } \{ \sqrt { f ( x _ { 0 } ) - f ^ { * } + ( ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \tau ^ { 2 } + 9 \tau L _ { 0 } ^ { 2 } / L _ { 1 } ) \displaystyle \frac { \sqrt { T } + 2 0 L _ { 0 } + 1 2 8 L _ { 1 } \tau } { T } } , } \\ & { \quad \quad \quad \quad ( f ( x _ { 0 } ) - f ^ { * } + ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \tau ^ { 2 } + 9 \tau L _ { 0 } ^ { 2 } / L _ { 1 } ) \displaystyle \frac { 6 4 L _ { 1 } } { T } \} . } \end{array}
+$$
+
+The last inequality follow by the fact that either $| \mathcal { U } | \ge T / 2$ or $| \mathcal { U } ^ { c } | \ge T / 2$ . This implies that $\begin{array} { r } { \mathbb { E } [ \operatorname* { m i n } _ { k \leq T } \| \nabla f ( x _ { k } ) \| ] \leq 2 \epsilon } \end{array}$ when
+
+$$
+T \geq \Delta \operatorname* { m a x } \{ \frac { 1 2 8 L _ { 1 } } { \epsilon } , \frac { 4 \Delta } { \epsilon ^ { 4 } } , \frac { 8 0 L _ { 0 } + 5 1 2 L _ { 1 } \tau } { \epsilon ^ { 2 } } \} ,
+$$
+
+where $\Delta = ( f ( x _ { 0 } ) - f ^ { * } + ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \tau ^ { 2 } + 9 \tau L _ { 0 } ^ { 2 } / L _ { 1 } )$ . By Markov inequality,
+
+$$
+\mathbb { P } \{ \operatorname* { m i n } _ { k \leq T } \| \nabla f ( x _ { k } ) \| \leq \epsilon \} \geq \frac { 1 } { 2 } .
+$$
+
+The theorem follows by the definition in (9).
+
+# F.1 TECHNICAL LEMMAS
+
+# Lemma 11.
+
+$$
+\mathbb { E } [ - h _ { k } \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle ] \leq { \frac { 1 } { 4 } } \mathbb { E } [ h _ { k } ] \| \nabla f ( x _ { k } ) \| ^ { 2 } .
+$$
+
+Proof. By unbiasedness of $g _ { k }$ and the fact that $\eta$ is a constant, we have
+
+$$
+\begin{array} { r l } { \mathbb { E } [ - h _ { k } \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle ] = \mathbb { E } [ ( \eta - h _ { k } ) \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle ] } & { } \\ & { = \mathbb { E } [ ( \eta - h _ { k } ) \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle \mathbb { 1 } _ { \{ \| g _ { k } \| \ge \frac { 1 } { 1 6 L _ { 1 } \eta } - \tau \} } ] } \\ & { \le \eta \| \nabla f ( x _ { k } ) \| \mathbb { E } [ \| g _ { k } - \nabla f ( x _ { k } ) \| \mathbb { 1 } _ { \{ \| g _ { k } \| \ge \frac { 1 } { 1 6 L _ { 1 } \eta } - \tau \} } ] } \\ & { \le \eta \| \nabla f ( x _ { k } ) \| ^ { 2 } 3 2 L _ { 1 } \mathbb { E } [ h _ { k } ] \tau } \end{array}
+$$
+
+The second last inequality follows by $h _ { k } \leq \eta$ and Cauchy-Schwartz inequality. The last inequality follows by
+
+$$
+\Vert \nabla f ( x _ { k } ) \Vert \ge \Vert g _ { k } \Vert - \tau = \frac { 1 } { 1 6 L _ { 1 } h _ { k } } - 2 \tau \ge \frac { 1 } { 1 6 L _ { 1 } h _ { k } } - \frac { 1 } { 3 2 L _ { 1 } \eta } \ge \frac { 1 } { 3 2 L _ { 1 } h _ { k } } .
+$$
+
+The equality above holds because $\begin{array} { r } { h _ { k } = \frac { 1 } { 1 6 \eta L _ { 1 } ( \left. { g _ { k } } \right. + \tau ) } . } \end{array}$ . The lemma follows by $3 2 \eta L _ { 1 } \tau \leq 1 / 4$ .
+
+# Lemma 12.
+
+$$
+\mathbb { E } \big [ ( 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| ) h _ { k } ^ { 2 } \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle \big ] \leq 9 \eta ^ { 2 } \tau L _ { 0 } ^ { 2 } / L _ { 1 } + \frac { 1 } { 8 } \mathbb { E } [ h _ { k } ] \| \nabla f ( x _ { k } ) \| ^ { 2 } .
+$$
+
+Proof. When $\| \nabla f ( x _ { k } ) \| \ge L _ { 0 } / L _ { 1 }$
+
+$$
+\begin{array} { r l } & { \mathbb { E } [ ( 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| ) h _ { k } ^ { 2 } \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle ] \leq 9 L _ { 1 } \| \nabla f ( x _ { k } ) \| \mathbb { E } [ h _ { k } ^ { 2 } ] \| \nabla f ( x _ { k } ) \| \tau } \\ & { \qquad \leq \frac { 1 } { 8 } \mathbb { E } [ h _ { k } ] \| \nabla f ( x _ { k } ) \| ^ { 2 } } \end{array}
+$$
+
+The last inequality follows by (12).
+
+When $\| \nabla f ( x _ { k } ) \| \leq L _ { 0 } / L _ { 1 }$ ,
+
+$$
+\mathbb { E } [ ( 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| ) h _ { k } ^ { 2 } \langle \nabla f ( x _ { k } ) , g _ { k } - \nabla f ( x _ { k } ) \rangle ] \le 9 \eta ^ { 2 } \tau L _ { 0 } ^ { 2 } / L _ { 1 }
+$$
+
+# Lemma 13.
+
+$$
+\frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } \mathbb { E } [ h _ { k } ^ { 2 } ( \| g _ { k } - \nabla f ( x _ { k } ) \| ^ { 2 } ) ] \leq ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \eta ^ { 2 } \tau ^ { 2 } + \frac { 1 } { 8 } \| \nabla f ( x _ { k } ) \| ^ { 2 } \mathbb { E } [ h _ { k } ] .
+$$
+
+Proof. When $\| \nabla f ( x _ { k } ) \| \ge L _ { 0 } / L _ { 1 } + \tau$ , we get
+
+$$
+\frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } \mathbb { E } [ h _ { k } ^ { 2 } ( \| g _ { k } - \nabla f ( x _ { k } ) \| ^ { 2 } ) ] \le 5 L _ { 1 } \| \nabla f ( x _ { k } ) \| ^ { 2 } \mathbb { E } [ h _ { k } ] \eta \tau \le \frac { 1 } { 8 } \| \nabla f ( x _ { k } ) \| ^ { 2 } \mathbb { E } [ h _ { k } ] .
+$$
+
+The first inequality follows by $h _ { k } \leq \eta$ and $\| g _ { k } - \nabla f ( x _ { k } ) \| \leq \tau \leq \| \nabla f ( x _ { k } ) \|$ .The last inequality follows by (12).
+
+When $\| \nabla f ( x _ { k } ) \| \le L _ { 0 } / L _ { 1 } + \tau$ , we get
+
+$$
+\frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } \mathbb { E } [ h _ { k } ^ { 2 } ( \| g _ { k } - \nabla f ( x _ { k } ) \| ^ { 2 } ) ] \le ( 5 L _ { 0 } + 2 L _ { 1 } \tau ) \eta ^ { 2 } \tau ^ { 2 } .
+$$
+
+# G PROOF OF THEOREM 8
+
+Similar to proof of Theorem 3, we have
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } [ f ( x _ { k + 1 } ) | ] \leq f ( x _ { k } ) - \mathbb { E } [ h _ { k } \langle g _ { k } , \nabla f ( x _ { k } ) \rangle ] + \frac { 5 L _ { 0 } + 4 L _ { 1 } \| \nabla f ( x _ { k } ) \| } { 2 } \mathbb { E } [ h _ { k } ^ { 2 } \| g _ { k } \| ^ { 2 } ] } \\ { \displaystyle \leq f ( x _ { k } ) - \frac { 1 } { \sqrt { T } } \| \nabla f ( x _ { k } ) \| ^ { 2 } + \frac { 5 L _ { 0 } + 4 L _ { 1 } M ( M + \tau ) ^ { 2 } } { 2 T } } \end{array}
+$$
+
+Sum across $k \in \{ 0 , . . . , T - 1 \}$ and take expectations, then we can get
+
+$$
+0 \leq f ( x _ { 0 } ) - \mathbb { E } [ f ( x _ { T } ) ] - { \frac { 1 } { \sqrt { T } } } \sum _ { k = 1 } ^ { T } \mathbb { E } \Big [ \| \nabla f ( x _ { k } ) \| ^ { 2 } \Big ] + { \frac { 5 L _ { 0 } + 4 L _ { 1 } M ( M + \tau ) ^ { 2 } } { 2 } }
+$$
+
+Rearrange and we get
+
+$$
+\frac { 1 } { T } \sum _ { k = 1 } ^ { T } \mathbb { E } \Big [ \| \nabla f ( x _ { k } ) \| ^ { 2 } \Big ] \leq \frac { 1 } { \sqrt { T } } \Bigg ( f ( x _ { 0 } ) - f ^ { * } + \frac { 5 L _ { 0 } + 4 L _ { 1 } M ( M + \tau ) ^ { 2 } } { 2 } \Bigg )
+$$
+
+By Jensen’s inequality,
+
+$$
+\frac { 1 } { T } \sum _ { k = 1 } ^ { T } \mathbb { E } [ \| \nabla f ( x _ { k } ) \| ] \leq \sqrt { \frac { 1 } { \sqrt { T } } } \bigg ( f ( x _ { 0 } ) - f ^ { * } + \frac { 5 L _ { 0 } + 4 L _ { 1 } M ( M + \tau ) ^ { 2 } } { 2 } \bigg )
+$$
+
+By Markov inequality,
+
+$$
+\mathbb { P } \Bigg \{ \frac { 1 } { T } \sum _ { k = 1 } ^ { T } \Big [ \| \nabla f ( x _ { k } ) \| ^ { 2 } \Big ] > \frac { 2 } { \sqrt { T } } \bigg ( f ( x _ { 0 } ) - f ^ { * } + \frac { 5 L _ { 0 } + 4 L _ { 1 } M ( M + \tau ) ^ { 2 } } { 2 } \bigg ) \Bigg \} \leq 0 . 5
+$$
+
+The theorem follows by the definition in (9) and Jensen’s inequality.
+
+# H EXPERIMENT DETAILS
+
+In this section, we first briefly overview the tasks and models used in our experiment. Then we explain how we estimate smoothness of the function. Lastly, we describe some details for generating the plots in Figure 2 and Figure 3.
+
+# H.1 LANGUAGE MODELLING
+
+Clipped gradient descent was introduced in (vanilla) recurrent neural network (RNN) language model (LM) (Mikolov et al., 2010) training to alleviate the exploding gradient problem, and has been used in more sophisticated RNN models (Hochreiter and Schmidhuber, 1997) or seq2seq models for language modelling or other NLP applications (Sutskever et al., 2014; Cho et al., 2014). In this work we experiment with LSTM LM (Sundermeyer et al., 2012), which has been an important building block for many popular NLP models (Young et al., 2017).
+
+The task of language modelling is to model the probability of the next word $w _ { t + 1 }$ based on word history (or context). Given a document of length $T$ (words) as training data, the training objective is to minimize negative log-likelihood of the data $\begin{array} { r } { \frac { - 1 } { T } \dot { \Sigma } _ { t = 1 } ^ { T } \log P ( w _ { t } | w _ { 1 } . . . w _ { t - 1 } ) } \end{array}$ .
+
+We run LM experiments on the Penn Treebank (PTB) (Mikolov et al., 2010) dataset, which has been a popular benchmark for language modelling. It has a vocabulary of size $1 0 \mathrm { k }$ , and $8 8 7 \mathrm { k } / 7 0 \mathrm { k } / 7 8 \mathrm { k }$ words for training/validation/testing.
+
+To train the LSTM LM, we follow the training recipe from 3 (Merity et al., 2018). The model is a 3-layer LSTM LM with hidden size of 1150 and embedding size of 400. Dropout (Srivastava et al., 2014) of rate 0.4 and DropConnect (Wan et al., 2013) of rate 0.5 is applied. For optimization, clipped SGD with clip value of 0.25 and a learning rate of 30 is used, and the model is trained for 500 epochs. After training, the model reaches a text-set perplexity of 56.5, which is very close to the current state-of-art result (Dai et al., 2019) on the PTB dataset.
+
+# H.2 IMAGE CLASSIFICATION
+
+As a comparison, we run the same set of experiments on image classification tasks. We train the ResNet20 (He et al., 2016) model on Cifar10 (Krizhevsky and Hinton, 2009) classification dataset. The dataset contains $5 0 \mathrm { k }$ training images and 10k testing images in 10 classes.
+
+Unless explicitly state, we use the standard hyper-parameters based on the Github repository4. Our baseline algorithm runs SGD momentum with learning rate 0.1, momentum 0.9 for 200 epochs. We choose weight decay to be $5 e { - 4 }$ . The learning rate is reduced by 10 at epoch 100 and 150. Up to our knowledge, this baseline achieves the best known test accuracy $( 9 5 . 0 \% )$ for Resnet20 on Cifar10. The baseline already beats some recently proposed algorithms which claim to improve upon SGD momentum.
+
+![](images/1d1019a5d7cc78ff94457a13bb6bd1316ab20bfd283c1721542c9ffe3a28ddc8.jpg)  
+Figure 5: Auxiliary plots for Figure 2a. The left subfigure shows the values scattered on linear scale. The right subfigure shows more data points from 200 epochs.
+
+![](images/f78c85ce67c6a1b84eb78b1135eef1177756e0e26917f85ed7a3cb2ed6acfc4c.jpg)  
+Figure 6: Estimated gradient norm and smoothness using $10 \%$ data versus all data. The values are computed from checkpoints of the LSTM LM model in the first epoch. This shows that statistics evaluated from $1 0 \%$ of the entire dataset provides accurate estimation.
+
+# H.3 ESTIMATING SMOOTHNESS
+
+Our smoothness estimator follows a similar implementation as in (Santurkar et al., 2018). More precisely, given a sequence of iterates generated by training procedure $\{ x _ { k } \} _ { k }$ , we estimate the smoothness $\hat { L } ( x _ { k } )$ as follows. For some small value $\delta \in ( 0 , 1 ) , d = x _ { k + 1 } - x _ { k }$ ,
+
+$$
+\hat { L } ( x _ { k } ) = \operatorname* { m a x } _ { \gamma \in \{ \delta , 2 \delta , \ldots , 1 \} } \frac { \| \nabla f ( x + \gamma d ) - \nabla f ( x ) \| } { \| \gamma d \| } .
+$$
+
+This suggests that we only care about the variation of gradient along $x _ { k + 1 } - x _ { k }$ . The motivation is based on the function upper bound (10), which shows that the deviation of the objective from its linear approximation is determined by the variation of gradient between $x _ { k + 1 }$ and $x _ { k }$ .
+
+# H.4 ADDITIONAL PLOTS
+
+The plots in Figure 2a show log-scale scattered data for iterates in the first epoch. To supplement this result, we show in Figure 5a the linear scale plot of the same data as in Figure 2a. In Figure 5b, we run the same experiment as in Figure 2a for 200 epochs instead of 1 epoch and plot the gradient norm and estimated smoothness along the trajectory.
+
+In Figure 2, we plot the correlation between gradient norm and smoothness in LSTM LM training. We take snapshots of the model every 5 iterations in the first epoch, and use $10 \%$ of training data to estimate gradient norm and smoothness. As shown in Figure 6, using $1 0 \%$ of the data provides a very accurate estimate of the smoothness computed from the entire data.
+
+# I A SYNTHETIC EXPERIMENT
+
+In this section, we demonstrate the different behaviors of gradient descent versus clipped gradient descent by optimizing a simple polynomial $f ( x ) = x ^ { 4 }$ . We initialize the point at $x _ { 0 } = 3 0$ and run both algorithms. Within the sublevel set $[ - 3 0 , 3 0 ]$ , the function satisfies
+
+$$
+\begin{array} { r } { f ^ { \prime \prime } ( x ) \leq 1 2 \times 3 0 ^ { 2 } = 1 . 0 8 \times 1 0 ^ { 4 } } \\ { f ^ { \prime \prime } ( x ) \leq 1 0 f ^ { \prime } ( x ) + 0 . 1 . } \end{array}
+$$
+
+Therefore, we can either pick $L _ { 1 } = 0 , L _ { 0 } = 1 . 0 8 ^ { 4 }$ for gradient descent or $L _ { 1 } = 1 0 . L _ { 0 } = 0 . 1$ for clipped GD. Since the theoretical analysis is not tight with respect to constants, we scan the step sizes to pick the best parameter for both algorithms. For gradient descent, we scan step size by halving the current steps. For clipped gradient descent, we fix threshold to be 0.01 and pick the step size in the same way. The convergence results are shown in Figure 7. We can conclude that clipped gradient descent converges much faster than vanilla gradient descent, as the theory suggested.
+
+![](images/406142130d68091d97cbda80b97306a35ddaa7afad510075ae1dd74a4a75a1e7.jpg)  
+Figure 7: An synthetic experiment to optimize $f ( x ) = x ^ { 4 }$ . (a) Gradient descent with different step size. (b) Clipped gradient descent with different step size and threshold $= 0 . 0 1$ .
+
+# J A QUANTITATIVE COMPARISON OF THEOREMS AND EXPERIMENTS
+
+To quantify how much the result align with the theorem, we assume that the leading term in the iteration complexity is the $\epsilon$ dependent term. For GD, the term scales as $\begin{array} { r } { \mathcal { O } ( \frac { M L _ { 1 } + L _ { 0 } ^ { - } } { \sqrt { T } } ) } \end{array}$ , while for Clipped GD, the term scales as $\begin{array} { r l } { \mathcal { O } \big ( \frac { L _ { 0 } } { \sqrt { T } } \big ) } \end{array}$ .
+
+First, we start with the synthetic experiment presented in I. From theory, we infer that the improvement of $\begin{array} { r } { \frac { f ^ { \prime } ( x _ { G D } ) } { f ^ { \prime } ( x _ { C G D } ) } \ \approx \ \frac { L _ { 0 } } { M L _ { 1 } + L _ { 0 } } \ \approx \ 1 e 5 } \end{array}$ . In experiment, the best performing GD reaches $f ^ { \prime } ( x _ { T } ) = 0 . 3 6$ , while for clipped GD, the value is $1 . 3 e \mathrm { ~ - ~ } 8$ , and the ratio is $\begin{array} { r } { \frac { f ^ { \prime } ( x _ { G D } ) } { f ^ { \prime } ( x _ { C G D } ) } \approx 1 e 7 . } \end{array}$ . This suggests that in this very adversarial (against vanilla GD) synthetic experiment, the theorem is correct but conservative.
+
+Next, we test how well the theory can align with practice in neural network training. To do so, we rerun the PTB experiment in 5 with a smaller architecture (2-Layer LSTM with 200 embedding dimension and 512 inner dimension). We choose hyperparameters based on Figure 4a. For clipped GD, we choose clipping threshold to be 0.25 and learning rate to be 10. For GD, we use a learning rate 2. One interesting observation is that, though GD makes steady progress in minimizing function value, its gradient norm is not decreasing.
+
+To quantify the difference between theory and practice, we follow the procedure as in the synthetic experiment. First, we estimate $M L _ { 1 } + L _ { 0 } = 2 5$ for GD from Figure 8(c). Second, we estimate $L _ { 1 } = 1 0 , L _ { 0 } = 5$ for clipped GD’s trajectory from subplot (d). Then the theory predicts that the ratio between gradients should be roughly $2 5 / 5 = 5$ . Empirically, we found the ratio to be $\approx 3$ by taking the average (as in Theorem 3 and Theorem 6). This doesn’t exactly align but is of the same scale. From our view, the main reason for the difference could be the presence of noise in this experiment. As theorems suggested, noise impacts convergence rates but is absent in our rough estimates $\frac { M L _ { 1 } + L _ { 0 } } { L _ { 0 } }$ .
+
+![](images/749b0e61a64465bdbd5945689768eb0636b75a453ad58da244ef0cc9012a6c71.jpg)  
+Figure 8: (a) Gradient norm. (b) Loss curves. (c)The scatter points of smoothness vs gradient norm for the model trained with gradient descent.(d)The scatter points of smoothness vs gradient norm for the model trained with clipped GD.

parse/train/HJeRkh05Km/HJeRkh05Km.md

@@ -0,0 +1,294 @@
+# VISUAL SEMANTIC NAVIGATION USING SCENE PRIORS
+
+Wei Yang1, Xiaolong Wang2, Ali Farhadi4,5, Abhinav Gupta2,3, Roozbeh Mottaghi5 1 The Chinese University of Hong Kong 2 Carnegie Mellon University 3 Facebook AI Research 4 University of Washington 5 Allen Institute for AI
+
+![](images/db7d2da001c9a1d9b7e1da8619686d0e4d5bec0baf0cfc67a499d5b53445191a.jpg)  
+Figure 1: Our goal is to use scene priors to improve navigation in unseen scenes and towards novel objects. (a) There is no mug in the field of view of the agent, but the likely location for finding a mug is the cabinet near the coffee machine. (b) The agent has not seen a mango before, but it infers that the most likely location for finding a mango is the fridge since similar objects such as apple appear there as well. The most likely locations are shown with the orange box.
+
+# ABSTRACT
+
+How do humans navigate to target objects in novel scenes? Do we use the semantic/functional priors we have built over years to efficiently search and navigate? For example, to search for mugs, we search cabinets near the coffee machine and for fruits we try the fridge. In this work, we focus on incorporating semantic priors in the task of semantic navigation. We propose to use Graph Convolutional Networks for incorporating the prior knowledge into a deep reinforcement learning framework. The agent uses the features from the knowledge graph to predict the actions. For evaluation, we use the AI2-THOR framework. Our experiments show how semantic knowledge improves performance significantly. More importantly, we show improvement in generalization to unseen scenes and/or objects.
+
+# 1 INTRODUCTION
+
+Consider the kitchen scene shown in Figure 1(a) and the task of finding an object such as a mug. Even though we have never seen this particular kitchen before and no mug is visible in the scene, we can still infer the likely locations to find the mug and create an exploration plan accordingly. For example, in Figure 1(a), we can infer that since there is a coffee machine, the mug is most likely in the cabinet near the coffee machine. How do we do that? We infer that mugs are usually used for coffee. And since there is a coffee machine, the mug is likely to be near the machine due to functional efficiency. We argue that humans use strong priors about the functional and semantic structure of the world to develop such efficient navigation strategies. And how do we learn such functional/semantic priors? Our prior experience and exploration of tens of kitchens help us to learn these priors.
+
+But these priors are not just used for navigating to known objects but also to completely unknown and unseen objects. For example, let us assume you have never seen a mango before and someone gives you a task of finding a mango in a new kitchen you have never seen before (let’s say Figure 1(b)). How would you do it? Assuming you have searched for fruits like apples and grapes before, and you know mango is also a fruit; so a similar exploration strategy might apply. Therefore, in Figure 1(b), you are more likely to navigate to the fridge to search for a mango. Therefore, we use the semantic/functional priors to navigate to unseen objects as well.
+
+Inspired by these observations, in this paper, we explore how to exploit semantic priors for the task of semantic and goal-oriented navigation. In our visual navigation task, the environment, the path to the target, the target location, or the exact appearance of the target object can be unknown. The prior knowledge about the semantic/functional structure of the world helps to improve the navigation. We propose to use Graph Convolutional Networks (GCNs) (Kipf & Welling, 2017) to incorporate the prior knowledge into a Deep Reinforcement Learning framework. The knowledge of the agent is encoded in a graph. GCNs allow arbitrary structured graphs to be encoded in an efficient way. The knowledge is updated according to the current observation of the agent, which is specific to the current environment, and the knowledge at the previous time step or the prior knowledge. The prior knowledge is obtained from large-scale datasets designed for scene understanding. Our model is based on the actor-critic model (Mnih et al., 2016) that is augmented by the knowledge graph and object visibility information.
+
+To evaluate our model, we use the AI2-THOR framework (Kolve et al., 2017), which provides near photo-realistic customizable environments. The agent can take navigation actions in these environments and observe the changes as a result of those actions. AI2-THOR includes various objects that can be arranged in many different configurations. The agent location is randomized as well at each episode of training or testing. Our experiments show that the semantic prior improves the performance of the baseline RL models significantly. Furthermore, we show the results of the model on the challenging setting where the scene and/or the object are new to the agent.
+
+Our contributions are summarized as follows: (1) We integrate a deep reinforcement learning model with knowledge graphs. This allows the agent to encode any form of knowledge that can be represented by graph structures. (2) We show that semantic prior knowledge can significantly improve the navigation performance. (3) By considering the prior information and the semantics of the target objects, we improve generalization to unseen environments and novel target objects.
+
+# 2 RELATED WORK
+
+Semantic and goal-oriented navigation is one of the most prominent tasks that intelligent species perform in their daily life. There are several challenges involved in visual navigation. First, the environment might be unknown to the agent. In this situation, the agent requires to explore the environment to have a better understanding of that environment. The second challenge is about the visibility of target objects. The target object might not be visible when the agent starts the navigation or it might go out of the field of view during navigation. Hence, the agent needs to learn an efficient search strategy to find the target object. The third challenge is related to planning. The object might be visible but planning a reasonable path towards the object is another issue that the agent needs to deal with. There have been several efforts in the past to tackle these challenges which we describe below.
+
+Geometry-based navigation. Navigation methods can be divided into two main categories of geometry-based and learning-based. Most of the traditional navigation approaches fall into the former category, where it is assumed that either the map of the environment is known a priori, e.g., Matthies & Shafer (1987); Borenstein & Koren (1991); Meng & Kak (1993); Kim & Nevatia (1999) or a map is built on the fly e.g., Thrun (1998); Feder et al. (1999); Jones & Soatto (2011); Siagian et al. (2014). Our work is different from these approaches since we do not rely on a map for our navigation and we leverage semantic prior knowledge to reduce the required exploration time.
+
+Learning-based navigation. Recent success of deep learning and reinforcement learning has made learning-based navigation approaches more popular. Zhu et al. (2017) propose a deep RL-based navigation approach, where they provide the picture of the target object. In contrast, we only provide semantic labels to the agent, so we can show generalization to unseen scenes. Gupta et al. (2017) propose a mapper and planner to output navigation actions. Mirowski et al. (2017) also propose a navigation framework that optimizes a loss for auxiliary tasks such as depth prediction and loop closure classification. Sadeghi & Levine (2017) propose an RL-based approach for collision avoidance. Brahmbhatt & Hays (2017) explore a CNN-based approach for navigating in cities using local observations of the streets. Wu & Tian (2017) combine deep RL with curriculum learning in a first-person shooting game setting. Savinov et al. (2018) introduce a topological landmark-based memory for navigation. Kahn et al. (2018) propose a method based on model-free and model-based RL to learn navigation policies using a few samples. Mousavian et al. (2018) use object detection and semantic segmentation to better navigate in unseen environments. Chen et al. (2015) directly map the input image to an action in an autonomous driving setting. There is also a large body of work that address visually grounded navigation instructions e.g., Anderson et al. (2018b); Chaplot et al. (2018); Hermann et al. (2017); Yu et al. (2018); Misra et al. (2017); Mei et al. (2016). In contrast to all these approaches, we incorporate semantic and functional priors to improve navigation performance and better generalize to unseen scenes and objects.
+
+Context and scene prior. Contextual reasoning has been studied extensively in the computer vision literature (Torralba et al., 2003; Hoiem et al., 2005; Rabinovich et al., 2005; Divvala et al., 2009; Desai et al., 2009; Marszalek et al., 2009; Malisiewicz & Efros, 2009; Mottaghi et al., 2014; Zhu et al., 2015; Shrivastava & Gupta, 2016). However, contextual information is mainly used for static settings such as object detection, semantic segmentation or action recognition. We use contextual reasoning for an interactive navigation task, where the agent updates its belief based on the current observation and the prior knowledge as it moves in the environment. Object relationships have been used for tasks such as image retrieval (Johnson et al., 2015), visual relation detection (Zhang et al., 2017), referring expressions (Nagaraja et al., 2016; Hu et al., 2017), and visual question answering (Johnson et al., 2017).
+
+Knowledge graphs. There are recent works that use knowledge graphs for computer vision problems. A knowledge graph is used by Marino et al. (2017) for image classification, by Li et al. (2017) for situation recognition and by Wang et al. (2018) for zero-shot recognition. We use knowledge graphs in an RL setting for the interactive task of visual navigation.
+
+Reasoning about unknown environments or objects. Various works have explored zero-shot reasoning in the context of reinforcement learning. Yu et al. (2018) address the problem of learning language in a 2D maze, where they can handle unseen word combinations or new sentences that contain unseen words. Harrison et al. (2017); Higgins et al. (2017) study zero-shot policy transfer in the scenarios that the dynamics or the states of the target domain is different from those of the source domain. Pathak et al. (2018) propose a zero-shot imitation learning approach where the expert demonstration for a particular task is never seen. Oh et al. (2017) address generalization of RL to unseen instructions and longer instructions. Our problem is different since we address navigation to novel objects or navigating in unseen scenes using scene priors.
+
+# 3 VISUAL SEMANTIC NAVIGATION
+
+In this section, we first define the task of visual semantic navigation. We then describe the formulation using deep reinforcement learning and the baseline model for the task.
+
+# 3.1 TASK DEFINITION
+
+Our goal is to navigate from a random starting location in a scene to a specified target object category given only egocentric RGB perception of the agent. The target object category is specified by a semantic label, thus we call our task visual semantic navigation. The task is considered successful if an instance of the target object category is visible. By “visible”, we mean the target object is in the field of view and within a threshold of distance.
+
+# 3.2 THE BASELINE MODEL
+
+We formulate the visual semantic navigation using a deep reinforcement learning framework. Given a semantic task objective $g$ , the agent perceives a state $s _ { t }$ (i.e., the egocentric RGB image from the current location and orientation) at the time step $t$ and samples an action $a _ { t }$ from the set of possible actions $\mathcal { A }$ according to its policy $\pi$ . We approximate the policy by a deep policy network $\pi ( \cdot ; \theta )$ :
+
+$$
+a _ { t } \sim \pi ( \phi ( s _ { t } ; u ) , \psi ( g ; v ) ; \theta ) ,
+$$
+
+![](images/18ddf835a05881d267abcdd22f7f41104bb2f3eeede453ab7d3bdd0ec04fe5ff.jpg)  
+Figure 2: Overview of the architecture. Our model to incorporate semantic knowledge into semantic navigation. Specifically, we learn a policy network that decides an action based on the visual features of the current state, the semantic target category feature and the features extracted from the knowledge graph. We extract features from the parts of the knowledge graph that are activated.
+
+where $u , v$ , and $\theta$ are the parameters for the network. Since the visual state and the semantic objective are from different modalities, we design two branches of subnetworks $\phi ( \cdot ; u )$ and $\psi ( \cdot ; v )$ to map these two inputs into a joint visual-semantic feature embedding.
+
+Visual network. As illustrated in Figure 2 (top), the visual network takes $2 2 4 \times 2 2 4$ RGB images as input and generates a 512-d feature vector as output. The backbone of the visual branch is ResNet50 (He et al., 2016) pre-trained on ImageNet. Specifically, we extract the 2048-d feature after the global average pooling of ResNet-50. To account for the history of the actions taken by the agent, we concatenate the features of the current frame and three past observations, which results in a 8192-d feature vector. We then add a fully connected layer and a ReLU layer to map the concatenated image feature into the 512-d visual-semantic feature.
+
+Semantic network. The semantic task objective is described by an object category, e.g., Microwave or Television. We use fastText (Joulin et al., 2016) to compute a 100-d embedding for each word. Then we map the word embedding into a 512-d feature by a fully connected layer and ReLU, as illustrated in Figure 2 (middle).
+
+Actor-Critic policy network. We employ the Asynchronous Advantage Actor-Critic (A3C) (Mnih et al., 2016) model to predict the policy at each time step. The input of our A3C model is the joint representation of the current state and the semantic task objective, which is a 1024-d feature vector made by concatenating the outputs of the visual network and the semantic network. The A3C model generates two outputs, i.e., the policy and the value. We sample the action from the predicted policy.
+
+Our implementation of the A3C model consists of three layers: the input, the hidden layer, and the outputs. The hidden layer is a fully connected layer followed by the ReLU activation layer which maps the fused input into a 512-d latent space. Then the $| { \cal A } |$ dimensional policy and the value are generated by two branches of network, as shown in Figure 2. Unlike previous work (e.g., Zhu et al. (2017)) which uses different policy networks for different scenes, we use a single policy network for different scene examples. This makes our model more compact and generalizable.
+
+Reward. We consider a reward to minimize the trajectory length to the targets: If any object instance from the target object category is reached within a certain number of steps, the agent receives a large positive reward 10.0. Otherwise, we penalize each step with a small negative reward -0.01. The design of the reward function is also affected by the types of actions $\mathcal { A }$ . In our experiments, we ablate two sets of actions $\mathcal { A }$ with or without the stop action. In the setting without the stop action, the agent will receive the positive reward if the environment notifies it when it reaches the target, which also ends an episode of training. In the setting with the stop action, the episode is terminated when the stop action is executed, and the positive reward will be provided only if the agent is within the threshold of distance from the target (1 meter in our experiments) and facing the target. This makes the task much more challenging.
+
+![](images/84f6b507c7d4337107b30bd248faf33b2ec5e3752b2f2033ccf289176aa6ab1e.jpg)  
+Figure 3: Scene priors. We extract relationships between objects from the Visual Genome (Krishna et al., 2017) dataset. The relationships for two example object categories are illustrated.
+
+# 4 GENERALIZATION WITH GRAPH CONVOLUTIONAL NETWORKS
+
+Our goal in this paper is to incorporate semantic knowledge into a Reinforcement Learning framework. To this end, we incorporate semantic knowledge in the form of graph representation and use Graph Convolutional Networks (GCNs) (Kipf & Welling, 2017) to compute relational features on the graph. GCNs allow us to incorporate prior knowledge and dynamically update it as the agent receives information specific to the current environment.
+
+We first briefly describe how we build a semantic knowledge graph to represent the priors. We then provide the background for GCNs. Finally, we delve into the details of how we incorporate GCNs for the task of visual semantic navigation and how it helps generalization to unseen scenes and novel object categories.
+
+# 4.1 KNOWLEDGE GRAPH CONSTRUCTION
+
+Our knowledge graph for visual navigation provides two main advantages: (1) It encodes spatial relationships between different object categories. (2) It provides the spatial and visual relationships between the known objects and novel categories in cases that we have not seen any visual examples of the novel categories.
+
+We denote our knowledge graph by $G = ( V , E )$ , where $V$ and $E$ denote the nodes and the edges between nodes, respectively. Specifically, each node $v \in V$ denotes an object category, and each edge $e \in E$ denotes a relationship between a pair of object categories.
+
+We use the Visual Genome (Krishna et al., 2017) dataset as a source to build the knowledge graph. Visual Genome consists of over 100K natural images. Each image is annotated with objects, attributes and the relationships between objects. Since there is no predefined object category list, the annotators are free to label any objects in the image, which results in very diverse object categories.
+
+In our experiments, we build the knowledge graph by including all object categories that appear in the AI2-THOR environment. Each object category is represented as a node in the graph. We count the occurrence of object-to-object relationships in the Visual Genome dataset. Two nodes are connected with an edge only when the occurrence frequency of any relationship is more than three. Some examples of the mined relationships are shown in Figure 3.
+
+# 4.2 INCORPORATING SEMANTIC KNOWLEDGE INTO ACTOR-CRITIC MODEL
+
+The baseline policy model decides the action using the current state and target object features. However, we want the policy network to incorporate semantic knowledge of the world when planning the actions. How do we represent the semantic knowledge? More importantly, how do we extract semantic knowledge in the context of the current environment and state?
+
+Our core idea is that the graph structure represents how the information propagates between different nodes. We initialize each node based on the current state (input scene image) and then perform information propagation to compute a semantic knowledge vector that is passed as another feature vector to the policy function. For information propagation, we use the recently proposed Graph Convolutional Network (GCN) (Kipf & Welling, 2017).
+
+![](images/1f2532148928edef404e9384660793c46dea3f02fd7532fb00f266aab3ee305f.jpg)  
+Figure 4: Graph Convolutional Networks. Each node denotes an object category and is initialized based on the the current state (image) and the word vector. We use three layers of GCN to perform information propagation. The first two layers output 1024-d latent features, and the last layer generates a single value for each node, which results in a $| V |$ dimensional semantic knowledge vector that is passed to the policy model.
+
+# 4.2.1 GRAPH CONVOLUTIONAL NETWORK (GCN)
+
+The GCNs are the extension of the Convolution Neural Networks to graph structures, where the goal is to learn a function representation for a given graph $G = ( V , E )$ . The input to each node $v$ is a feature vector $x _ { v }$ . We summarize the inputs of all nodes as a matrix $X = [ x _ { 1 } , \cdot \cdot \cdot , x _ { | V | } ] \in R ^ { | V | \times D }$ , where $D$ denotes the dimension of the input feature. The graph structure is represented as a binary adjacency matrix $A$ . We perform normalization on $A$ following (Kipf & Welling, 2017) and obtain $\widehat { A }$ . The GCN outputs a node-level representation $Z = [ z _ { 1 } , \cdots , z _ { | V | } ] \in R ^ { | V | \times F } ,$ . Let $f ( \cdot )$ denote the ReLU activation function, we have
+
+$$
+H ^ { ( l + 1 ) } = f ( \widehat { A } H ^ { ( l ) } W ^ { ( l ) } )
+$$
+
+with $H ^ { ( 0 ) } = X$ and $H ^ { ( L ) } = Z$ , where $W ^ { ( l ) }$ is the parameter for the $l$ -th layer and $L$ is the number of GCN layers.
+
+# 4.2.2 GCN FOR NAVIGATION
+
+In our visual semantic navigation task, the input of each node is designed as a joint representation of both the semantic cues (e.g., the word embedding) and the visual cues (e.g., the image classification score depending on the current state $s _ { t }$ ). Specifically, the word embedding is generated by fastText (Joulin et al., 2016) and the classification score is generated by a ResNet-50 (He et al., 2016) pretrained on the 1000-class ImageNet dataset. Note that the classification score is obtained based on the frame of the current state and we have different word embeddings for different graph nodes. These two representations are first mapped to 512-d features by two different fully connected layers respectively. We then concatenate these two features and form a 1024-d joint representation for each graph node.
+
+As illustrated in Figure 4, we use three layers of GCN, the first two layers output 1024 dimensional latent features, the last layer outputs a single value for each node which results in a $| V |$ dimensional feature vector. This feature vector is basically an encoding of semantic prior in the context of the current scene and environment.
+
+Finally, we map this feature vector into the 512-d feature embedding and concatenate it with the features generated from the visual and semantic branches (1024-d embedding), which results in a 1536-d feature vector. As illustrated in Figure 2, the joint feature is further fed into the policy network for policy prediction.
+
+# 5 EXPERIMENTS
+
+In this section, we provide the results of navigation using GCNs. We evaluate our model in scenarios where the scenes are unseen and/or the target objects are novel to the agent. We also provide ablation results that show the knowledge graph is useful.
+
+# 5.1 EVALUATION FRAMEWORK
+
+We evaluate our method in the interactive environments of AI2-THOR (Kolve et al., 2017). AI2- THOR provides 120 scenes covering four different room categories: kitchens, living rooms, bedrooms, and bathrooms. Each room category consists of 30 rooms with diverse appearance and configurations. We randomly split the scenes into three splits for each room category, i.e., 20 training rooms, 5 validation rooms, and 5 testing rooms.
+
+<table><tr><td colspan="2"></td><td>Kitchen</td><td>Living room</td><td>Bedroom</td><td>Bathroom</td><td>Avg.</td></tr><tr><td rowspan="3">Seen scenes, Known objects</td><td>Random</td><td>2.4/3.5</td><td>1.1/1.7</td><td>1.8/2.7</td><td>3.2/4.8</td><td>2.1/3.1</td></tr><tr><td>A3C</td><td>38.5 /51.0</td><td>9.7 /15.1</td><td>6.8 / 11.5</td><td>69.1/81.0</td><td>31.1/39.6</td></tr><tr><td>Ours</td><td>58.6 / 72.7</td><td>12.4 / 18.6</td><td>41.6 / 52.4</td><td>71.3 /83.0</td><td>46.0 / 56.7</td></tr><tr><td rowspan="3">Seen scenes, Novel objects</td><td>Random</td><td>0.9/1.3</td><td>0.8/1.2</td><td>2.3/3.4</td><td>1.4/2.1</td><td>1.4/2.0</td></tr><tr><td>A3C</td><td>2.1 /4.9</td><td>3.2 /4.8</td><td>0.5 / 1.7</td><td>17.1 / 28.5</td><td>5.7 /9.9</td></tr><tr><td>Ours</td><td>3.2 / 6.1</td><td>9.8 / 16.2</td><td>6.2 / 8.6</td><td>24.7 / 37.3</td><td>11.0 / 17.1</td></tr><tr><td rowspan="3">Unseen scenes, Known objects</td><td>Random</td><td>4.1/5.9</td><td>0.9/1.3</td><td>1.6/2.4</td><td>4.2/6.2</td><td>2.7/3.9</td></tr><tr><td>A3C</td><td>11.5 / 18.8</td><td>0.5 / 2.5</td><td>2.2/3.8</td><td>8.6/18.7</td><td>5.7 / 10.4</td></tr><tr><td>Ours</td><td>12.7 / 20.5</td><td>1.0 / 4.0</td><td>4.5 / 11.0</td><td>8.7 / 21.1</td><td>6.7 / 13.4</td></tr><tr><td>Unseen scenes,</td><td>Random</td><td>2.0/2.8</td><td>0.6/1.0</td><td>2.0/2.8</td><td>2.7/3.9</td><td>1.8 /2.6</td></tr><tr><td>Novel objects</td><td>A3C Ours</td><td>2.2 /7.5 3.3 / 12.7</td><td>2.5 /4.4 2.8 / 5.3</td><td>1.3 /4.4 2.0 / 6.3</td><td>3.4 /9.3 4.1 / 12.2</td><td>2.4 / 5.9 3.1/ 8.5</td></tr></table>
+
+Table 1: Results using termination (stop) action. SPL / Success rate $( \% )$ is shown. We compare against a random baseline and A3C (Mnih et al., 2016).
+
+There are 87 object categories within AI2-THOR that are common among the scenes. However, some of the objects are not visible without interaction. For example, spoons were not visible since they always appeared in closed drawers during random initialization of the scenes so we did not use spoon among our categories. Therefore, we have $| V | = 5 3$ categories based on their visibility at random initialization of the scenes. To test the generalization ability of our method on novel objects, we split the 53 object categories into known and novel sets. Only the known set of object categories are used in training. The full split of object categories is shown in Appendix A. We only use navigation commands of AI2-THOR for our experiments. These actions include: move forward, move back, rotate right, rotate left, and stop.
+
+We evaluate the models based on two metrics: Success Rate and the Success weighted by Path Length (SPL) metric recently proposed by Anderson et al. (2018a). Success Rate is defined as the ratio of the number of times the agent successfully navigates to the target and the total number of episodes. $S P L$ is a better metric which is a function considering both Success Rate and the path length to reach the goal from the starting point. It is defined as $\begin{array} { r } { \frac { \bar { 1 } } { N } \sum _ { i = 1 } ^ { N } S _ { i } \frac { L _ { i } } { \operatorname* { m a x } \left( P _ { i } , L _ { i } \right) } } \end{array}$ , where $N$ is the number of episodes, $S _ { i }$ is a binary indicator of success in episode $i$ , $P _ { i }$ represents path length and $L _ { i }$ is the shortest path distance (provided by the environment for evaluation) in episode $i$ .
+
+# 5.2 RESULTS
+
+We train each of the models three times with different random initializations. We show the training curves in Appendix B, where we plot the curves with error bands representing the standard deviation. The curves show that our proposed model converges in fewer training episodes compared to baseline and achieves better Success Rate as well as $S P L$ , which shows the effectiveness of scene priors.
+
+For evaluation, we run 250 episodes for each scene, where the initial location and orientation of the agent is randomized. The target object is randomly sampled for each episode. We select the models which perform best on the validation set for all methods and evaluate them on the test set.
+
+We compare the performance of the following models: (1) Random walk, which is the simplest baseline for navigation. The agent randomly samples an action from the action space at each step. (2) A3C (Mnih et al., 2016), which refers to the baseline model presented in Section 3.2. It is a state-of-the-art deep reinforcement learning model. (3) Ours, which is our proposed model. Each node of the first layer of GCNs is fed by a joint representation of the word embedding and the image classification scores extracted by ResNet-50, which depends on the current observed image.
+
+We analyze the generalization ability of our method for unseen scenes and novel objects. Specifically, there are three experimental settings: 1) test on seen scenes with novel object categories as the navigation target; 2) test on unseen scenes with known object categories; and 3) test on unseen scenes with novel object categories. Table 1 shows the results for these different settings. In addition to the above settings, we also provide the results for seen scenes and known objects in the first row of the table. Note that most previous work (e.g., Zhu et al. (2017)) assume the environment notifies the agent when it reaches the target, and the agent does not have any idea if it has reached the target or not. In contrast, we consider the stop action and expect the agent to issue this action when it reaches the target. As mentioned in Section 3.2, this makes the learning challenging. In Table 2, we report the results for the simpler case where we remove the “stop” action from the list of actions.
+
+<table><tr><td colspan="2"></td><td>Kitchen</td><td>Living room</td><td>Bedroom</td><td>Bathroom</td><td>Avg.</td></tr><tr><td rowspan="2">Seen scenes,</td><td>Random</td><td>17.9/33.1</td><td>12.1/30.5</td><td>16.8 / 51.2</td><td>24.5 /34.6</td><td>17.8/37.3</td></tr><tr><td>A3C</td><td>79.9 / 86.7</td><td>38.8 /57.6</td><td>87.8 /89.5</td><td>93.7 /96.6</td><td>75.0 / 82.5</td></tr><tr><td>Known objects</td><td>Ours</td><td>83.5 / 88.2</td><td>46.4 /64.4</td><td>90.6 /92.7</td><td>93.6 /96.5</td><td>78.5 / 85.5</td></tr><tr><td rowspan="2"> Seen scenes,</td><td>Random</td><td>10.0/23.1</td><td>8.0/18.5</td><td>17.3/35.2</td><td>11.2/32.2</td><td>11.6/ 27.2</td></tr><tr><td>A3C</td><td>20.2 /38.8</td><td>24.2 /46.5</td><td>23.5 / 35.8</td><td>50.2 / 74.6</td><td>29.5 /48.9</td></tr><tr><td rowspan="2">Novel objects Unseen scenes,</td><td>Ours</td><td>22.9 / 53.6</td><td>39.5 / 66.5</td><td>26.1 / 38.9</td><td>50.5 / 78.6</td><td>34.7 / 59.4</td></tr><tr><td>Random</td><td>27.3/45.2</td><td>5.6/16.6</td><td>13.1/ 34.5</td><td>36.0/49.1</td><td>20.5/36.3</td></tr><tr><td rowspan="2">Known objects</td><td>A3C</td><td>39.5 / 56.2</td><td>12.0 / 31.8</td><td>22.5 /49.2</td><td>47.4 / 60.2</td><td>30.3 / 49.3</td></tr><tr><td>Ours</td><td>46.2 / 62.5</td><td>13.8 / 40.6</td><td>26.5 / 58.6</td><td>51.5 / 65.8</td><td>34.5 / 56.9</td></tr><tr><td rowspan="2">Unseen scenes,</td><td>Random</td><td>21.3/44.3</td><td>3.3/22.9</td><td>25.8/47.8</td><td>25.5/48.9</td><td>19.0/41.0</td></tr><tr><td>A3C</td><td>26.1 /56.3</td><td>9.4 / 25.1</td><td>28.2 /54.0</td><td>33.8 /90.7</td><td>24.4 / 56.5</td></tr><tr><td>Novel objects</td><td>Ours</td><td>38.5 / 62.5</td><td>13.7 / 40.3</td><td>30.1 / 63.1</td><td>39.2 / 93.6</td><td>30.4 / 64.9</td></tr></table>
+
+Table 2: Results without termination (stop) action. SPL / Success rate $( \% )$ is shown. We compare against a random baseline and A3C. This scenario is simpler than the case shown in Table 1.
+
+Our method that incorporates the knowledge graph outperforms the baselines in terms of both success rate and SPL. We observe a higher performance for the case that we do not use a stop action (Table 2), which is expected. The scenario in which both scenes and target objects are novel is quite challenging, and the performance degrades drastically for both A3C and our method. However, the performance is significantly better than random. The bathroom scenes are typically small so there is not much difference between the performance of our method and the baseline. Note that more than half of the object categories are not among ImageNet categories. Also, note that “Unseen scenes, Novel objects” is not necessarily the hardest case. For instance, in “Seen scenes, Novel objects”, the appearance of the object and the mapping between the name and the object appearance are still unknown. We also observe overfitting to known scenes and objects (refer to “Seen scenes, Known objects”). So the results of different cases are not directly comparable, and it depends on the structure of the scenes and the configuration of objects. We show some qualitative examples in Appendix D, and the implementation details are provided in Appendix C.
+
+Generalization Across Scene Types. We evaluate generalization across scene types as well. The idea is that we train the model on one scene type and evaluate it on a different scene type. The result is close to random in the scenario with the termination action. This is expected since there are very few common objects among different scene categories. The result for the simpler case of without the termination action is shown in Table 3.
+
+<table><tr><td rowspan=2 colspan=2></td><td rowspan=1 colspan=4>Test type</td></tr><tr><td rowspan=1 colspan=1>Kitchen</td><td rowspan=1 colspan=1>Living room</td><td rowspan=1 colspan=1>Bedroom</td><td rowspan=1 colspan=1>Bathroom</td></tr><tr><td rowspan=4 colspan=1>Traintype</td><td rowspan=1 colspan=1>Kitchen</td><td rowspan=1 colspan=1>38.5/62.5</td><td rowspan=1 colspan=1>4.5/8.1</td><td rowspan=1 colspan=1>28.2/52.4</td><td rowspan=1 colspan=1>31.7/66.7</td></tr><tr><td rowspan=1 colspan=1>Living room</td><td rowspan=1 colspan=1>22.6/ 52.1</td><td rowspan=1 colspan=1>13.7/40.3</td><td rowspan=1 colspan=1>27.0/48.0</td><td rowspan=1 colspan=1>26.9/60.1</td></tr><tr><td rowspan=1 colspan=1>Bedroom</td><td rowspan=1 colspan=1>29.5/58.4</td><td rowspan=1 colspan=1>10.4 /30.1</td><td rowspan=1 colspan=1>30.1/ 63.1</td><td rowspan=1 colspan=1>28.0 /55.1</td></tr><tr><td rowspan=1 colspan=1>Bathroom</td><td rowspan=1 colspan=1>35.4/71.9</td><td rowspan=1 colspan=1>5.9/17.9</td><td rowspan=1 colspan=1>24.1/35.8</td><td rowspan=1 colspan=1>39.2/93.6</td></tr></table>
+
+Table 3: Results of generalization across scene types. SPL / Success rate $( \% )$ is shown.
+
+Ablations on Knowledge Graph. We perform evaluations on how the performance is affected by changing the knowledge graph in our model. The experiment is performed with the kitchen scenes without the “stop” action. We first remove different fractions of object nodes or relations from the graph and re-train the models. As shown in Table 4, the SPL performance drops as more information is removed from the knowledge graph. We also train our model with a fully-connected graph which leads to the SPL of 32.5 and the model with a random graph leads to the SPL of $3 0 . 1 \pm 0 . 6$ (we repeated this experiment three times). The performance of these two cases is worse than the performance of the model with a proper knowledge graph (38.5).
+
+Table 4: Results of removing objects and relations in the knowledge graph.   
+
+<table><tr><td rowspan=1 colspan=1>Drop %</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>80%</td></tr><tr><td rowspan=1 colspan=1>ObjectsRelations</td><td rowspan=1 colspan=1>38.538.5</td><td rowspan=1 colspan=1>34.836.7</td><td rowspan=1 colspan=1>33.735.0</td><td rowspan=1 colspan=1>33.534.2</td><td rowspan=1 colspan=1>31.131.5</td></tr></table>
+
+We have tried using the edge types (“on”, “next to”, etc.), but the results is not better than the case that we ignore the edge types. That is probably due to the lack of training data for each type separately. We have also tried training only one model for all scene categories, but the performance is lower.
+
+Computation Cost. It is worth mentioning that the GCN module in our model increases only 0.12 GFLOPs computation compared to the baseline $A 3 C$ $\sim 4$ GFLOPs), which is marginal.
+
+# 6 CONCLUSIONS
+
+We propose an approach to integrate semantic and functional priors with a deep reinforcement learning model for the task of navigation. We use Graph Convolutional Networks to encode the prior knowledge and to update the knowledge according to the observations from the current scene. Our experiments show that prior knowledge improves generalization to unseen scenes and targets.
+
+The current formulation of the problem does not include a long-term memory so in the future we plan to integrate memory to learn more complex exploration strategies. Incorporating higher-order relationships between objects and scenes is another future direction that we consider.
+
+Acknowledgements: This research is partly sponsored by Google Focused Award and the ARO under Grant Number W911NF-18-1-0019. Abhinav was supported in part by Okawa Foundation. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the ARO or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dandelion Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, ´ Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, ´ and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow.org/. Software available from tensorflow.org.   
+Peter Anderson, Angel X. Chang, Devendra Singh Chaplot, Alexey Dosovitskiy, Saurabh Gupta, Vladlen Koltun, Jana Kosecka, Jitendra Malik, Roozbeh Mottaghi, Manolis Savva, and Amir Roshan Zamir. On evaluation of embodied navigation agents. arXiv, 2018a.   
+Peter Anderson, Qi Wu, Damien Teney, Jake Bruce, Mark Johnson, Niko Sunderhauf, Ian Reid, Stephen Gould, ¨ and Anton van den Hengel. Vision-and-language navigation: Interpreting visually-grounded navigation instructions in real environments. In CVPR, 2018b.   
+Johann Borenstein and Yoram Koren. The vector field histogram and fast obstacle-avoidance for mobile robots. IEEE Trans. on Robotics and Automation, 1991.   
+Samarth Brahmbhatt and James Hays. Deepnav: Learning to navigate large cities. In CVPR, 2017.   
+Devendra Singh Chaplot, Kanthashree Mysore Sathyendra, Rama Kumar Pasumarthi, Dheeraj Rajagopal, and Ruslan Salakhutdinov. Gated-attention architectures for task-oriented language grounding. In AAAI, 2018.   
+Chenyi Chen, Ary Seff, Alain L. Kornhauser, and Jianxiong Xiao. Deepdriving: Learning affordance for direct perception in autonomous driving. In ICCV, 2015.   
+Chaitanya Desai, Deva Ramanan, and Charless. Fowlkes. Discriminative models for multi-class object layout. In ICCV, 2009.   
+Santosh Kumar Divvala, Derek Hoiem, James Hays, Alexei A. Efros, and Martial Hebert. An empirical study of context in object detection. In CVPR, 2009.   
+Hans Jacob S. Feder, John J. Leonard, and Christopher M. Smith. Adaptive mobile robot navigation and mapping. Intl. J. of Robotics Research, 1999.   
+Saurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. In CVPR, 2017.   
+James Harrison, Animesh Garg, Boris Ivanovic, Yuke Zhu, Silvio Savarese, Li Fei-Fei, and Marco Pavone. AdaPT: Zero-shot adaptive policy transfer for stochastic dynamical systems. In ISRR, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Karl Moritz Hermann, Felix Hill, Simon Green, Fumin Wang, Ryan Faulkner, Hubert Soyer, David Szepesvari, Wojciech Marian Czarnecki, Max Jaderberg, Denis Teplyashin, Marcus Wainwright, Chris Apps, Demis Hassabis, and Phil Blunsom. Grounded language learning in a simulated 3d world. arXiv, 2017.
+
+Irina Higgins, Arka Pal, Andrei Rusu, Loic Matthey, Christopher Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. In ICML, 2017.
+
+Derek Hoiem, Alexei A. Efros, and Martial Hebert. Geometric context from a single image. In ICCV, 2005.
+
+Ronghang Hu, Marcus Rohrbach, Jacob Andreas, Trevor Darrell, and Kate Saenko. Modeling relationships in referential expressions with compositional modular networks. In CVPR, 2017.
+
+Justin Johnson, Ranjay Krishna, Michael Stark, Jia Li, Michael Bernstein, and Li Fei-Fei. Image retrieval using scene graphs. In CVPR, 2015.
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In CVPR, 2017.
+
+Eagle S. Jones and Stefano Soatto. Visual-inertial navigation, mapping and localization: A scalable real-time causal approach. Intl. J. of Robotics Research, 2011.
+
+Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. Bag of tricks for efficient text classification. arXiv, 2016.
+
+Gregory Kahn, Adam Villaflor, Bosen Ding, Pieter Abbeel, and Sergey Levine. Self-supervised deep reinforcement learning with generalized computation graphs for robot navigation. In ICRA, 2018.
+
+Dongsung Kim and Ramakant Nevatia. Symbolic navigation with a generic map. Autonomous Robots, 1999.
+
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.
+
+Eric Kolve, Roozbeh Mottaghi, Daniel Gordon, Yuke Zhu, Abhinav Gupta, and Ali Farhadi. AI2-THOR: An Interactive 3D Environment for Visual AI. arXiv, 2017.
+
+Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A Shamma, et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. IJCV, 2017.
+
+Ruiyu Li, Makarand Tapaswi, Renjie Liao, Jiaya Jia, Raquel Urtasun, and Sanja Fidler. Situation recognition with graph neural networks. In ICCV, 2017.
+
+Tomasz Malisiewicz and Alexei A. Efros. Beyond categories: The visual memex model for reasoning about object relationships. In NIPS, 2009.
+
+Kenneth Marino, Ruslan Salakhutdinov, and Abhinav Gupta. The more you know: Using knowledge graphs for image classification. In CVPR, 2017.
+
+Marcin Marszalek, Ivan Laptev, and Cordelia Schmid. Actions in context. In CVPR, 2009.
+
+Larry H. Matthies and Steven A. Shafer. Error modeling in stereo navigation. IEEE J. Robotics and Automation, 1987.
+
+Hongyuan Mei, Mohit Bansal, and Matthew R. Walter. Listen, attend, and walk: Neural mapping of navigational instructions to action sequences. In AAAI, 2016.
+
+Min Meng and Avinash C. Kak. Neuro-nav: A neural network based architecture for vision-guided mobile robot navigation using non-metrical models of the environment. In ICRA, 1993.
+
+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.
+
+Dipendra Kumar Misra, John Langford, and Yoav Artzi. Mapping instructions and visual observations to actions with reinforcement learning. In EMNLP, 2017.
+
+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.
+
+Roozbeh Mottaghi, Xianjie Chen, Xiaobai Liu, Nam-Gyu Cho, Seong-Whan Lee, Sanja Fidler, Raquel Urtasun, and Alan Yuille. The role of context for object detection and semantic segmentation in the wild. In CVPR, 2014.
+
+Arsalan Mousavian, Alexander Toshev, Marek Fiser, Jana Kosecka, and James Davidson. Visual representations for semantic target driven navigation. In ECCV Workshop on Visual Learning and Embodied Agents in Simulation Environments, 2018.
+
+Varun K. Nagaraja, Vlad I. Morariu, and Larry S. Davis. Modeling context between objects for referring expression understanding. In ECCV, 2016.
+
+Junhyuk Oh, Satinder Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization with multi-task deep reinforcement learning. In ICML, 2017.
+
+Deepak Pathak, Parsa Mahmoudieh, Guanghao Luo, Pulkit Agrawal, Dian Chen, Fred Shentu, Evan Shelhamer, Jitendra Malik, Alexei A. Efros, and Trevor Darrell. Zero-shot visual imitation. In ICLR, 2018.
+
+Andrew Rabinovich, Andrea Vedaldi, Carolina Galleguillos, Eric Wiewiora, and Serge Belongie. Objects in context. In ICCV, 2005.
+
+Fereshteh Sadeghi and Sergey Levine. CAD2RL: real single-image flight without a single real image. In RSS, 2017.
+
+Nikolay Savinov, Alexey Dosovitskiy, and Vladlen Koltun. Semi-parametric topological memory for navigation. In ICLR, 2018.
+
+Abhinav Shrivastava and Abhinav Gupta. Contextual priming and feedback for faster r-cnn. In ECCV, 2016.
+
+Christian Siagian, Chin-Kai Chang, and Laurent Itti. Autonomous mobile robot localization and navigation using a hierarchical map representation primarily guided by vision. J. Field Robotics, 2014.
+
+Sebastian Thrun. Learning metric-topological maps for indoor mobile robot navigation. Artificial Intelligence, 1998.
+
+Tijmen Tieleman and Geoffrey Hinton. RMSprop gradient optimization. URL http://www.cs.toronto. edu/˜tijmen/csc321/slides/lecture_slides_lec6.pdf.
+
+Antonio Torralba, Kevin P. Murphy, William T. Freeman, and Mark A. Rubin. Context-based vision system for place and object recognition. In CVPR, 2003.
+
+Xiaolong Wang, Yufei Ye, and Abhinav Gupta. Zero-shot recognition via semantic embeddings and knowledge graphs. In CVPR, 2018.
+
+Yuxin Wu and Yuandong Tian. Training agent for first-person shooter game with actor-critic curriculum learning. In ICLR, 2017.
+
+Haonan Yu, Haichao Zhang, and Wei Xu. Interactive grounded language acquisition and generalization in a 2d world. In ICLR, 2018.
+
+Hanwang Zhang, Zawlin Kyaw, Shih-Fu Chang, and Tat-Seng Chua. Visual translation embedding network for visual relation detection. In CVPR, 2017.
+
+Yuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J Lim, Abhinav Gupta, Li Fei-Fei, and Ali Farhadi. Targetdriven visual navigation in indoor scenes using deep reinforcement learning. In ICRA, 2017.
+
+Yukun Zhu, Raquel Urtasun, Ruslan Salakhutdinov, and Sanja Fidler. segdeepm: Exploiting segmentation and context in deep neural networks for object detection. In CVPR, 2015.
+
+# APPENDIX A NAVIGATION TARGETS
+
+In Table 5, we show the object categories that are used as our navigation targets. The split of train and test categories is provided as well.
+
+<table><tr><td rowspan=1 colspan=1>Room type</td><td rowspan=1 colspan=1>Train objects</td><td rowspan=1 colspan=1>Test objects</td></tr><tr><td rowspan=1 colspan=1>Kitchen</td><td rowspan=1 colspan=1>HousePlant, StoveKnob,Sink, TableTop,Potato,Bread,Tomato,Knife,Cabinet, Fridge, Container, ButterKnife,Lettuce,Pan, Bowl, CoffeeMachine, StoveBurner,Plate</td><td rowspan=1 colspan=1>Mug，Apple,Microwave,Toaster</td></tr><tr><td rowspan=1 colspan=1>Living room</td><td rowspan=1 colspan=1>Television，HousePlant,Chair，TableTop，Box，Cloth,Newspaper, KeyChain,WateringCan,PaintingHanger</td><td rowspan=1 colspan=1>Painting,Statue</td></tr><tr><td rowspan=1 colspan=1>Bedroom</td><td rowspan=1 colspan=1>Painting,HousePlant, CellPhone,LightSwitch, Candle,TableTop,Bed, Lamp, Statue,Book, CreditCard,Key-Chain, Bowl, Pen,Box, Pencil,Blinds,Laptop,Alarm-Clock</td><td rowspan=1 colspan=1>Television,Mirror, Cabi-net</td></tr><tr><td rowspan=1 colspan=1>Bathroom</td><td rowspan=1 colspan=1>SprayBottle,Painting, Candle, LightSwitch, Sink, Cab-inet，TowelHolder，Watch，ToiletPaper，ShowerDoor,SoapBottle</td><td rowspan=1 colspan=1>SoapBar,Towel</td></tr></table>
+
+Table 5: Training and testing split of object categories for each scene type in the AI2-THOR.
+
+# APPENDIX B TRAINING CURVES
+
+We show the training curves in Figure 5. We compare our method with the baseline A3C. All the models are trained 3 times with different initializations. We compute the model performance with Success Rate and $S P L$ every 10 million iterations during training. We use the error band to represent the standard deviation. The curves show our model converges faster than the A3C baseline and obtain better performance in both metrics, which indicates the effectiveness of the scene priors.
+
+![](images/ab74b398c9a6c3af39d24431a836b6ee4e63a3a6235965d4c9b29043e53a006f.jpg)  
+Figure 5: Learning curves. The top row shows success rate and the bottom row shows SPL.
+
+# APPENDIX C IMPLEMENTATION DETAILS
+
+Our method is implemented in Tensorflow (Abadi et al., 2015) and the actor-critic policy network is trained with a single NVIDIA GeForce GTX Titan X GPU with 20 threads for 10 million frames for experiments without stop action, and for 25 million frames for experiments with stop action. The initial learning rate is set empirically as $7 e \mathrm { ~ - ~ } 4$ , and is decreased linearly as the training progresses. The network parameters are optimized by the RMSProp optimizer (Tieleman & Hinton). The maximum number of steps is set to 100 for kitchen, bedroom and bathroom, and to 200 for living room due to the larger exploration space. Since there is almost no overlap between object categories within different room types, we train separate models for each room type.
+
+# APPENDIX D QUALITATIVE RESULTS
+
+![](images/a655395377b04900bdf2b9f6bd673d9880454c4785fc532037d286c108141623.jpg)  
+Figure 6: Qualitative results. Examples of last eight frames and the corresponding actions $a _ { t }$ predicted from our model on unseen scenes with novel target objects.

parse/train/HJeRkh05Km/HJeRkh05Km_content_list.json

@@ -0,0 +1,1550 @@
+[
+    {
+        "type": "text",
+        "text": "VISUAL SEMANTIC NAVIGATION USING SCENE PRIORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            650,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wei Yang1, Xiaolong Wang2, Ali Farhadi4,5, Abhinav Gupta2,3, Roozbeh Mottaghi5 1 The Chinese University of Hong Kong 2 Carnegie Mellon University 3 Facebook AI Research 4 University of Washington 5 Allen Institute for AI ",
+        "bbox": [
+            183,
+            169,
+            810,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/db7d2da001c9a1d9b7e1da8619686d0e4d5bec0baf0cfc67a499d5b53445191a.jpg",
+        "image_caption": [
+            "Figure 1: Our goal is to use scene priors to improve navigation in unseen scenes and towards novel objects. (a) There is no mug in the field of view of the agent, but the likely location for finding a mug is the cabinet near the coffee machine. (b) The agent has not seen a mango before, but it infers that the most likely location for finding a mango is the fridge since similar objects such as apple appear there as well. The most likely locations are shown with the orange box. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            257,
+            820,
+            411
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            518,
+            544,
+            534
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "How do humans navigate to target objects in novel scenes? Do we use the semantic/functional priors we have built over years to efficiently search and navigate? For example, to search for mugs, we search cabinets near the coffee machine and for fruits we try the fridge. In this work, we focus on incorporating semantic priors in the task of semantic navigation. We propose to use Graph Convolutional Networks for incorporating the prior knowledge into a deep reinforcement learning framework. The agent uses the features from the knowledge graph to predict the actions. For evaluation, we use the AI2-THOR framework. Our experiments show how semantic knowledge improves performance significantly. More importantly, we show improvement in generalization to unseen scenes and/or objects. ",
+        "bbox": [
+            233,
+            550,
+            766,
+            689
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            717,
+            334,
+            733
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Consider the kitchen scene shown in Figure 1(a) and the task of finding an object such as a mug. Even though we have never seen this particular kitchen before and no mug is visible in the scene, we can still infer the likely locations to find the mug and create an exploration plan accordingly. For example, in Figure 1(a), we can infer that since there is a coffee machine, the mug is most likely in the cabinet near the coffee machine. How do we do that? We infer that mugs are usually used for coffee. And since there is a coffee machine, the mug is likely to be near the machine due to functional efficiency. We argue that humans use strong priors about the functional and semantic structure of the world to develop such efficient navigation strategies. And how do we learn such functional/semantic priors? Our prior experience and exploration of tens of kitchens help us to learn these priors. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "But these priors are not just used for navigating to known objects but also to completely unknown and unseen objects. For example, let us assume you have never seen a mango before and someone gives you a task of finding a mango in a new kitchen you have never seen before (let’s say Figure 1(b)). How would you do it? Assuming you have searched for fruits like apples and grapes before, and you know mango is also a fruit; so a similar exploration strategy might apply. Therefore, in Figure 1(b), you are more likely to navigate to the fridge to search for a mango. Therefore, we use the semantic/functional priors to navigate to unseen objects as well. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Inspired by these observations, in this paper, we explore how to exploit semantic priors for the task of semantic and goal-oriented navigation. In our visual navigation task, the environment, the path to the target, the target location, or the exact appearance of the target object can be unknown. The prior knowledge about the semantic/functional structure of the world helps to improve the navigation. We propose to use Graph Convolutional Networks (GCNs) (Kipf & Welling, 2017) to incorporate the prior knowledge into a Deep Reinforcement Learning framework. The knowledge of the agent is encoded in a graph. GCNs allow arbitrary structured graphs to be encoded in an efficient way. The knowledge is updated according to the current observation of the agent, which is specific to the current environment, and the knowledge at the previous time step or the prior knowledge. The prior knowledge is obtained from large-scale datasets designed for scene understanding. Our model is based on the actor-critic model (Mnih et al., 2016) that is augmented by the knowledge graph and object visibility information. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our model, we use the AI2-THOR framework (Kolve et al., 2017), which provides near photo-realistic customizable environments. The agent can take navigation actions in these environments and observe the changes as a result of those actions. AI2-THOR includes various objects that can be arranged in many different configurations. The agent location is randomized as well at each episode of training or testing. Our experiments show that the semantic prior improves the performance of the baseline RL models significantly. Furthermore, we show the results of the model on the challenging setting where the scene and/or the object are new to the agent. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are summarized as follows: (1) We integrate a deep reinforcement learning model with knowledge graphs. This allows the agent to encode any form of knowledge that can be represented by graph structures. (2) We show that semantic prior knowledge can significantly improve the navigation performance. (3) By considering the prior information and the semantics of the target objects, we improve generalization to unseen environments and novel target objects. ",
+        "bbox": [
+            174,
+            458,
+            823,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            344,
+            570
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Semantic and goal-oriented navigation is one of the most prominent tasks that intelligent species perform in their daily life. There are several challenges involved in visual navigation. First, the environment might be unknown to the agent. In this situation, the agent requires to explore the environment to have a better understanding of that environment. The second challenge is about the visibility of target objects. The target object might not be visible when the agent starts the navigation or it might go out of the field of view during navigation. Hence, the agent needs to learn an efficient search strategy to find the target object. The third challenge is related to planning. The object might be visible but planning a reasonable path towards the object is another issue that the agent needs to deal with. There have been several efforts in the past to tackle these challenges which we describe below. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            728
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Geometry-based navigation. Navigation methods can be divided into two main categories of geometry-based and learning-based. Most of the traditional navigation approaches fall into the former category, where it is assumed that either the map of the environment is known a priori, e.g., Matthies & Shafer (1987); Borenstein & Koren (1991); Meng & Kak (1993); Kim & Nevatia (1999) or a map is built on the fly e.g., Thrun (1998); Feder et al. (1999); Jones & Soatto (2011); Siagian et al. (2014). Our work is different from these approaches since we do not rely on a map for our navigation and we leverage semantic prior knowledge to reduce the required exploration time. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning-based navigation. Recent success of deep learning and reinforcement learning has made learning-based navigation approaches more popular. Zhu et al. (2017) propose a deep RL-based navigation approach, where they provide the picture of the target object. In contrast, we only provide semantic labels to the agent, so we can show generalization to unseen scenes. Gupta et al. (2017) propose a mapper and planner to output navigation actions. Mirowski et al. (2017) also propose a navigation framework that optimizes a loss for auxiliary tasks such as depth prediction and loop closure classification. Sadeghi & Levine (2017) propose an RL-based approach for collision avoidance. Brahmbhatt & Hays (2017) explore a CNN-based approach for navigating in cities using local observations of the streets. Wu & Tian (2017) combine deep RL with curriculum learning in a first-person shooting game setting. Savinov et al. (2018) introduce a topological landmark-based memory for navigation. Kahn et al. (2018) propose a method based on model-free and model-based RL to learn navigation policies using a few samples. Mousavian et al. (2018) use object detection and semantic segmentation to better navigate in unseen environments. Chen et al. (2015) directly map the input image to an action in an autonomous driving setting. There is also a large body of work that address visually grounded navigation instructions e.g., Anderson et al. (2018b); Chaplot et al. (2018); Hermann et al. (2017); Yu et al. (2018); Misra et al. (2017); Mei et al. (2016). In contrast to all these approaches, we incorporate semantic and functional priors to improve navigation performance and better generalize to unseen scenes and objects. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Context and scene prior. Contextual reasoning has been studied extensively in the computer vision literature (Torralba et al., 2003; Hoiem et al., 2005; Rabinovich et al., 2005; Divvala et al., 2009; Desai et al., 2009; Marszalek et al., 2009; Malisiewicz & Efros, 2009; Mottaghi et al., 2014; Zhu et al., 2015; Shrivastava & Gupta, 2016). However, contextual information is mainly used for static settings such as object detection, semantic segmentation or action recognition. We use contextual reasoning for an interactive navigation task, where the agent updates its belief based on the current observation and the prior knowledge as it moves in the environment. Object relationships have been used for tasks such as image retrieval (Johnson et al., 2015), visual relation detection (Zhang et al., 2017), referring expressions (Nagaraja et al., 2016; Hu et al., 2017), and visual question answering (Johnson et al., 2017). ",
+        "bbox": [
+            174,
+            277,
+            825,
+            416
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Knowledge graphs. There are recent works that use knowledge graphs for computer vision problems. A knowledge graph is used by Marino et al. (2017) for image classification, by Li et al. (2017) for situation recognition and by Wang et al. (2018) for zero-shot recognition. We use knowledge graphs in an RL setting for the interactive task of visual navigation. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Reasoning about unknown environments or objects. Various works have explored zero-shot reasoning in the context of reinforcement learning. Yu et al. (2018) address the problem of learning language in a 2D maze, where they can handle unseen word combinations or new sentences that contain unseen words. Harrison et al. (2017); Higgins et al. (2017) study zero-shot policy transfer in the scenarios that the dynamics or the states of the target domain is different from those of the source domain. Pathak et al. (2018) propose a zero-shot imitation learning approach where the expert demonstration for a particular task is never seen. Oh et al. (2017) address generalization of RL to unseen instructions and longer instructions. Our problem is different since we address navigation to novel objects or navigating in unseen scenes using scene priors. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 VISUAL SEMANTIC NAVIGATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            631,
+            477,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first define the task of visual semantic navigation. We then describe the formulation using deep reinforcement learning and the baseline model for the task. ",
+        "bbox": [
+            173,
+            661,
+            823,
+            689
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 TASK DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            339,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to navigate from a random starting location in a scene to a specified target object category given only egocentric RGB perception of the agent. The target object category is specified by a semantic label, thus we call our task visual semantic navigation. The task is considered successful if an instance of the target object category is visible. By “visible”, we mean the target object is in the field of view and within a threshold of distance. ",
+        "bbox": [
+            174,
+            732,
+            823,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 THE BASELINE MODEL",
+        "text_level": 1,
+        "bbox": [
+            176,
+            818,
+            377,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We formulate the visual semantic navigation using a deep reinforcement learning framework. Given a semantic task objective $g$ , the agent perceives a state $s _ { t }$ (i.e., the egocentric RGB image from the current location and orientation) at the time step $t$ and samples an action $a _ { t }$ from the set of possible actions $\\mathcal { A }$ according to its policy $\\pi$ . We approximate the policy by a deep policy network $\\pi ( \\cdot ; \\theta )$ : ",
+        "bbox": [
+            174,
+            844,
+            823,
+            901
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72a016a9bc03c444cb6dfbb276f90060e326da9f31f22bab6130c9233f8f1a9f.jpg",
+        "text": "$$\na _ { t } \\sim \\pi ( \\phi ( s _ { t } ; u ) , \\psi ( g ; v ) ; \\theta ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            904,
+            591,
+            921
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/18ddf835a05881d267abcdd22f7f41104bb2f3eeede453ab7d3bdd0ec04fe5ff.jpg",
+        "image_caption": [
+            "Figure 2: Overview of the architecture. Our model to incorporate semantic knowledge into semantic navigation. Specifically, we learn a policy network that decides an action based on the visual features of the current state, the semantic target category feature and the features extracted from the knowledge graph. We extract features from the parts of the knowledge graph that are activated. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            99,
+            797,
+            316
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $u , v$ , and $\\theta$ are the parameters for the network. Since the visual state and the semantic objective are from different modalities, we design two branches of subnetworks $\\phi ( \\cdot ; u )$ and $\\psi ( \\cdot ; v )$ to map these two inputs into a joint visual-semantic feature embedding. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Visual network. As illustrated in Figure 2 (top), the visual network takes $2 2 4 \\times 2 2 4$ RGB images as input and generates a 512-d feature vector as output. The backbone of the visual branch is ResNet50 (He et al., 2016) pre-trained on ImageNet. Specifically, we extract the 2048-d feature after the global average pooling of ResNet-50. To account for the history of the actions taken by the agent, we concatenate the features of the current frame and three past observations, which results in a 8192-d feature vector. We then add a fully connected layer and a ReLU layer to map the concatenated image feature into the 512-d visual-semantic feature. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Semantic network. The semantic task objective is described by an object category, e.g., Microwave or Television. We use fastText (Joulin et al., 2016) to compute a 100-d embedding for each word. Then we map the word embedding into a 512-d feature by a fully connected layer and ReLU, as illustrated in Figure 2 (middle). ",
+        "bbox": [
+            174,
+            554,
+            825,
+            611
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Actor-Critic policy network. We employ the Asynchronous Advantage Actor-Critic (A3C) (Mnih et al., 2016) model to predict the policy at each time step. The input of our A3C model is the joint representation of the current state and the semantic task objective, which is a 1024-d feature vector made by concatenating the outputs of the visual network and the semantic network. The A3C model generates two outputs, i.e., the policy and the value. We sample the action from the predicted policy. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            688
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our implementation of the A3C model consists of three layers: the input, the hidden layer, and the outputs. The hidden layer is a fully connected layer followed by the ReLU activation layer which maps the fused input into a 512-d latent space. Then the $| { \\cal A } |$ dimensional policy and the value are generated by two branches of network, as shown in Figure 2. Unlike previous work (e.g., Zhu et al. (2017)) which uses different policy networks for different scenes, we use a single policy network for different scene examples. This makes our model more compact and generalizable. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Reward. We consider a reward to minimize the trajectory length to the targets: If any object instance from the target object category is reached within a certain number of steps, the agent receives a large positive reward 10.0. Otherwise, we penalize each step with a small negative reward -0.01. The design of the reward function is also affected by the types of actions $\\mathcal { A }$ . In our experiments, we ablate two sets of actions $\\mathcal { A }$ with or without the stop action. In the setting without the stop action, the agent will receive the positive reward if the environment notifies it when it reaches the target, which also ends an episode of training. In the setting with the stop action, the episode is terminated when the stop action is executed, and the positive reward will be provided only if the agent is within the threshold of distance from the target (1 meter in our experiments) and facing the target. This makes the task much more challenging. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/84f6b507c7d4337107b30bd248faf33b2ec5e3752b2f2033ccf289176aa6ab1e.jpg",
+        "image_caption": [
+            "Figure 3: Scene priors. We extract relationships between objects from the Visual Genome (Krishna et al., 2017) dataset. The relationships for two example object categories are illustrated. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            88,
+            730,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 GENERALIZATION WITH GRAPH CONVOLUTIONAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            309,
+            728,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our goal in this paper is to incorporate semantic knowledge into a Reinforcement Learning framework. To this end, we incorporate semantic knowledge in the form of graph representation and use Graph Convolutional Networks (GCNs) (Kipf & Welling, 2017) to compute relational features on the graph. GCNs allow us to incorporate prior knowledge and dynamically update it as the agent receives information specific to the current environment. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            406
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first briefly describe how we build a semantic knowledge graph to represent the priors. We then provide the background for GCNs. Finally, we delve into the details of how we incorporate GCNs for the task of visual semantic navigation and how it helps generalization to unseen scenes and novel object categories. ",
+        "bbox": [
+            176,
+            414,
+            825,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 KNOWLEDGE GRAPH CONSTRUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            486,
+            477,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our knowledge graph for visual navigation provides two main advantages: (1) It encodes spatial relationships between different object categories. (2) It provides the spatial and visual relationships between the known objects and novel categories in cases that we have not seen any visual examples of the novel categories. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            564
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We denote our knowledge graph by $G = ( V , E )$ , where $V$ and $E$ denote the nodes and the edges between nodes, respectively. Specifically, each node $v \\in V$ denotes an object category, and each edge $e \\in E$ denotes a relationship between a pair of object categories. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            613
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the Visual Genome (Krishna et al., 2017) dataset as a source to build the knowledge graph. Visual Genome consists of over 100K natural images. Each image is annotated with objects, attributes and the relationships between objects. Since there is no predefined object category list, the annotators are free to label any objects in the image, which results in very diverse object categories. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we build the knowledge graph by including all object categories that appear in the AI2-THOR environment. Each object category is represented as a node in the graph. We count the occurrence of object-to-object relationships in the Visual Genome dataset. Two nodes are connected with an edge only when the occurrence frequency of any relationship is more than three. Some examples of the mined relationships are shown in Figure 3. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 INCORPORATING SEMANTIC KNOWLEDGE INTO ACTOR-CRITIC MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            770,
+            710,
+            784
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The baseline policy model decides the action using the current state and target object features. However, we want the policy network to incorporate semantic knowledge of the world when planning the actions. How do we represent the semantic knowledge? More importantly, how do we extract semantic knowledge in the context of the current environment and state? ",
+        "bbox": [
+            174,
+            791,
+            825,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our core idea is that the graph structure represents how the information propagates between different nodes. We initialize each node based on the current state (input scene image) and then perform information propagation to compute a semantic knowledge vector that is passed as another feature vector to the policy function. For information propagation, we use the recently proposed Graph Convolutional Network (GCN) (Kipf & Welling, 2017). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/1f2532148928edef404e9384660793c46dea3f02fd7532fb00f266aab3ee305f.jpg",
+        "image_caption": [
+            "Figure 4: Graph Convolutional Networks. Each node denotes an object category and is initialized based on the the current state (image) and the word vector. We use three layers of GCN to perform information propagation. The first two layers output 1024-d latent features, and the last layer generates a single value for each node, which results in a $| V |$ dimensional semantic knowledge vector that is passed to the policy model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            83,
+            821,
+            167
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 GRAPH CONVOLUTIONAL NETWORK (GCN) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            539,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The GCNs are the extension of the Convolution Neural Networks to graph structures, where the goal is to learn a function representation for a given graph $G = ( V , E )$ . The input to each node $v$ is a feature vector $x _ { v }$ . We summarize the inputs of all nodes as a matrix $X = [ x _ { 1 } , \\cdot \\cdot \\cdot , x _ { | V | } ] \\in R ^ { | V | \\times D }$ , where $D$ denotes the dimension of the input feature. The graph structure is represented as a binary adjacency matrix $A$ . We perform normalization on $A$ following (Kipf & Welling, 2017) and obtain $\\widehat { A }$ . The GCN outputs a node-level representation $Z = [ z _ { 1 } , \\cdots , z _ { | V | } ] \\in R ^ { | V | \\times F } ,$ . Let $f ( \\cdot )$ denote the ReLU activation function, we have ",
+        "bbox": [
+            173,
+            285,
+            825,
+            387
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0c504d313317c7f1decd9888fe70de17fd4559b13e1ff1484ce1ec9bc4cb65a0.jpg",
+        "text": "$$\nH ^ { ( l + 1 ) } = f ( \\widehat { A } H ^ { ( l ) } W ^ { ( l ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            392,
+            584,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "with $H ^ { ( 0 ) } = X$ and $H ^ { ( L ) } = Z$ , where $W ^ { ( l ) }$ is the parameter for the $l$ -th layer and $L$ is the number of GCN layers. ",
+        "bbox": [
+            176,
+            419,
+            825,
+            449
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2.2 GCN FOR NAVIGATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            464,
+            390,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our visual semantic navigation task, the input of each node is designed as a joint representation of both the semantic cues (e.g., the word embedding) and the visual cues (e.g., the image classification score depending on the current state $s _ { t }$ ). Specifically, the word embedding is generated by fastText (Joulin et al., 2016) and the classification score is generated by a ResNet-50 (He et al., 2016) pretrained on the 1000-class ImageNet dataset. Note that the classification score is obtained based on the frame of the current state and we have different word embeddings for different graph nodes. These two representations are first mapped to 512-d features by two different fully connected layers respectively. We then concatenate these two features and form a 1024-d joint representation for each graph node. ",
+        "bbox": [
+            173,
+            483,
+            825,
+            609
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As illustrated in Figure 4, we use three layers of GCN, the first two layers output 1024 dimensional latent features, the last layer outputs a single value for each node which results in a $| V |$ dimensional feature vector. This feature vector is basically an encoding of semantic prior in the context of the current scene and environment. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            672
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, we map this feature vector into the 512-d feature embedding and concatenate it with the features generated from the visual and semantic branches (1024-d embedding), which results in a 1536-d feature vector. As illustrated in Figure 2, the joint feature is further fed into the policy network for policy prediction. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            328,
+            767
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide the results of navigation using GCNs. We evaluate our model in scenarios where the scenes are unseen and/or the target objects are novel to the agent. We also provide ablation results that show the knowledge graph is useful. ",
+        "bbox": [
+            176,
+            777,
+            823,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 EVALUATION FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            833,
+            403,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method in the interactive environments of AI2-THOR (Kolve et al., 2017). AI2- THOR provides 120 scenes covering four different room categories: kitchens, living rooms, bedrooms, and bathrooms. Each room category consists of 30 rooms with diverse appearance and configurations. We randomly split the scenes into three splits for each room category, i.e., 20 training rooms, 5 validation rooms, and 5 testing rooms. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/c0ea08638519f60dfef106e4c743f08361fa3717c45a7d4e844c06ea5249361b.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Results using termination (stop) action. SPL / Success rate $( \\% )$ is shown. We compare against a random baseline and A3C (Mnih et al., 2016). "
+        ],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td>Kitchen</td><td>Living room</td><td>Bedroom</td><td>Bathroom</td><td>Avg.</td></tr><tr><td rowspan=\"3\">Seen scenes, Known objects</td><td>Random</td><td>2.4/3.5</td><td>1.1/1.7</td><td>1.8/2.7</td><td>3.2/4.8</td><td>2.1/3.1</td></tr><tr><td>A3C</td><td>38.5 /51.0</td><td>9.7 /15.1</td><td>6.8 / 11.5</td><td>69.1/81.0</td><td>31.1/39.6</td></tr><tr><td>Ours</td><td>58.6 / 72.7</td><td>12.4 / 18.6</td><td>41.6 / 52.4</td><td>71.3 /83.0</td><td>46.0 / 56.7</td></tr><tr><td rowspan=\"3\">Seen scenes, Novel objects</td><td>Random</td><td>0.9/1.3</td><td>0.8/1.2</td><td>2.3/3.4</td><td>1.4/2.1</td><td>1.4/2.0</td></tr><tr><td>A3C</td><td>2.1 /4.9</td><td>3.2 /4.8</td><td>0.5 / 1.7</td><td>17.1 / 28.5</td><td>5.7 /9.9</td></tr><tr><td>Ours</td><td>3.2 / 6.1</td><td>9.8 / 16.2</td><td>6.2 / 8.6</td><td>24.7 / 37.3</td><td>11.0 / 17.1</td></tr><tr><td rowspan=\"3\">Unseen scenes, Known objects</td><td>Random</td><td>4.1/5.9</td><td>0.9/1.3</td><td>1.6/2.4</td><td>4.2/6.2</td><td>2.7/3.9</td></tr><tr><td>A3C</td><td>11.5 / 18.8</td><td>0.5 / 2.5</td><td>2.2/3.8</td><td>8.6/18.7</td><td>5.7 / 10.4</td></tr><tr><td>Ours</td><td>12.7 / 20.5</td><td>1.0 / 4.0</td><td>4.5 / 11.0</td><td>8.7 / 21.1</td><td>6.7 / 13.4</td></tr><tr><td>Unseen scenes,</td><td>Random</td><td>2.0/2.8</td><td>0.6/1.0</td><td>2.0/2.8</td><td>2.7/3.9</td><td>1.8 /2.6</td></tr><tr><td>Novel objects</td><td>A3C Ours</td><td>2.2 /7.5 3.3 / 12.7</td><td>2.5 /4.4 2.8 / 5.3</td><td>1.3 /4.4 2.0 / 6.3</td><td>3.4 /9.3 4.1 / 12.2</td><td>2.4 / 5.9 3.1/ 8.5</td></tr></table>",
+        "bbox": [
+            197,
+            87,
+            795,
+            271
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There are 87 object categories within AI2-THOR that are common among the scenes. However, some of the objects are not visible without interaction. For example, spoons were not visible since they always appeared in closed drawers during random initialization of the scenes so we did not use spoon among our categories. Therefore, we have $| V | = 5 3$ categories based on their visibility at random initialization of the scenes. To test the generalization ability of our method on novel objects, we split the 53 object categories into known and novel sets. Only the known set of object categories are used in training. The full split of object categories is shown in Appendix A. We only use navigation commands of AI2-THOR for our experiments. These actions include: move forward, move back, rotate right, rotate left, and stop. ",
+        "bbox": [
+            173,
+            316,
+            825,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the models based on two metrics: Success Rate and the Success weighted by Path Length (SPL) metric recently proposed by Anderson et al. (2018a). Success Rate is defined as the ratio of the number of times the agent successfully navigates to the target and the total number of episodes. $S P L$ is a better metric which is a function considering both Success Rate and the path length to reach the goal from the starting point. It is defined as $\\begin{array} { r } { \\frac { \\bar { 1 } } { N } \\sum _ { i = 1 } ^ { N } S _ { i } \\frac { L _ { i } } { \\operatorname* { m a x } \\left( P _ { i } , L _ { i } \\right) } } \\end{array}$ , where $N$ is the number of episodes, $S _ { i }$ is a binary indicator of success in episode $i$ , $P _ { i }$ represents path length and $L _ { i }$ is the shortest path distance (provided by the environment for evaluation) in episode $i$ . ",
+        "bbox": [
+            174,
+            449,
+            825,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            560,
+            279,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We train each of the models three times with different random initializations. We show the training curves in Appendix B, where we plot the curves with error bands representing the standard deviation. The curves show that our proposed model converges in fewer training episodes compared to baseline and achieves better Success Rate as well as $S P L$ , which shows the effectiveness of scene priors. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For evaluation, we run 250 episodes for each scene, where the initial location and orientation of the agent is randomized. The target object is randomly sampled for each episode. We select the models which perform best on the validation set for all methods and evaluate them on the test set. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            686
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare the performance of the following models: (1) Random walk, which is the simplest baseline for navigation. The agent randomly samples an action from the action space at each step. (2) A3C (Mnih et al., 2016), which refers to the baseline model presented in Section 3.2. It is a state-of-the-art deep reinforcement learning model. (3) Ours, which is our proposed model. Each node of the first layer of GCNs is fed by a joint representation of the word embedding and the image classification scores extracted by ResNet-50, which depends on the current observed image. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We analyze the generalization ability of our method for unseen scenes and novel objects. Specifically, there are three experimental settings: 1) test on seen scenes with novel object categories as the navigation target; 2) test on unseen scenes with known object categories; and 3) test on unseen scenes with novel object categories. Table 1 shows the results for these different settings. In addition to the above settings, we also provide the results for seen scenes and known objects in the first row of the table. Note that most previous work (e.g., Zhu et al. (2017)) assume the environment notifies the agent when it reaches the target, and the agent does not have any idea if it has reached the target or not. In contrast, we consider the stop action and expect the agent to issue this action when it reaches the target. As mentioned in Section 3.2, this makes the learning challenging. In Table 2, we report the results for the simpler case where we remove the “stop” action from the list of actions. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/97786490843d3fa4a995a002f54027188e9d1029edbd73bc6422b343e3f819d8.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Results without termination (stop) action. SPL / Success rate $( \\% )$ is shown. We compare against a random baseline and A3C. This scenario is simpler than the case shown in Table 1. "
+        ],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td>Kitchen</td><td>Living room</td><td>Bedroom</td><td>Bathroom</td><td>Avg.</td></tr><tr><td rowspan=\"2\">Seen scenes,</td><td>Random</td><td>17.9/33.1</td><td>12.1/30.5</td><td>16.8 / 51.2</td><td>24.5 /34.6</td><td>17.8/37.3</td></tr><tr><td>A3C</td><td>79.9 / 86.7</td><td>38.8 /57.6</td><td>87.8 /89.5</td><td>93.7 /96.6</td><td>75.0 / 82.5</td></tr><tr><td>Known objects</td><td>Ours</td><td>83.5 / 88.2</td><td>46.4 /64.4</td><td>90.6 /92.7</td><td>93.6 /96.5</td><td>78.5 / 85.5</td></tr><tr><td rowspan=\"2\"> Seen scenes,</td><td>Random</td><td>10.0/23.1</td><td>8.0/18.5</td><td>17.3/35.2</td><td>11.2/32.2</td><td>11.6/ 27.2</td></tr><tr><td>A3C</td><td>20.2 /38.8</td><td>24.2 /46.5</td><td>23.5 / 35.8</td><td>50.2 / 74.6</td><td>29.5 /48.9</td></tr><tr><td rowspan=\"2\">Novel objects Unseen scenes,</td><td>Ours</td><td>22.9 / 53.6</td><td>39.5 / 66.5</td><td>26.1 / 38.9</td><td>50.5 / 78.6</td><td>34.7 / 59.4</td></tr><tr><td>Random</td><td>27.3/45.2</td><td>5.6/16.6</td><td>13.1/ 34.5</td><td>36.0/49.1</td><td>20.5/36.3</td></tr><tr><td rowspan=\"2\">Known objects</td><td>A3C</td><td>39.5 / 56.2</td><td>12.0 / 31.8</td><td>22.5 /49.2</td><td>47.4 / 60.2</td><td>30.3 / 49.3</td></tr><tr><td>Ours</td><td>46.2 / 62.5</td><td>13.8 / 40.6</td><td>26.5 / 58.6</td><td>51.5 / 65.8</td><td>34.5 / 56.9</td></tr><tr><td rowspan=\"2\">Unseen scenes,</td><td>Random</td><td>21.3/44.3</td><td>3.3/22.9</td><td>25.8/47.8</td><td>25.5/48.9</td><td>19.0/41.0</td></tr><tr><td>A3C</td><td>26.1 /56.3</td><td>9.4 / 25.1</td><td>28.2 /54.0</td><td>33.8 /90.7</td><td>24.4 / 56.5</td></tr><tr><td>Novel objects</td><td>Ours</td><td>38.5 / 62.5</td><td>13.7 / 40.3</td><td>30.1 / 63.1</td><td>39.2 / 93.6</td><td>30.4 / 64.9</td></tr></table>",
+        "bbox": [
+            186,
+            83,
+            808,
+            268
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our method that incorporates the knowledge graph outperforms the baselines in terms of both success rate and SPL. We observe a higher performance for the case that we do not use a stop action (Table 2), which is expected. The scenario in which both scenes and target objects are novel is quite challenging, and the performance degrades drastically for both A3C and our method. However, the performance is significantly better than random. The bathroom scenes are typically small so there is not much difference between the performance of our method and the baseline. Note that more than half of the object categories are not among ImageNet categories. Also, note that “Unseen scenes, Novel objects” is not necessarily the hardest case. For instance, in “Seen scenes, Novel objects”, the appearance of the object and the mapping between the name and the object appearance are still unknown. We also observe overfitting to known scenes and objects (refer to “Seen scenes, Known objects”). So the results of different cases are not directly comparable, and it depends on the structure of the scenes and the configuration of objects. We show some qualitative examples in Appendix D, and the implementation details are provided in Appendix C. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generalization Across Scene Types. We evaluate generalization across scene types as well. The idea is that we train the model on one scene type and evaluate it on a different scene type. The result is close to random in the scenario with the termination action. This is expected since there are very few common objects among different scene categories. The result for the simpler case of without the termination action is shown in Table 3. ",
+        "bbox": [
+            174,
+            497,
+            823,
+            566
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/294313f588a3c4e9ce9b73e5218ceb7dfe946eafadf6543d49dedef61bcd8a25.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Results of generalization across scene types. SPL / Success rate $( \\% )$ is shown. "
+        ],
+        "table_body": "<table><tr><td rowspan=2 colspan=2></td><td rowspan=1 colspan=4>Test type</td></tr><tr><td rowspan=1 colspan=1>Kitchen</td><td rowspan=1 colspan=1>Living room</td><td rowspan=1 colspan=1>Bedroom</td><td rowspan=1 colspan=1>Bathroom</td></tr><tr><td rowspan=4 colspan=1>Traintype</td><td rowspan=1 colspan=1>Kitchen</td><td rowspan=1 colspan=1>38.5/62.5</td><td rowspan=1 colspan=1>4.5/8.1</td><td rowspan=1 colspan=1>28.2/52.4</td><td rowspan=1 colspan=1>31.7/66.7</td></tr><tr><td rowspan=1 colspan=1>Living room</td><td rowspan=1 colspan=1>22.6/ 52.1</td><td rowspan=1 colspan=1>13.7/40.3</td><td rowspan=1 colspan=1>27.0/48.0</td><td rowspan=1 colspan=1>26.9/60.1</td></tr><tr><td rowspan=1 colspan=1>Bedroom</td><td rowspan=1 colspan=1>29.5/58.4</td><td rowspan=1 colspan=1>10.4 /30.1</td><td rowspan=1 colspan=1>30.1/ 63.1</td><td rowspan=1 colspan=1>28.0 /55.1</td></tr><tr><td rowspan=1 colspan=1>Bathroom</td><td rowspan=1 colspan=1>35.4/71.9</td><td rowspan=1 colspan=1>5.9/17.9</td><td rowspan=1 colspan=1>24.1/35.8</td><td rowspan=1 colspan=1>39.2/93.6</td></tr></table>",
+        "bbox": [
+            232,
+            573,
+            761,
+            659
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablations on Knowledge Graph. We perform evaluations on how the performance is affected by changing the knowledge graph in our model. The experiment is performed with the kitchen scenes without the “stop” action. We first remove different fractions of object nodes or relations from the graph and re-train the models. As shown in Table 4, the SPL performance drops as more information is removed from the knowledge graph. We also train our model with a fully-connected graph which leads to the SPL of 32.5 and the model with a random graph leads to the SPL of $3 0 . 1 \\pm 0 . 6$ (we repeated this experiment three times). The performance of these two cases is worse than the performance of the model with a proper knowledge graph (38.5). ",
+        "bbox": [
+            173,
+            681,
+            825,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/eefb75d07a6201c4ab2e6812c74e0543209da22c44a69a5642513509a935222b.jpg",
+        "table_caption": [
+            "Table 4: Results of removing objects and relations in the knowledge graph. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Drop %</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>80%</td></tr><tr><td rowspan=1 colspan=1>ObjectsRelations</td><td rowspan=1 colspan=1>38.538.5</td><td rowspan=1 colspan=1>34.836.7</td><td rowspan=1 colspan=1>33.735.0</td><td rowspan=1 colspan=1>33.534.2</td><td rowspan=1 colspan=1>31.131.5</td></tr></table>",
+        "bbox": [
+            330,
+            803,
+            663,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have tried using the edge types (“on”, “next to”, etc.), but the results is not better than the case that we ignore the edge types. That is probably due to the lack of training data for each type separately. We have also tried training only one model for all scene categories, but the performance is lower. ",
+        "bbox": [
+            173,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Computation Cost. It is worth mentioning that the GCN module in our model increases only 0.12 GFLOPs computation compared to the baseline $A 3 C$ $\\sim 4$ GFLOPs), which is marginal. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            328,
+            165
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose an approach to integrate semantic and functional priors with a deep reinforcement learning model for the task of navigation. We use Graph Convolutional Networks to encode the prior knowledge and to update the knowledge according to the observations from the current scene. Our experiments show that prior knowledge improves generalization to unseen scenes and targets. ",
+        "bbox": [
+            174,
+            176,
+            823,
+            232
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The current formulation of the problem does not include a long-term memory so in the future we plan to integrate memory to learn more complex exploration strategies. Incorporating higher-order relationships between objects and scenes is another future direction that we consider. ",
+        "bbox": [
+            176,
+            239,
+            821,
+            280
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements: This research is partly sponsored by Google Focused Award and the ARO under Grant Number W911NF-18-1-0019. Abhinav was supported in part by Okawa Foundation. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the ARO or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            385,
+            285,
+            398
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dandelion Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, ´ Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, ´ and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow.org/. Software available from tensorflow.org.   \nPeter Anderson, Angel X. Chang, Devendra Singh Chaplot, Alexey Dosovitskiy, Saurabh Gupta, Vladlen Koltun, Jana Kosecka, Jitendra Malik, Roozbeh Mottaghi, Manolis Savva, and Amir Roshan Zamir. On evaluation of embodied navigation agents. arXiv, 2018a.   \nPeter Anderson, Qi Wu, Damien Teney, Jake Bruce, Mark Johnson, Niko Sunderhauf, Ian Reid, Stephen Gould, ¨ and Anton van den Hengel. Vision-and-language navigation: Interpreting visually-grounded navigation instructions in real environments. In CVPR, 2018b.   \nJohann Borenstein and Yoram Koren. The vector field histogram and fast obstacle-avoidance for mobile robots. IEEE Trans. on Robotics and Automation, 1991.   \nSamarth Brahmbhatt and James Hays. Deepnav: Learning to navigate large cities. In CVPR, 2017.   \nDevendra Singh Chaplot, Kanthashree Mysore Sathyendra, Rama Kumar Pasumarthi, Dheeraj Rajagopal, and Ruslan Salakhutdinov. Gated-attention architectures for task-oriented language grounding. In AAAI, 2018.   \nChenyi Chen, Ary Seff, Alain L. Kornhauser, and Jianxiong Xiao. Deepdriving: Learning affordance for direct perception in autonomous driving. In ICCV, 2015.   \nChaitanya Desai, Deva Ramanan, and Charless. Fowlkes. Discriminative models for multi-class object layout. In ICCV, 2009.   \nSantosh Kumar Divvala, Derek Hoiem, James Hays, Alexei A. Efros, and Martial Hebert. An empirical study of context in object detection. In CVPR, 2009.   \nHans Jacob S. Feder, John J. Leonard, and Christopher M. Smith. Adaptive mobile robot navigation and mapping. Intl. J. of Robotics Research, 1999.   \nSaurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. In CVPR, 2017.   \nJames Harrison, Animesh Garg, Boris Ivanovic, Yuke Zhu, Silvio Savarese, Li Fei-Fei, and Marco Pavone. AdaPT: Zero-shot adaptive policy transfer for stochastic dynamical systems. In ISRR, 2017. ",
+        "bbox": [
+            169,
+            404,
+            828,
+            930
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            171,
+            104,
+            823,
+            131
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Felix Hill, Simon Green, Fumin Wang, Ryan Faulkner, Hubert Soyer, David Szepesvari, Wojciech Marian Czarnecki, Max Jaderberg, Denis Teplyashin, Marcus Wainwright, Chris Apps, Demis Hassabis, and Phil Blunsom. Grounded language learning in a simulated 3d world. arXiv, 2017. ",
+        "bbox": [
+            176,
+            138,
+            821,
+            179
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Arka Pal, Andrei Rusu, Loic Matthey, Christopher Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. In ICML, 2017. ",
+        "bbox": [
+            173,
+            186,
+            825,
+            226
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Derek Hoiem, Alexei A. Efros, and Martial Hebert. Geometric context from a single image. In ICCV, 2005. ",
+        "bbox": [
+            173,
+            234,
+            808,
+            248
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ronghang Hu, Marcus Rohrbach, Jacob Andreas, Trevor Darrell, and Kate Saenko. Modeling relationships in referential expressions with compositional modular networks. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            256,
+            821,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Ranjay Krishna, Michael Stark, Jia Li, Michael Bernstein, and Li Fei-Fei. Image retrieval using scene graphs. In CVPR, 2015. ",
+        "bbox": [
+            171,
+            291,
+            823,
+            318
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            325,
+            823,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eagle S. Jones and Stefano Soatto. Visual-inertial navigation, mapping and localization: A scalable real-time causal approach. Intl. J. of Robotics Research, 2011. ",
+        "bbox": [
+            173,
+            373,
+            821,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. Bag of tricks for efficient text classification. arXiv, 2016. ",
+        "bbox": [
+            174,
+            409,
+            820,
+            435
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gregory Kahn, Adam Villaflor, Bosen Ding, Pieter Abbeel, and Sergey Levine. Self-supervised deep reinforcement learning with generalized computation graphs for robot navigation. In ICRA, 2018. ",
+        "bbox": [
+            176,
+            443,
+            820,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dongsung Kim and Ramakant Nevatia. Symbolic navigation with a generic map. Autonomous Robots, 1999. ",
+        "bbox": [
+            176,
+            478,
+            816,
+            492
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            501,
+            823,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric Kolve, Roozbeh Mottaghi, Daniel Gordon, Yuke Zhu, Abhinav Gupta, and Ali Farhadi. AI2-THOR: An Interactive 3D Environment for Visual AI. arXiv, 2017. ",
+        "bbox": [
+            174,
+            535,
+            823,
+            563
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A Shamma, et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. IJCV, 2017. ",
+        "bbox": [
+            173,
+            570,
+            823,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ruiyu Li, Makarand Tapaswi, Renjie Liao, Jiaya Jia, Raquel Urtasun, and Sanja Fidler. Situation recognition with graph neural networks. In ICCV, 2017. ",
+        "bbox": [
+            171,
+            617,
+            823,
+            645
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomasz Malisiewicz and Alexei A. Efros. Beyond categories: The visual memex model for reasoning about object relationships. In NIPS, 2009. ",
+        "bbox": [
+            173,
+            652,
+            823,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kenneth Marino, Ruslan Salakhutdinov, and Abhinav Gupta. The more you know: Using knowledge graphs for image classification. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            688,
+            823,
+            715
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marcin Marszalek, Ivan Laptev, and Cordelia Schmid. Actions in context. In CVPR, 2009. ",
+        "bbox": [
+            173,
+            723,
+            710,
+            737
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Larry H. Matthies and Steven A. Shafer. Error modeling in stereo navigation. IEEE J. Robotics and Automation, 1987. ",
+        "bbox": [
+            169,
+            744,
+            823,
+            772
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hongyuan Mei, Mohit Bansal, and Matthew R. Walter. Listen, attend, and walk: Neural mapping of navigational instructions to action sequences. In AAAI, 2016. ",
+        "bbox": [
+            173,
+            780,
+            821,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Min Meng and Avinash C. Kak. Neuro-nav: A neural network based architecture for vision-guided mobile robot navigation using non-metrical models of the environment. In ICRA, 1993. ",
+        "bbox": [
+            173,
+            815,
+            823,
+            842
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            174,
+            849,
+            821,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dipendra Kumar Misra, John Langford, and Yoav Artzi. Mapping instructions and visual observations to actions with reinforcement learning. In EMNLP, 2017. ",
+        "bbox": [
+            171,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            176,
+            103,
+            823,
+            143
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Roozbeh Mottaghi, Xianjie Chen, Xiaobai Liu, Nam-Gyu Cho, Seong-Whan Lee, Sanja Fidler, Raquel Urtasun, and Alan Yuille. The role of context for object detection and semantic segmentation in the wild. In CVPR, 2014. ",
+        "bbox": [
+            174,
+            151,
+            821,
+            190
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arsalan Mousavian, Alexander Toshev, Marek Fiser, Jana Kosecka, and James Davidson. Visual representations for semantic target driven navigation. In ECCV Workshop on Visual Learning and Embodied Agents in Simulation Environments, 2018. ",
+        "bbox": [
+            173,
+            199,
+            823,
+            239
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Varun K. Nagaraja, Vlad I. Morariu, and Larry S. Davis. Modeling context between objects for referring expression understanding. In ECCV, 2016. ",
+        "bbox": [
+            173,
+            247,
+            821,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Satinder Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization with multi-task deep reinforcement learning. In ICML, 2017. ",
+        "bbox": [
+            173,
+            282,
+            823,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Parsa Mahmoudieh, Guanghao Luo, Pulkit Agrawal, Dian Chen, Fred Shentu, Evan Shelhamer, Jitendra Malik, Alexei A. Efros, and Trevor Darrell. Zero-shot visual imitation. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            318,
+            823,
+            344
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Rabinovich, Andrea Vedaldi, Carolina Galleguillos, Eric Wiewiora, and Serge Belongie. Objects in context. In ICCV, 2005. ",
+        "bbox": [
+            174,
+            352,
+            823,
+            380
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fereshteh Sadeghi and Sergey Levine. CAD2RL: real single-image flight without a single real image. In RSS, 2017. ",
+        "bbox": [
+            174,
+            388,
+            823,
+            416
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nikolay Savinov, Alexey Dosovitskiy, and Vladlen Koltun. Semi-parametric topological memory for navigation. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            422,
+            821,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abhinav Shrivastava and Abhinav Gupta. Contextual priming and feedback for faster r-cnn. In ECCV, 2016. ",
+        "bbox": [
+            173,
+            458,
+            813,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Siagian, Chin-Kai Chang, and Laurent Itti. Autonomous mobile robot localization and navigation using a hierarchical map representation primarily guided by vision. J. Field Robotics, 2014. ",
+        "bbox": [
+            173,
+            481,
+            821,
+            508
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Thrun. Learning metric-topological maps for indoor mobile robot navigation. Artificial Intelligence, 1998. ",
+        "bbox": [
+            174,
+            516,
+            821,
+            544
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. RMSprop gradient optimization. URL http://www.cs.toronto. edu/˜tijmen/csc321/slides/lecture_slides_lec6.pdf. ",
+        "bbox": [
+            174,
+            551,
+            820,
+            579
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antonio Torralba, Kevin P. Murphy, William T. Freeman, and Mark A. Rubin. Context-based vision system for place and object recognition. In CVPR, 2003. ",
+        "bbox": [
+            176,
+            587,
+            823,
+            614
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang, Yufei Ye, and Abhinav Gupta. Zero-shot recognition via semantic embeddings and knowledge graphs. In CVPR, 2018. ",
+        "bbox": [
+            174,
+            622,
+            821,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuxin Wu and Yuandong Tian. Training agent for first-person shooter game with actor-critic curriculum learning. In ICLR, 2017. ",
+        "bbox": [
+            176,
+            657,
+            821,
+            684
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haonan Yu, Haichao Zhang, and Wei Xu. Interactive grounded language acquisition and generalization in a 2d world. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            693,
+            823,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hanwang Zhang, Zawlin Kyaw, Shih-Fu Chang, and Tat-Seng Chua. Visual translation embedding network for visual relation detection. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            728,
+            823,
+            755
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J Lim, Abhinav Gupta, Li Fei-Fei, and Ali Farhadi. Targetdriven visual navigation in indoor scenes using deep reinforcement learning. In ICRA, 2017. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            791
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yukun Zhu, Raquel Urtasun, Ruslan Salakhutdinov, and Sanja Fidler. segdeepm: Exploiting segmentation and context in deep neural networks for object detection. In CVPR, 2015. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            825
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A NAVIGATION TARGETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            493,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In Table 5, we show the object categories that are used as our navigation targets. The split of train and test categories is provided as well. ",
+        "bbox": [
+            174,
+            127,
+            823,
+            154
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/27383e78803c589d3e537b7473107690c1920ae88bd094b406412a31cdd399f7.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 5: Training and testing split of object categories for each scene type in the AI2-THOR. "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Room type</td><td rowspan=1 colspan=1>Train objects</td><td rowspan=1 colspan=1>Test objects</td></tr><tr><td rowspan=1 colspan=1>Kitchen</td><td rowspan=1 colspan=1>HousePlant, StoveKnob,Sink, TableTop,Potato,Bread,Tomato,Knife,Cabinet, Fridge, Container, ButterKnife,Lettuce,Pan, Bowl, CoffeeMachine, StoveBurner,Plate</td><td rowspan=1 colspan=1>Mug，Apple,Microwave,Toaster</td></tr><tr><td rowspan=1 colspan=1>Living room</td><td rowspan=1 colspan=1>Television，HousePlant,Chair，TableTop，Box，Cloth,Newspaper, KeyChain,WateringCan,PaintingHanger</td><td rowspan=1 colspan=1>Painting,Statue</td></tr><tr><td rowspan=1 colspan=1>Bedroom</td><td rowspan=1 colspan=1>Painting,HousePlant, CellPhone,LightSwitch, Candle,TableTop,Bed, Lamp, Statue,Book, CreditCard,Key-Chain, Bowl, Pen,Box, Pencil,Blinds,Laptop,Alarm-Clock</td><td rowspan=1 colspan=1>Television,Mirror, Cabi-net</td></tr><tr><td rowspan=1 colspan=1>Bathroom</td><td rowspan=1 colspan=1>SprayBottle,Painting, Candle, LightSwitch, Sink, Cab-inet，TowelHolder，Watch，ToiletPaper，ShowerDoor,SoapBottle</td><td rowspan=1 colspan=1>SoapBar,Towel</td></tr></table>",
+        "bbox": [
+            191,
+            160,
+            802,
+            345
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B TRAINING CURVES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            381,
+            460,
+            397
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We show the training curves in Figure 5. We compare our method with the baseline A3C. All the models are trained 3 times with different initializations. We compute the model performance with Success Rate and $S P L$ every 10 million iterations during training. We use the error band to represent the standard deviation. The curves show our model converges faster than the A3C baseline and obtain better performance in both metrics, which indicates the effectiveness of the scene priors. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/ab74b398c9a6c3af39d24431a836b6ee4e63a3a6235965d4c9b29043e53a006f.jpg",
+        "image_caption": [
+            "Figure 5: Learning curves. The top row shows success rate and the bottom row shows SPL. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            487,
+            834,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            755,
+            532,
+            771
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our method is implemented in Tensorflow (Abadi et al., 2015) and the actor-critic policy network is trained with a single NVIDIA GeForce GTX Titan X GPU with 20 threads for 10 million frames for experiments without stop action, and for 25 million frames for experiments with stop action. The initial learning rate is set empirically as $7 e \\mathrm { ~ - ~ } 4$ , and is decreased linearly as the training progresses. The network parameters are optimized by the RMSProp optimizer (Tieleman & Hinton). The maximum number of steps is set to 100 for kitchen, bedroom and bathroom, and to 200 for living room due to the larger exploration space. Since there is almost no overlap between object categories within different room types, we train separate models for each room type. ",
+        "bbox": [
+            173,
+            780,
+            825,
+            882
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX D QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            900,
+            500,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/a655395377b04900bdf2b9f6bd673d9880454c4785fc532037d286c108141623.jpg",
+        "image_caption": [
+            "Figure 6: Qualitative results. Examples of last eight frames and the corresponding actions $a _ { t }$ predicted from our model on unseen scenes with novel target objects. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            116,
+            790,
+            859
+        ],
+        "page_idx": 12
+    }
+]

parse/train/Pz_dcqfcKW8/Pz_dcqfcKW8.md

@@ -0,0 +1,274 @@
+# DUAL-MODE ASR: UNIFY AND IMPROVE STREAMING ASR WITH FULL-CONTEXT MODELING
+
+Jiahui $\mathbf { Y u } ^ { 1 }$ Wei Han1† Anmol Gulati1† Chung-Cheng Chiu1 Bo Li2 Tara N. Sainath2 Yonghui Wu1 Ruoming Pang1
+
+1Google Brain 2Google LLC {jiahuiyu, rpang}@google.com
+
+# ABSTRACT
+
+Streaming automatic speech recognition (ASR) aims to emit each hypothesized word as quickly and accurately as possible, while full-context ASR waits for the completion of a full speech utterance before emitting completed hypotheses. In this work, we propose a unified framework, Dual-mode ASR, to train a single end-to-end ASR model with shared weights for both streaming and full-context speech recognition. We show that the latency and accuracy of streaming ASR significantly benefit from weight sharing and joint training of full-context ASR, especially with inplace knowledge distillation during the training. The Dual-mode ASR framework can be applied to recent state-of-the-art convolution-based and transformer-based ASR networks. We present extensive experiments with two state-of-the-art ASR networks, ContextNet and Conformer, on two datasets, a widely used public dataset LibriSpeech and a large-scale dataset MultiDomain. Experiments and ablation studies demonstrate that Dual-mode ASR not only simplifies the workflow of training and deploying streaming and full-context ASR models, but also significantly improves both emission latency and recognition accuracy of streaming ASR. With Dual-mode ASR, we achieve new state-of-the-art streaming ASR results on both LibriSpeech and MultiDomain in terms of accuracy and latency.
+
+# 1 INTRODUCTION
+
+“Ok Google. Hey Siri. Hi Alexa.” have featured a massive boom of smart speakers in recent years, unveiling a trend towards ubiquitous and ambient Artificial Intelligence (AI) for better daily lives. As the communication bridge between human and machine, low-latency streaming ASR (a.k.a., online ASR) is of central importance, whose goal is to emit each hypothesized word as quickly and accurately as possible on the fly as they are spoken. On the other hand, there are some scenarios where full-context ASR (a.k.a., offline ASR) is sufficient, for example, offline video captioning on video-sharing platforms. While low-latency streaming ASR is generally preferred in most of the speech recognition scenarios, it often has worse prediction accuracy as measured in Word Error Rate (WER), due to the lack of future context compared with full-context ASR. Improving both WER and emission latency has been shown to be highly challenging (He et al., 2019; Li et al., 2020a; Sainath et al., 2020) in streaming ASR systems.
+
+Since the acoustic, pronunciation, and language model (AM, PM, and LM) of a conventional ASR system have been evolved into a single end-to-end (E2E) all-neural network, modern streaming and full-context ASR models share most of the neural architectures and training recipes in common, such as, Mel-spectrogram inputs, data augmentations, neural network meta-architectures, training objectives, model regularization techniques and decoding methods. The most significant difference is that streaming ASR encoders are auto-regressive models, with the prediction of the current timestep conditioned on previous ones (no future context is permitted). Specifically, let $x$ and $y$ be the input and output sequence, $t$ as frame index, $T$ as total length of frames. Streaming ASR encoders model the output $y _ { t }$ as a function of input $x _ { 1 : t }$ while full-context ASR encoders model the output $y _ { t }$ as a function of input $x _ { 1 : T }$ . Streaming ASR encoders can be built with uni-directional LSTMs, causal convolution and left-context attention layers in streaming ASR encoders (Chiu & Raffel, 2018; Fan et al., 2018; Han et al., 2020; Gulati et al., 2020; Huang et al., 2020; Moritz et al., 2020; Miao et al., 2020; Tsunoo et al., 2020; Zhang et al., 2020; Yeh et al., 2019). Recurrent Neural Network Transducers (RNN-T) (Graves, 2012) are commonly used as the decoder in both streaming and fullcontext models, which predicts the token of the current input frame based on all previous tokens using uni-directional recurrent layers. Figure 1 illustrates a simplified example of the similarity and difference between streaming and full-context ASR models with E2E neural networks.
+
+![](images/d1f34c27d36c1a06c1d05b32cf8f7d91905338b9c64253cb7fcd9d2936456a44.jpg)  
+Figure 1: A simplified illustration of the similarity and difference between Streaming ASR and Fullcontext ASR networks. Modern end-to-end streaming and full-context ASR models share most of the neural architectures and training recipes in common, with the most significant difference in the ASR encoder (highlighted). Streaming ASR encoders are auto-regressive models, with each prediction of the current timestep conditioned on previous ones (no future context). We show examples of feed-forward layer, convolution layer and self-attention layer in the encoder of streaming and full-context ASR respectively. With Dual-mode ASR, we unify them without parameters overhead.
+
+Albeit the similarities, streaming and full-context ASR models are usually developed, trained, and deployed separately. In this work, we propose Dual-mode ASR, a framework to unify streaming and full-context speech recognition networks with shared weights. Dual-mode ASR comes with many immediate benefits, including reduced model download and storage on devices and simplified development and deployment workflows. To accomplish this goal, we first introduce Dual-mode Encoders, which can run in both streaming mode and full-context mode. Dual-mode encoders are designed to reuse the same set of model weights for both modes with zero or near-zero parameters overhead. We propose the design principles of a dual-mode encoder and show examples on how to design dual-mode convolution, dual-mode pooling, and dual-mode attention layers. We also investigate into different training algorithms for Dual-mode ASR, specifically, randomly sampled training and joint training. We show that joint training significantly outperforms randomly sampled training in terms of model quality and training stability. Moreover, motivated by Inplace Knowledge Distillation (Yu & Huang, 2019b) in which a large model is used to supervise a small model, we propose to distill knowledge from the full-context mode (teacher) into the streaming mode (student) on the fly during the training within the same Dual-mode ASR model, by encouraging consistency of the predicted token probabilities.
+
+We demonstrate that the emission latency and prediction accuracy of streaming ASR significantly benefit from weight sharing and joint training of its full-context mode, especially with inplace knowledge distillation during the training. We present extensive experiments with two state-of-theart ASR networks, convolution-based ContextNet (Han et al., 2020) and conv-transformer hybrid Conformer (Gulati et al., 2020), on two datasets, a widely used public dataset LibriSpeech (Panayotov et al., 2015) (970 hours of English reading speech) and a large-scale dataset MultiDomain (Narayanan et al., 2018) (413,000 hours speech of a mixture across multiple domains including Voice Search, Farfield Speech, YouTube and Meetings). For each proposed technique, we also present ablation study and analysis to demonstrate and understand the effectiveness. With Dual-mode ASR, we achieve new state-of-the-art streaming ASR results on both LibriSpeech and MultiDomain in terms of accuracy and latency.
+
+# 2 RELATED WORK
+
+Streaming ASR Networks. There has been a growing interest in building streaming ASR systems based on E2E Recurrent Neural Network Transducers (RNN-T) (Graves, 2012). Compared with sequence-to-sequence models (Chorowski et al., 2014; 2015; Chorowski & Jaitly, 2016; Bahdanau et al., 2016; Chan et al., 2016), RNN-T models are naturally streamable and have shown great potentials for low-latency streaming ASR (Chang et al., 2019; He et al., 2019; Tsunoo et al., 2019; Sainath et al., 2019; Shen et al., 2019; Li et al., 2020a;b; Sainath et al., 2020; Huang et al., 2020; Moritz et al., 2020; Narayanan et al., 2020). In this work, we mainly focus on RNN-T based models. He et al. specifically studied how to optimize the RNN-T streaming ASR model for mobile devices, and proposed a bag of techniques including using layer normalization and large batch size to stabilize training; using word-piece targets (Wu et al., 2016); using a time-reduction layer to speed up training and inference; quantizing network parameters to reduce memory footprint and speed up computation; applying shallow-fusion to bias towards user-specific context. To support streaming modeling in E2E ASR models, various efforts have also been made by modifying attention-based models such as monotonic attention (Raffel et al., 2017; Chiu & Raffel, 2017; Fan et al., 2018; Arivazhagan et al., 2019), GMM attention (Graves, 2013; Chiu et al., 2019), triggered attention (TA) (Moritz et al., 2019), Scout Network (Wang et al., 2020), and approaches that segment encoder output into non-overlapping chunks (Jaitly et al., 2016; Tsunoo et al., 2020). Tsunoo et al. also applied knowledge distillation from the non-streaming model to the streaming model, but their streaming and non-streaming models do not share weights and are trained separately.
+
+To improve the latency of RNN-T streaming models, Li et al. investigated additional early and late penalties on Endpointer prediction (Chang et al., 2019) to reduce the emission latency, and employed the minimum word error rate (MWER) training (Prabhavalkar et al., 2018) to remedy accuracy degradation. Sainath et al. further proposed to improve quality by using two-pass models (Sainath et al., 2019), i.e., a second-pass LAS-based rescore model on top of the hypotheses from first-pass RNN-T streaming output. More recently, Li et al. proposed parallel rescoring by replacing LSTMs with Transformers (Vaswani et al., 2017) in rescoring models. Chang et al. further proposed Prefetching to reduce system latency by submitting partial recognition results for subsequent processing such as obtaining assistant server responses or second-pass rescoring before the recognition result is finalized. Unlike these approaches, our work explores the unification of streaming and fullcontext ASR networks, thus can be generally applied as an add-on technique without requiring extra runtime support during inference.
+
+Weight Sharing for Multi-tasking. Sharing model weights of a deep neural network for multiple tasks has been widely explored in the literature to reduce overall model sizes. In the broadest sense, tasks can refer to different objectives or same objective but different settings, ranging from natural language processing and speech recognition to computer vision and reinforcement learning. In speech recognition, Kannan et al. employed a single ASR network for multilingual ASR, and showed accuracy improvements over monolingual ASR systems. Wu et al. proposed dynamic sparsity neural networks (DSNN) for speech recognition on mobile devices with resource constraints. A single trained DSNN (Wu et al., 2020) can transform into multiple networks of different sparsities for adaptive inference in real-time. Chang et al. trained a single RNN-T model with LSTMs (Hochreiter & Schmidhuber, 1997) for Joint Endpointing (i.e., predicting both recognition tokens and the end of an utterance transcription) in streaming ASR systems. Moreover, Watanabe et al. proposed a hybrid CTC and attention architecture for ASR based on multi-objective learning to eliminate the use of linguistic resources.
+
+Another related research work in Computer Vision is Slimmable Neural Networks (Yu et al., 2018; Yu & Huang, 2019a;b; Yu et al., 2020). Yu et al. proposed an approach to train a single neural network running at different widths, permitting instant and adaptive accuracy efficiency trade-offs at runtime. We also adapt the training rules introduced in slimmable networks, that is, using independent normalization layers for different sub-networks (tasks) as conditional parameters and using the prediction of teacher network to supervise student network as inplace distillation during the training. Unlike slimmable networks in which a large model is used to supervise a small model, we propose to distill the knowledge from full-context mode (teacher) into streaming mode (student) on the fly within the same Dual-mode ASR model.
+
+Knowledge Distillation. Hinton et al. explored a simple method to “transfer” knowledge from a teacher neural network to a student neural network by enforcing their predictions to be close measured by KL-divergence, $\ell _ { 1 }$ or $\ell _ { 2 }$ distance. It is shown that such distillation method is effective to compress neural networks (Yu & Huang, 2019b), accelerate training (Chen et al., 2015), improve robustness (Carlini & Wagner, 2017; Papernot et al., 2016), estimate model uncertainty (Blundell et al., 2015) and transfer learned domain to other domains (Tzeng et al., 2015).
+
+# 3 DUAL-MODE ASR
+
+Most neural sequence transduction networks for ASR have an encoder-decoder structure (Graves, 2012; Sainath et al., 2020; He et al., 2019; Li et al., 2020a), as shown in Figure 1. Without loss of generality, here we discuss how to design Dual-mode ASR networks under the most commonly used RNN-T model (Graves, 2012). In RNN-T models, we first extract mel-spectrogram feature from input speech waveform. The Mel-spectrogram feature is then fed into a neural-net encoder, which usually consists of feed-forward layers, RNN/LSTM layers, convolution layers, attention layers, pooling (time-reduction) layers, and residual or dense connections. In neural-net encoders, streaming ASR model requires all components to be auto-regressive, whereas full-context ASR model has no such requirement. The ASR decoder then predicts the token of current frame based on the output from the encoder and previous predicted tokens (inference) or target tokens (training with teacher forcing (Williams & Zipser, 1989)). The decoder is commonly an auto-regressive model in both streaming and full-context ASR models, thus is fully shared in Dual-mode ASR. The prediction from decoder is finally used either in decoding algorithm during inference (e.g., beam search) or learning algorithm during training (e.g., RNN-T loss).
+
+As discussed above and shown in Figure 1, it becomes clear that the major difference between streaming and full-context ASR models is in the neural-net encoder. In the following, we will first discuss the design principles of dual-mode encoder to support both streaming and full-context ASR. We provide examples including dual-mode convolution, dual-mode average pooling, and dual-mode attention layers, which are widely used in the state-of-the-art ASR networks ContextNet (Han et al., 2020) and Conformer (Gulati et al., 2020). We will then discuss the training algorithm of Dual-mode ASR networks including joint training and inplace knowledge distillation.
+
+# 3.1 DUAL-MODE ENCODER
+
+Unifying streaming and full-context ASR models requires two design principles of Dual-mode Encoder:
+
+1. Each layer in a dual-mode encoder should be either dual-mode or streaming (a.k.a., causal). Since streaming encoder has to be auto-regressive which prohibits any future context, any full-context (a.k.a., non-causal) layer violates this constraint.   
+2. The design of a dual-mode layer should not introduce significant amount of additional parameters, compared with its streaming model. We aim at supporting full-context ASR on top of the streaming model with near-zero parameters overhead.
+
+We show examples below by applying the above two design principles to ContextNet (Han et al., 2020) and Conformer (Gulati et al., 2020), in which the encoders are composed of pointwise operators (feed-forward net, residual connections, activation layers, striding, dropout, etc.), convolution, average pooling, self-attention and normalization layers.
+
+Pointwise operators are naturally dual-mode layers. Neural network layers that connect input and output neurons within each timestep (no across-connections among different timesteps) are often referred as pointwise operators (Chollet, 2017), including feed-forward layers (a.k.a., fullyconnected layers or $1 \times 1$ convolution layers), activation layers (e.g., ReLU, Swish (Ramachandran et al., 2017)), residual and dense connections (He et al., 2016; Huang et al., 2017), striding layers, dropout layers (Srivastava et al., 2014) and element-wise multiplications. As there is no information propagation through time, pointwise operators are naturally dual-mode layers and can be directly used in Dual-mode ASR encoders.
+
+![](images/f0ab9aa67a0046df1f58ffff9f82dde0ba719a2847b80d942aac195b112a5175.jpg)  
+Figure 2: Dual-mode convolution and average pooling layer for Dual-mode ASR.
+
+Dual-mode Convolution. Convolution layers, however, convolve feature across its neighbor timesteps within a fixed window (e.g., kernel size is 3, 5, or larger), and has been widely used in sequence modeling (Gehring et al., 2017; Han et al., 2020; Gulati et al., 2020). In conv-based streaming ASR models, causal convolution layers (Oord et al., 2016) are used where the convolution window is biased to the left (self-included). As shown in Figure 2 on the left, to support both streaming and full-context modes with shared weights, we first construct a normal symmetric convolution of kernel size $k$ which will be applied in full-context mode. Then we mimic the causal convolution of kernel size $( k + 1 ) / 2$ by constructing a Boolean mask and multiplying with the fullcontext convolution kernel before applying the actual convolution of streaming mode in Dual-mode ASR encoders.
+
+The design of dual-mode convolution introduces $( k - 1 ) / 2$ additional parameters to support fullcontext convolution $( k )$ compared with streaming convolution $( ( k + 1 ) / 2 )$ . However, we note that in convolution-based models, these temporal-wise convolution layers only take a tiny amount of total model size and most of the weights are on $1 \times 1$ convolution layers which are fully shared pointwise operators. For example, in ContextNet (Han et al., 2020), temporal-wise convolution has less than $1 \%$ of total model size, thus parameters overhead is negligible.
+
+Dual-mode Average Pooling. Squeeze-and-excitation (Hu et al., 2018) (SE) modules are used in ContextNet to enhance the global context encoding. Each SE module is a sequential stack of average pooling (through time) layer, feed-forward layer, activation layer, another feed-forward layer and elementwise multiplication. To support both modes, dual-mode average pooling layer is used as shown in Figure 2 on the right. Dual-mode average pooling layer is parameter-free thus does not introduce additional model parameters. It also trains in parallel in streaming mode, easily implemented with “cumsum” function in both TensorFlow and PyTorch.
+
+Dual-mode Self-attention. Self-attention (a.k.a. intra-attention) is an attention mechanism weighting different positions of a single sequence in order to compute a representation of the same sequence. It is heavily used in Conformer (Gulati et al., 2020) ASR networks. The attention layer itself is parameter-free (projection layers before attention are fully shared), and is composed of matrix multiplication of the key and the query, followed by softmax over keys, before another matrix multiplication with the value. As shown in Figure 3, in dual-mode attention layer, the softmax is performed on the left context only in streaming mode (rectangle with solid line), compared with the full-context mode (rectangle with dash line). We find this simple form of dual-mode self-attention works well in practice.
+
+![](images/4f528f18a6c4aa9e2a4f6bb67f082a371fc76eca55334f921678afdf1c5f1264.jpg)  
+Figure 3: Dual-mode self-attention layer.
+
+# Algorithm 1 Pseudocode of training Dual-mode ASR networks.
+
+# Requires: data_loader; context manager with support of mode switching by network.mode(); dual_mode_network with support of running both modes under context manager;   
+for x, y in data_loader: # Load a minibatch of speech input x and text label y. with dual_mode_network.mode(’fullcontext’): # Switch context to ’fullcontext’ mode. # Compute full-context prediction given speech input x and text label y. fullcontext_pred $=$ dual_mode_network.forward_encoder_decoder(x, y) # Compute RNN-T loss of full-context mode. fullcontext_loss $=$ rnnt_loss(fullcontext_pred, y)
+
+with dual_mode_network.mode(’streaming’): # Switch context to ’streaming’ mode. # Compute streaming prediction given speech input x and text label y. streaming_pred $=$ dual_mode_network.forward_encoder_decoder(x, y) # Compute RNN-T loss of streaming mode. streaming_loss $=$ rnnt_loss(streaming_pred, y)
+
+# Add inplace knowledge distillation loss (full-context prediction as teacher). distill_loss $=$ inplace_distill_loss(streaming_pred, stop_gradient(fullcontext_pred)
+
+# Compute total loss as a sum of full-context, streaming and distillation losses. loss $=$ fullcontext_loss $^ +$ streaming_loss $^ +$ distill_loss   
+loss.backward() # Update weights.
+
+Dual-mode Normalization. Moreover, following Yu et al. (2018), we also find the normalization statistics like means and variances are different in streaming and full-context modes. Thus, for normalization layers including BatchNorm (Ioffe & Szegedy, 2015) and LayerNorm (Ba et al., 2016) in Dual-mode ContextNet and Dual-mode Conformer, we instantiate two separate norm layers dedicated to streaming and full-context mode respectively.
+
+# 3.2 TRAINING DUAL-MODE ASR NETWORKS
+
+The training algorithm of Dual-mode ASR networks is outlined in Algorithm 1. In this section, we discuss two important training techniques: joint training and inplace knowledge distillation.
+
+Joint Training. To train Dual-mode ASR networks, given a batch of data in each training iteration, we can either randomly sample one from two modes to train, or train both modes and aggregate their losses. In the former approach, referred as randomly sampled training, we can control the importance of streaming and full-context modes by setting different sampling probabilities during training. In the latter approach, referred as joint training, importance can also be controlled by assigning different loss weights to balance streaming and full-context modes. Empirically we find joint training leads to better model qualities overall thus is adopted in all of our experiments. We will show an ablation study comparing randomly sampled training and joint training. In all of our experiments, we treat streaming and full-context mode to be equally important by assigning equal importance during training.
+
+Inplace Knowledge Distillation. Additionally we propose to distill knowledge from the full-context mode (teacher) into the streaming mode (student) on the fly within the same Dual-mode ASR model, by encouraging consistency of the predicted token probabilities. Since in each iteration we always compute predictions of both modes, the teacher prediction comes for free (no additional computation or memory cost), as shown in Algorithm 1. We use the efficient knowledge distillation introduced by Panchapagesan et al., which is based on the KL-divergence between full-context and streaming over the probability of three parts: $P _ { l a b e l }$ , $P _ { b l a n k }$ and $1 - P _ { l a b e l } - P _ { b l a n k }$ . We note that the prediction of full-context mode (teacher) usually has lower latency (since it has no incentive to delay its output), thus we can control the target emission latency of streaming mode (student) by shifting the prediction of full-context mode, before applying distillation loss. We do a small-scale hyper-parameter sweep from -2 to 2 frames to shift for ContextNet and Conformer in our experiments.
+
+# 4 EXPERIMENTS
+
+# 4.1 MAIN RESULT
+
+Measuring Latency. Latency measurement is itself challenging for streaming ASR systems. Motivated by Prefetching (Chang et al., 2020) technique, we measure latency as the difference of two timestamps: 1) when the last token is emitted in the finalized recognition result; 2) the end of the speech when a user finishes speaking. We find this is especially descriptive of user experience in real-world ASR applications like Voice Search. ASR models that capture stronger contexts can emit the full hypothesis even before they are spoken, leading to a negative latency. Moreover, instead of naively averaging latency over all utterances, we report both median and 90th percentile of all utterances in test set, denoted as Latency $\textcircled{6} 5 \mathbf { 0 }$ and Latency $@ 9 0$ , to better characterize latency by excluding outlier utterances. To evaluate the model quality, we report WER only for full-context models and both WER and latency for streaming models (full-context latency is meaningless).
+
+Datasets. We conduct our experiments on two datasets: a public widely used dataset LibriSpeech (Panayotov et al., 2015) (1,000 hours of English reading speech) and a large-scale dataset MultiDomain (413,000 hours speech, 287 million utterances of a mixture across multiple domains including Voice Search, YouTube, and Meetings). Table 1 summarizes the information and statistics of two datasets. For LibriSpeech, we report our evaluation results on TestClean and TestOther (noisy) sets and compare with other published baselines. For MultiDomain, we report our evaluation results on Voice Search test set and compare with our reproduced baselines. For fair comparisons, on each dataset we train and report our models and baselines with the same settings (number of training iterations, hyper-parameters, optimizer, regularization, etc.). We note that these hyper-parameters are inherited from previous work Han et al. (2020); Gulati et al. (2020) and not specifically tuned for our dual-mode models.
+
+Table 1: Summary of datasets we used in our experiments.   
+
+<table><tr><td>Dataset Name</td><td>#Hours</td><td># Utterances</td><td>Speech Domain</td></tr><tr><td>LibriSpeech (Panayotov et al., 2015)</td><td>~970</td><td>~ 281,000</td><td>Single domain of English reading speech.</td></tr><tr><td>MultiDomain (Narayanan et al., 2018)</td><td>~ 413,000</td><td>~ 287,000,000</td><td>Multiple domains including: Voice Search, Farfield Speech, YouTube and Meetings.</td></tr></table>
+
+ASR Networks. We use two recent state-of-the-art ASR networks to demonstrate the effectiveness of our proposed methods, ContextNet (Han et al., 2020) and Conformer (Gulati et al., 2020). The encoder of ContextNet is based on depthwise-separable convolution (Chollet, 2017) and squeezeand-excitation modules (Hu et al., 2018). In depthwise-separable convolution of Dual-mode ContextNet, the weights of $1 \times 1$ convolutions are fully shared between streaming and full-context mode, whereas for temporal-wise convolution we follow the design of Dual-mode Convolution proposed in Section 3.1. Note that in ContextNet, temporal-wise convolutions only take less than $1 \%$ of the model size thus the parameters overhead of full-context mode is negligible compared with steaming mode. In squeeze-and-excitation modules, we use dual-mode average pooling layers (Section 3.1) to support both streaming and full-context mode without additional parameters.
+
+Conformer (Gulati et al., 2020) combines convolution and transformer to model both local and global dependencies of speech sequences in a parameter-efficient way. In Dual-mode Conformer, we replace all convolution and transformer layers with their dual-mode correspondents (Section 3.1). Moreover, for normalization layers including BatchNorm (Ioffe & Szegedy, 2015) and LayerNorm (Ba et al., 2016) in Dual-mode ContextNet and Dual-mode Conformer, we instantiate two separate norm layers for streaming and full-context mode respectively.
+
+Training Details and Results. We train our models exactly following our baselines ContextNet (Han et al., 2020) and Conformer (Gulati et al., 2020), using Adam optimizer (Kingma & Ba, 2014), SpecAugment (Park et al., 2019) and a transformer learning rate schedule (Vaswani et al., 2017) with warm-up (Goyal et al., 2017). Our main results are summarized in Table 2 and Table 3. We also add a streaming ContextNet Look-ahead baseline (6 frames, 10ms per frame, totally 60ms look-ahead latency) in Table 3 by padding additional frames at the end of the input utterances. As shown in the tables, the streaming mode in Dual-mode ASR models has significantly better latency and similar or higher WER results, surpassing other baselines including conventional models, LSTM-based transducers (Sainath et al., 2020), transformer-transducers (Zhang et al., 2020) and some others.
+
+Table 2: Summary of our results on MultiDomain dataset (Narayanan et al., 2018). We report WER on Voice Search test set. Compared with standalone ContextNet and Conformer models, Dual-mode ASR models have slightly higher accuracy and much better streaming latency. ASR models that capture stronger contexts can emit the full hypothesis even slightly before they are spoken, leading to a negative latency.   
+
+<table><tr><td>Method</td><td>Mode</td><td># Params (M)</td><td>VS Test WER(%)</td><td>Latency @50 (ms)</td><td>Latency @90 (ms)</td></tr><tr><td>ContextNet Conformer</td><td>Full-context Full-context</td><td>133 142</td><td>5.1 5.2</td><td></td><td></td></tr><tr><td>LSTM (Sainath et al., 2020) ContextNet (Han et al.,2020)</td><td>Streaming Streaming</td><td>179 133</td><td>6.4 6.1</td><td>190 160</td><td>350 310</td></tr><tr><td>Conformer (Gulati et al., 2020) Dual-mode ContextNet</td><td>Streaming Full-context</td><td>142 133</td><td>6.1 4.9</td><td>160</td><td>300</td></tr><tr><td>Dual-mode Conformer</td><td>Streaming Full-context Streaming</td><td>142</td><td>6.0 (-0.1) 5.0 6.0 (-0.1)</td><td>10 (-150) -50 (-210)</td><td>220 (-90) 130 (-170)</td></tr></table>
+
+Table 3: Summary of our results on Librispeech dataset (Panayotov et al., 2015). We report WER on TestClean and TestOther (noisy) set. Compared with standalone ContextNet and Conformer models, Dual-mode ASR models have both higher accuracy in average and better streaming latency.   
+
+<table><tr><td>Method</td><td>Mode</td><td># Params (M)</td><td>Test Clean/Other WER(%)</td><td></td><td>Latency@50 (ms)</td><td>Latency @90 (ms)</td></tr><tr><td>LSTM-LAS</td><td>Full-context</td><td>360</td><td>2.6 /</td><td>6.0</td><td></td><td></td></tr><tr><td>QuartzNet-CTC</td><td>Full-context</td><td>19</td><td>3.9 /</td><td>11.3</td><td></td><td></td></tr><tr><td>Transformer</td><td>Full-context</td><td>29</td><td>3.1 /</td><td>7.3</td><td></td><td></td></tr><tr><td>Transformer</td><td>Full-context</td><td>139</td><td>2.4 /</td><td>5.6</td><td></td><td></td></tr><tr><td>ContextNet</td><td>Full-context</td><td>31.4</td><td>2.4 /</td><td>5.4</td><td></td><td></td></tr><tr><td>Conformer</td><td>Full-context</td><td>30.7</td><td>2.3 /</td><td>5.0</td><td></td><td></td></tr><tr><td>Transformer</td><td>Streaming</td><td>18.9</td><td>5.0 /</td><td>11.6</td><td>80</td><td>190</td></tr><tr><td>ContextNet</td><td>Streaming</td><td>31.4</td><td>4.5 /</td><td>10.0</td><td>70</td><td>270</td></tr><tr><td>Conformer</td><td>Streaming</td><td>30.7</td><td>4.6</td><td>9.9</td><td>140</td><td>280</td></tr><tr><td>ContextNet Look-ahead</td><td>Streaming</td><td>31.4</td><td>4.1 /</td><td>9.0</td><td>150</td><td>420</td></tr><tr><td>Dual-mode Transformer</td><td>Full-context Streaming</td><td>29</td><td>3.1 4.4 (-0.6)</td><td>/7.9 ) / 11.5 (-0.1)</td><td>-50 (-130)</td><td>30 (-160)</td></tr><tr><td>Dual-mode ContextNet</td><td>Full-context Streaming Full-context</td><td>31.8</td><td>2.3 / 5.3 3.9 (-0.6) / 8.5 (-1.5) 2.5 / 5.9</td><td></td><td>40 (-30)</td><td>160 (-110)</td></tr><tr><td>Dual-mode Conformer</td><td>Streaming</td><td>30.7</td><td>3.7 (-0.9) /</td><td>/9.2 (-0.7)</td><td>10 (-130)</td><td>90 (-190)</td></tr></table>
+
+# 4.2 ABLATION STUDY
+
+In this section, we perform various ablation studies to support and understand the effectiveness of each technique in Dual-mode ASR. We train Dual-mode ContextNet on LibriSpeech training set with exactly same settings and report WER, Latency $\textcircled { a } 5 0$ and Latency $@ 9 0$ on TestOther set of streaming mode. We specifically study three techniques and their combinations including weight sharing, joint training and inplace knowledge distillation during the training.
+
+During the training we distill knowledge from full-context mode (teacher) into streaming mode (student) on the fly within the same dual-mode model. Inplace distillation during the training comes for free as shown in training Algorithm 1. But what if we simply share weights and jointly train them without distillation? As shown in the second row of Table 4, the model without inplace distillation during the training has worse results compared to the baseline.
+
+Given a batch of data for each training iteration, we train both modes and aggregate their losses. We also show results of randomly sampled training in the third row of Table 4, which leads to even worse performance. Note that with randomly sampled training, we cannot apply inplace distillation easily either because in each training iteration there is only one prediction from either streaming mode or full-context mode.
+
+Weight sharing reduces the model size which is one of the major motivation of Dual-mode ASR. However, what if we simply train two individual models and use knowledge distillation with fullcontext model as the teacher? As shown in the last row of Table 4, the results are better than other ablation but still worse than the Dual-mode ASR baseline. It might indicate that weight sharing itself encourages learning better deep representation for streaming ASR. Weight sharing has been shown empirically to improve Multilingual ASR (Kannan et al., 2019), Model Pruning (Wu et al., 2020), Endpointing (Hochreiter & Schmidhuber, 1997) and some Computer Vision problems (Yu et al., 2018) and this intriguing property need to be studied in more details as a future work.
+
+Table 4: Ablation studies of weight sharing, joint training and inplace distillation. We report WER on TestOther (noisy) set (Panayotov et al., 2015) using ContextNet with same training settings.   
+
+<table><tr><td>Weight Sharing</td><td>Joint Training</td><td>Inplace Distillation</td><td>TestOther WER(%)</td><td>Latency@50 (ms)</td><td>Latency @90 (ms)</td></tr><tr><td></td><td></td><td>r</td><td>8.5</td><td>40</td><td>160</td></tr><tr><td>&lt;</td><td></td><td>×</td><td>10.2 (+1.7)</td><td>120 (+80)</td><td>310 (+150)</td></tr><tr><td>厂</td><td>×</td><td>×</td><td>10.6 (+2.1)</td><td>90 (+50)</td><td>290 (+130)</td></tr><tr><td>×</td><td></td><td>？</td><td>9.9 (+1.4)</td><td>50 (+10)</td><td>210 (+50)</td></tr></table>
+
+Further, we visualize the emission lattices of dual-mode ASR models trained with and without inplace knowledge distillation. We randomly sampled two audio sequences on LibriSpeech TestOther set and plotted their emission lattices of streaming mode in Figure 4. X-axis represents the speech input frames while Y-axis represents the text output labels (tokens). Figure 4 shows that with knowledge distillation from full-context mode in Dual-mode ASR, streaming mode emits faster and has much less latency, which is very critical for product datasets like MultiDomain presented in our work.
+
+![](images/2790e3f68de9406341cefca41a790dd745ff79ccd9bab20b7914a7f7f1c84193.jpg)  
+Figure 4: Two speech-text pair comparison of Dual-model ASR models trained with and without inplace distillation by visualization of their streaming emission lattices. $\mathbf { X }$ -axis represents the speech input frames while Y-axis represents the text output labels (tokens). Inplace distillation significantly reduces emission latency of streaming mode in Dual-mode ASR models which is critical in realworld applications.
+
+# 5 CONCLUSION
+
+In this work, we have proposed a unified framework, Dual-mode ASR, to unify and improve streaming ASR by joint full-context modeling. We hope our exploration will inspire streaming models in other fields such as simultaneous machine translation and video processing.
+
+# REFERENCES
+
+Naveen Arivazhagan, Colin Cherry, Wolfgang Macherey, Chung-Cheng Chiu, Semih Yavuz, Ruoming Pang, Wei Li, and Colin Raffel. Monotonic infinite lookback attention for simultaneous machine translation. In ACL, 2019.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
+
+Dzmitry Bahdanau, Jan Chorowski, Dmitriy Serdyuk, Philemon Brakel, and Yoshua Bengio. Endto-end attention-based large vocabulary speech recognition. In 2016 IEEE international conference on acoustics, speech and signal processing (ICASSP), pp. 4945–4949. IEEE, 2016.
+
+Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. arXiv preprint arXiv:1505.05424, 2015.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 ieee symposium on security and privacy (sp), pp. 39–57. IEEE, 2017.
+
+William Chan, Navdeep Jaitly, Quoc Le, and Oriol Vinyals. Listen, attend and spell: A neural network for large vocabulary conversational speech recognition. In 2016 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4960–4964. IEEE, 2016.
+
+Shuo-Yiin Chang, Rohit Prabhavalkar, Yanzhang He, Tara N Sainath, and Gabor Simko. Joint endpointing and decoding with end-to-end models. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5626–5630. IEEE, 2019.
+
+Shuo-Yiin Chang, Bo Li, David Rybach, Yanzhang He, Wei Li, Tara Sainath, and Trevor Strohman. Low latency speech recognition using end-to-end prefetching. In Interspeech. ISCA, 2020.
+
+Tianqi Chen, Ian Goodfellow, and Jonathon Shlens. Net2net: Accelerating learning via knowledge transfer. arXiv preprint arXiv:1511.05641, 2015.
+
+Chung-Cheng Chiu and Colin Raffel. Monotonic chunkwise attention. arXiv preprint arXiv:1712.05382, 2017.
+
+Chung-Cheng Chiu and Colin Raffel. Monotonic chunkwise attention. In International Conference on Learning Representations, 2018.
+
+Chung-Cheng Chiu, Wei Han, Yu Zhang, Ruoming Pang, Sergey Kishchenko, Patrick Nguyen, Arun Narayanan, Hank Liao, Shuyuan Zhang, Anjuli Kannan, Rohit Prabhavalkar, Zhifeng Chen, Tara Sainath, and Yonghui Wu. A comparison of end-to-end models for long-form speech recognition. In ASRU, 2019.
+
+Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1251–1258, 2017.
+
+Jan Chorowski and Navdeep Jaitly. Towards better decoding and language model integration in sequence to sequence models. arXiv preprint arXiv:1612.02695, 2016.
+
+Jan Chorowski, Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. End-to-end continuous speech recognition using attention-based recurrent nn: First results. arXiv preprint arXiv:1412.1602, 2014.
+
+Jan K Chorowski, Dzmitry Bahdanau, Dmitriy Serdyuk, Kyunghyun Cho, and Yoshua Bengio. Attention-based models for speech recognition. In Advances in neural information processing systems, pp. 577–585, 2015.
+
+Ruchao Fan, Pan Zhou, Wei Chen, Jia Jia, and Gang Liu. An online attention-based model for speech recognition. arXiv preprint arXiv:1811.05247, 2018.
+
+Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N Dauphin. Convolutional sequence to sequence learning. arXiv preprint arXiv:1705.03122, 2017.
+
+Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An-´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.
+
+Alex Graves. Sequence transduction with recurrent neural networks. arXiv preprint arXiv:1211.3711, 2012.
+
+Alex Graves. Generating sequences with recurrent neural networks, 2013.
+
+Anmol Gulati, James Qin, Chung-Cheng Chiu, Niki Parmar, Yu Zhang, Jiahui Yu, Wei Han, Shibo Wang, Zhengdong Zhang, Yonghui Wu, et al. Conformer: Convolution-augmented transformer for speech recognition. arXiv preprint arXiv:2005.08100, 2020.
+
+Wei Han, Zhengdong Zhang, Yu Zhang, Jiahui Yu, Chung-Cheng Chiu, James Qin, Anmol Gulati, Ruoming Pang, and Yonghui Wu. Contextnet: Improving convolutional neural networks for automatic speech recognition with global context. arXiv preprint arXiv:2005.03191, 2020.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Yanzhang He, Tara N Sainath, Rohit Prabhavalkar, Ian McGraw, Raziel Alvarez, Ding Zhao, David Rybach, Anjuli Kannan, Yonghui Wu, Ruoming Pang, et al. Streaming end-to-end speech recognition for mobile devices. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6381–6385. IEEE, 2019.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 7132–7141, 2018.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.
+
+Wenyong Huang, Wenchao Hu, Yu Ting Yeung, and Xiao Chen. Conv-transformer transducer: Low latency, low frame rate, streamable end-to-end speech recognition. arXiv preprint arXiv:2008.05750, 2020.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Navdeep Jaitly, Quoc V Le, Oriol Vinyals, Ilya Sutskever, David Sussillo, and Samy Bengio. An online sequence-to-sequence model using partial conditioning. In Advances in Neural Information Processing Systems 29, pp. 5067–5075, 2016.
+
+Anjuli Kannan, Arindrima Datta, Tara N Sainath, Eugene Weinstein, Bhuvana Ramabhadran, Yonghui Wu, Ankur Bapna, Zhifeng Chen, and Seungji Lee. Large-scale multilingual speech recognition with a streaming end-to-end model. arXiv preprint arXiv:1909.05330, 2019.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Bo Li, Shuo-yiin Chang, Tara N Sainath, Ruoming Pang, Yanzhang He, Trevor Strohman, and Yonghui Wu. Towards fast and accurate streaming end-to-end asr. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6069–6073. IEEE, 2020a.
+
+Wei Li, James Qin, Chung-Cheng Chiu, Ruoming Pang, and Yanzhang He. Parallel rescoring with transformer for streaming on-device speech recognition. arXiv preprint arXiv:2008.13093, 2020b.
+
+Haoran Miao, Gaofeng Cheng, Changfeng Gao, Pengyuan Zhang, and Yonghong Yan. Transformerbased online ctc/attention end-to-end speech recognition architecture. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6084– 6088. IEEE, 2020.
+
+Niko Moritz, Takaaki Hori, and Jonathan Le Roux. Triggered attention for end-to-end speech recognition. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5666–5670. IEEE, 2019.
+
+Niko Moritz, Takaaki Hori, and Jonathan Le. Streaming automatic speech recognition with the transformer model. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6074–6078. IEEE, 2020.
+
+Arun Narayanan, Ananya Misra, Khe Chai Sim, Golan Pundak, Anshuman Tripathi, Mohamed Elfeky, Parisa Haghani, Trevor Strohman, and Michiel Bacchiani. Toward domain-invariant speech recognition via large scale training. In 2018 IEEE Spoken Language Technology Workshop (SLT), pp. 441–447. IEEE, 2018.
+
+Arun Narayanan, Tara N Sainath, Ruoming Pang, Jiahui Yu, Chung-Cheng Chiu, Rohit Prabhavalkar, Ehsan Variani, and Trevor Strohman. Cascaded encoders for unifying streaming and non-streaming asr. arXiv preprint arXiv:2010.14606, 2020.
+
+Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016.
+
+Vassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: an asr corpus based on public domain audio books. In 2015 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5206–5210. IEEE, 2015.
+
+Sankaran Panchapagesan, Daniel S Park, Chung-Cheng Chiu, Yuan Shangguan, Qiao Liang, and Alexander Gruenstein. Efficient knowledge distillation for rnn-transducer models. arXiv preprint arXiv:2011.06110, 2020.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE Symposium on Security and Privacy (SP), pp. 582–597. IEEE, 2016.
+
+Daniel S Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D Cubuk, and Quoc V Le. Specaugment: A simple data augmentation method for automatic speech recognition. arXiv preprint arXiv:1904.08779, 2019.
+
+Rohit Prabhavalkar, Tara N Sainath, Yonghui Wu, Patrick Nguyen, Zhifeng Chen, Chung-Cheng Chiu, and Anjuli Kannan. Minimum word error rate training for attention-based sequence-tosequence models. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4839–4843. IEEE, 2018.
+
+C. Raffel, M. Luong, P. J. Liu, R.J. Weiss, and D. Eck. Online and Linear-Time Attention by Enforcing Monotonic Alignments. In Proc. ICML, 2017.
+
+Prajit Ramachandran, Barret Zoph, and Quoc V Le. Searching for activation functions. arXiv preprint arXiv:1710.05941, 2017.
+
+Tara N Sainath, Ruoming Pang, David Rybach, Yanzhang He, Rohit Prabhavalkar, Wei Li, Mirko´ Visontai, Qiao Liang, Trevor Strohman, Yonghui Wu, et al. Two-pass end-to-end speech recognition. arXiv preprint arXiv:1908.10992, 2019.
+
+Tara N Sainath, Yanzhang He, Bo Li, Arun Narayanan, Ruoming Pang, Antoine Bruguier, Shuoyiin Chang, Wei Li, Raziel Alvarez, Zhifeng Chen, et al. A streaming on-device end-to-end model surpassing server-side conventional model quality and latency. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6059–6063. IEEE, 2020.
+
+Jonathan Shen, Patrick Nguyen, Yonghui Wu, Zhifeng Chen, Mia X Chen, Ye Jia, Anjuli Kannan, Tara Sainath, Yuan Cao, Chung-Cheng Chiu, et al. Lingvo: a modular and scalable framework for sequence-to-sequence modeling. arXiv preprint arXiv:1902.08295, 2019.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958, 2014.
+
+Emiru Tsunoo, Yosuke Kashiwagi, Toshiyuki Kumakura, and Shinji Watanabe. Towards online end-to-end transformer automatic speech recognition. arXiv preprint arXiv:1910.11871, 2019.
+
+Emiru Tsunoo, Yosuke Kashiwagi, and Shinji Watanabe. Streaming transformer asr with blockwise synchronous inference. arXiv preprint arXiv:2006.14941, 2020.
+
+Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 4068–4076, 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. 5998–6008, 2017.
+
+Chengyi Wang, Yu Wu, Shujie Liu, Jinyu Li, Liang Lu, Guoli Ye, and Ming Zhou. Low latency end-to-end streaming speech recognition with a scout network. arXiv preprint arXiv:2003.10369, 2020.
+
+Shinji Watanabe, Takaaki Hori, Suyoun Kim, John R Hershey, and Tomoki Hayashi. Hybrid ctc/attention architecture for end-to-end speech recognition. IEEE Journal of Selected Topics in Signal Processing, 11(8):1240–1253, 2017.
+
+Ronald J Williams and David Zipser. A learning algorithm for continually running fully recurrent neural networks. Neural computation, 1(2):270–280, 1989.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Zhaofeng Wu, Ding Zhao, Qiao Liang, Jiahui Yu, Anmol Gulati, and Ruoming Pang. Dynamic sparsity neural networks for automatic speech recognition. arXiv preprint arXiv:2005.10627, 2020.
+
+Ching-Feng Yeh, Jay Mahadeokar, Kaustubh Kalgaonkar, Yongqiang Wang, Duc Le, Mahaveer Jain, Kjell Schubert, Christian Fuegen, and Michael L Seltzer. Transformer-transducer: End-toend speech recognition with self-attention. arXiv preprint arXiv:1910.12977, 2019.
+
+Jiahui Yu and Thomas Huang. Autoslim: Towards one-shot architecture search for channel numbers. arXiv preprint arXiv:1903.11728, 2019a.
+
+Jiahui Yu and Thomas S Huang. Universally slimmable networks and improved training techniques. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1803–1811, 2019b.
+
+Jiahui Yu, Linjie Yang, Ning Xu, Jianchao Yang, and Thomas Huang. Slimmable neural networks. In International Conference on Learning Representations, 2018.
+
+Jiahui Yu, Pengchong Jin, Hanxiao Liu, Gabriel Bender, Pieter-Jan Kindermans, Mingxing Tan, Thomas Huang, Xiaodan Song, Ruoming Pang, and Quoc Le. Bignas: Scaling up neural architecture search with big single-stage models. arXiv preprint arXiv:2003.11142, 2020.
+
+Qian Zhang, Han Lu, Hasim Sak, Anshuman Tripathi, Erik McDermott, Stephen Koo, and Shankar Kumar. Transformer transducer: A streamable speech recognition model with transformer encoders and rnn-t loss. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 7829–7833. IEEE, 2020.

parse/train/Pz_dcqfcKW8/Pz_dcqfcKW8_content_list.json

@@ -0,0 +1,1558 @@
+[
+    {
+        "type": "text",
+        "text": "DUAL-MODE ASR: UNIFY AND IMPROVE STREAMING ASR WITH FULL-CONTEXT MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            84,
+            823,
+            132
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiahui $\\mathbf { Y u } ^ { 1 }$ Wei Han1† Anmol Gulati1† Chung-Cheng Chiu1 Bo Li2 Tara N. Sainath2 Yonghui Wu1 Ruoming Pang1 ",
+        "bbox": [
+            186,
+            146,
+            795,
+            181
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Google Brain 2Google LLC {jiahuiyu, rpang}@google.com ",
+        "bbox": [
+            374,
+            186,
+            645,
+            219
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            229,
+            544,
+            244
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Streaming automatic speech recognition (ASR) aims to emit each hypothesized word as quickly and accurately as possible, while full-context ASR waits for the completion of a full speech utterance before emitting completed hypotheses. In this work, we propose a unified framework, Dual-mode ASR, to train a single end-to-end ASR model with shared weights for both streaming and full-context speech recognition. We show that the latency and accuracy of streaming ASR significantly benefit from weight sharing and joint training of full-context ASR, especially with inplace knowledge distillation during the training. The Dual-mode ASR framework can be applied to recent state-of-the-art convolution-based and transformer-based ASR networks. We present extensive experiments with two state-of-the-art ASR networks, ContextNet and Conformer, on two datasets, a widely used public dataset LibriSpeech and a large-scale dataset MultiDomain. Experiments and ablation studies demonstrate that Dual-mode ASR not only simplifies the workflow of training and deploying streaming and full-context ASR models, but also significantly improves both emission latency and recognition accuracy of streaming ASR. With Dual-mode ASR, we achieve new state-of-the-art streaming ASR results on both LibriSpeech and MultiDomain in terms of accuracy and latency. ",
+        "bbox": [
+            233,
+            261,
+            766,
+            511
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            539,
+            336,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "“Ok Google. Hey Siri. Hi Alexa.” have featured a massive boom of smart speakers in recent years, unveiling a trend towards ubiquitous and ambient Artificial Intelligence (AI) for better daily lives. As the communication bridge between human and machine, low-latency streaming ASR (a.k.a., online ASR) is of central importance, whose goal is to emit each hypothesized word as quickly and accurately as possible on the fly as they are spoken. On the other hand, there are some scenarios where full-context ASR (a.k.a., offline ASR) is sufficient, for example, offline video captioning on video-sharing platforms. While low-latency streaming ASR is generally preferred in most of the speech recognition scenarios, it often has worse prediction accuracy as measured in Word Error Rate (WER), due to the lack of future context compared with full-context ASR. Improving both WER and emission latency has been shown to be highly challenging (He et al., 2019; Li et al., 2020a; Sainath et al., 2020) in streaming ASR systems. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            724
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Since the acoustic, pronunciation, and language model (AM, PM, and LM) of a conventional ASR system have been evolved into a single end-to-end (E2E) all-neural network, modern streaming and full-context ASR models share most of the neural architectures and training recipes in common, such as, Mel-spectrogram inputs, data augmentations, neural network meta-architectures, training objectives, model regularization techniques and decoding methods. The most significant difference is that streaming ASR encoders are auto-regressive models, with the prediction of the current timestep conditioned on previous ones (no future context is permitted). Specifically, let $x$ and $y$ be the input and output sequence, $t$ as frame index, $T$ as total length of frames. Streaming ASR encoders model the output $y _ { t }$ as a function of input $x _ { 1 : t }$ while full-context ASR encoders model the output $y _ { t }$ as a function of input $x _ { 1 : T }$ . Streaming ASR encoders can be built with uni-directional LSTMs, causal convolution and left-context attention layers in streaming ASR encoders (Chiu & Raffel, 2018; Fan et al., 2018; Han et al., 2020; Gulati et al., 2020; Huang et al., 2020; Moritz et al., 2020; Miao et al., 2020; Tsunoo et al., 2020; Zhang et al., 2020; Yeh et al., 2019). Recurrent Neural Network Transducers (RNN-T) (Graves, 2012) are commonly used as the decoder in both streaming and fullcontext models, which predicts the token of the current input frame based on all previous tokens using uni-directional recurrent layers. Figure 1 illustrates a simplified example of the similarity and difference between streaming and full-context ASR models with E2E neural networks. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1f34c27d36c1a06c1d05b32cf8f7d91905338b9c64253cb7fcd9d2936456a44.jpg",
+        "image_caption": [
+            "Figure 1: A simplified illustration of the similarity and difference between Streaming ASR and Fullcontext ASR networks. Modern end-to-end streaming and full-context ASR models share most of the neural architectures and training recipes in common, with the most significant difference in the ASR encoder (highlighted). Streaming ASR encoders are auto-regressive models, with each prediction of the current timestep conditioned on previous ones (no future context). We show examples of feed-forward layer, convolution layer and self-attention layer in the encoder of streaming and full-context ASR respectively. With Dual-mode ASR, we unify them without parameters overhead. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            98,
+            790,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            547,
+            823,
+            617
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Albeit the similarities, streaming and full-context ASR models are usually developed, trained, and deployed separately. In this work, we propose Dual-mode ASR, a framework to unify streaming and full-context speech recognition networks with shared weights. Dual-mode ASR comes with many immediate benefits, including reduced model download and storage on devices and simplified development and deployment workflows. To accomplish this goal, we first introduce Dual-mode Encoders, which can run in both streaming mode and full-context mode. Dual-mode encoders are designed to reuse the same set of model weights for both modes with zero or near-zero parameters overhead. We propose the design principles of a dual-mode encoder and show examples on how to design dual-mode convolution, dual-mode pooling, and dual-mode attention layers. We also investigate into different training algorithms for Dual-mode ASR, specifically, randomly sampled training and joint training. We show that joint training significantly outperforms randomly sampled training in terms of model quality and training stability. Moreover, motivated by Inplace Knowledge Distillation (Yu & Huang, 2019b) in which a large model is used to supervise a small model, we propose to distill knowledge from the full-context mode (teacher) into the streaming mode (student) on the fly during the training within the same Dual-mode ASR model, by encouraging consistency of the predicted token probabilities. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate that the emission latency and prediction accuracy of streaming ASR significantly benefit from weight sharing and joint training of its full-context mode, especially with inplace knowledge distillation during the training. We present extensive experiments with two state-of-theart ASR networks, convolution-based ContextNet (Han et al., 2020) and conv-transformer hybrid Conformer (Gulati et al., 2020), on two datasets, a widely used public dataset LibriSpeech (Panayotov et al., 2015) (970 hours of English reading speech) and a large-scale dataset MultiDomain (Narayanan et al., 2018) (413,000 hours speech of a mixture across multiple domains including Voice Search, Farfield Speech, YouTube and Meetings). For each proposed technique, we also present ablation study and analysis to demonstrate and understand the effectiveness. With Dual-mode ASR, we achieve new state-of-the-art streaming ASR results on both LibriSpeech and MultiDomain in terms of accuracy and latency. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            214,
+            344,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Streaming ASR Networks. There has been a growing interest in building streaming ASR systems based on E2E Recurrent Neural Network Transducers (RNN-T) (Graves, 2012). Compared with sequence-to-sequence models (Chorowski et al., 2014; 2015; Chorowski & Jaitly, 2016; Bahdanau et al., 2016; Chan et al., 2016), RNN-T models are naturally streamable and have shown great potentials for low-latency streaming ASR (Chang et al., 2019; He et al., 2019; Tsunoo et al., 2019; Sainath et al., 2019; Shen et al., 2019; Li et al., 2020a;b; Sainath et al., 2020; Huang et al., 2020; Moritz et al., 2020; Narayanan et al., 2020). In this work, we mainly focus on RNN-T based models. He et al. specifically studied how to optimize the RNN-T streaming ASR model for mobile devices, and proposed a bag of techniques including using layer normalization and large batch size to stabilize training; using word-piece targets (Wu et al., 2016); using a time-reduction layer to speed up training and inference; quantizing network parameters to reduce memory footprint and speed up computation; applying shallow-fusion to bias towards user-specific context. To support streaming modeling in E2E ASR models, various efforts have also been made by modifying attention-based models such as monotonic attention (Raffel et al., 2017; Chiu & Raffel, 2017; Fan et al., 2018; Arivazhagan et al., 2019), GMM attention (Graves, 2013; Chiu et al., 2019), triggered attention (TA) (Moritz et al., 2019), Scout Network (Wang et al., 2020), and approaches that segment encoder output into non-overlapping chunks (Jaitly et al., 2016; Tsunoo et al., 2020). Tsunoo et al. also applied knowledge distillation from the non-streaming model to the streaming model, but their streaming and non-streaming models do not share weights and are trained separately. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To improve the latency of RNN-T streaming models, Li et al. investigated additional early and late penalties on Endpointer prediction (Chang et al., 2019) to reduce the emission latency, and employed the minimum word error rate (MWER) training (Prabhavalkar et al., 2018) to remedy accuracy degradation. Sainath et al. further proposed to improve quality by using two-pass models (Sainath et al., 2019), i.e., a second-pass LAS-based rescore model on top of the hypotheses from first-pass RNN-T streaming output. More recently, Li et al. proposed parallel rescoring by replacing LSTMs with Transformers (Vaswani et al., 2017) in rescoring models. Chang et al. further proposed Prefetching to reduce system latency by submitting partial recognition results for subsequent processing such as obtaining assistant server responses or second-pass rescoring before the recognition result is finalized. Unlike these approaches, our work explores the unification of streaming and fullcontext ASR networks, thus can be generally applied as an add-on technique without requiring extra runtime support during inference. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            686
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Weight Sharing for Multi-tasking. Sharing model weights of a deep neural network for multiple tasks has been widely explored in the literature to reduce overall model sizes. In the broadest sense, tasks can refer to different objectives or same objective but different settings, ranging from natural language processing and speech recognition to computer vision and reinforcement learning. In speech recognition, Kannan et al. employed a single ASR network for multilingual ASR, and showed accuracy improvements over monolingual ASR systems. Wu et al. proposed dynamic sparsity neural networks (DSNN) for speech recognition on mobile devices with resource constraints. A single trained DSNN (Wu et al., 2020) can transform into multiple networks of different sparsities for adaptive inference in real-time. Chang et al. trained a single RNN-T model with LSTMs (Hochreiter & Schmidhuber, 1997) for Joint Endpointing (i.e., predicting both recognition tokens and the end of an utterance transcription) in streaming ASR systems. Moreover, Watanabe et al. proposed a hybrid CTC and attention architecture for ASR based on multi-objective learning to eliminate the use of linguistic resources. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another related research work in Computer Vision is Slimmable Neural Networks (Yu et al., 2018; Yu & Huang, 2019a;b; Yu et al., 2020). Yu et al. proposed an approach to train a single neural network running at different widths, permitting instant and adaptive accuracy efficiency trade-offs at runtime. We also adapt the training rules introduced in slimmable networks, that is, using independent normalization layers for different sub-networks (tasks) as conditional parameters and using the prediction of teacher network to supervise student network as inplace distillation during the training. Unlike slimmable networks in which a large model is used to supervise a small model, we propose to distill the knowledge from full-context mode (teacher) into streaming mode (student) on the fly within the same Dual-mode ASR model. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            186
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Knowledge Distillation. Hinton et al. explored a simple method to “transfer” knowledge from a teacher neural network to a student neural network by enforcing their predictions to be close measured by KL-divergence, $\\ell _ { 1 }$ or $\\ell _ { 2 }$ distance. It is shown that such distillation method is effective to compress neural networks (Yu & Huang, 2019b), accelerate training (Chen et al., 2015), improve robustness (Carlini & Wagner, 2017; Papernot et al., 2016), estimate model uncertainty (Blundell et al., 2015) and transfer learned domain to other domains (Tzeng et al., 2015). ",
+        "bbox": [
+            174,
+            194,
+            825,
+            277
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 DUAL-MODE ASR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            299,
+            357,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Most neural sequence transduction networks for ASR have an encoder-decoder structure (Graves, 2012; Sainath et al., 2020; He et al., 2019; Li et al., 2020a), as shown in Figure 1. Without loss of generality, here we discuss how to design Dual-mode ASR networks under the most commonly used RNN-T model (Graves, 2012). In RNN-T models, we first extract mel-spectrogram feature from input speech waveform. The Mel-spectrogram feature is then fed into a neural-net encoder, which usually consists of feed-forward layers, RNN/LSTM layers, convolution layers, attention layers, pooling (time-reduction) layers, and residual or dense connections. In neural-net encoders, streaming ASR model requires all components to be auto-regressive, whereas full-context ASR model has no such requirement. The ASR decoder then predicts the token of current frame based on the output from the encoder and previous predicted tokens (inference) or target tokens (training with teacher forcing (Williams & Zipser, 1989)). The decoder is commonly an auto-regressive model in both streaming and full-context ASR models, thus is fully shared in Dual-mode ASR. The prediction from decoder is finally used either in decoding algorithm during inference (e.g., beam search) or learning algorithm during training (e.g., RNN-T loss). ",
+        "bbox": [
+            174,
+            332,
+            825,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As discussed above and shown in Figure 1, it becomes clear that the major difference between streaming and full-context ASR models is in the neural-net encoder. In the following, we will first discuss the design principles of dual-mode encoder to support both streaming and full-context ASR. We provide examples including dual-mode convolution, dual-mode average pooling, and dual-mode attention layers, which are widely used in the state-of-the-art ASR networks ContextNet (Han et al., 2020) and Conformer (Gulati et al., 2020). We will then discuss the training algorithm of Dual-mode ASR networks including joint training and inplace knowledge distillation. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            630
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 DUAL-MODE ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            377,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unifying streaming and full-context ASR models requires two design principles of Dual-mode Encoder: ",
+        "bbox": [
+            176,
+            674,
+            823,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Each layer in a dual-mode encoder should be either dual-mode or streaming (a.k.a., causal). Since streaming encoder has to be auto-regressive which prohibits any future context, any full-context (a.k.a., non-causal) layer violates this constraint.   \n2. The design of a dual-mode layer should not introduce significant amount of additional parameters, compared with its streaming model. We aim at supporting full-context ASR on top of the streaming model with near-zero parameters overhead. ",
+        "bbox": [
+            212,
+            709,
+            823,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We show examples below by applying the above two design principles to ContextNet (Han et al., 2020) and Conformer (Gulati et al., 2020), in which the encoders are composed of pointwise operators (feed-forward net, residual connections, activation layers, striding, dropout, etc.), convolution, average pooling, self-attention and normalization layers. ",
+        "bbox": [
+            176,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pointwise operators are naturally dual-mode layers. Neural network layers that connect input and output neurons within each timestep (no across-connections among different timesteps) are often referred as pointwise operators (Chollet, 2017), including feed-forward layers (a.k.a., fullyconnected layers or $1 \\times 1$ convolution layers), activation layers (e.g., ReLU, Swish (Ramachandran et al., 2017)), residual and dense connections (He et al., 2016; Huang et al., 2017), striding layers, dropout layers (Srivastava et al., 2014) and element-wise multiplications. As there is no information propagation through time, pointwise operators are naturally dual-mode layers and can be directly used in Dual-mode ASR encoders. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0ab9aa67a0046df1f58ffff9f82dde0ba719a2847b80d942aac195b112a5175.jpg",
+        "image_caption": [
+            "Figure 2: Dual-mode convolution and average pooling layer for Dual-mode ASR. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            821,
+            228
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            284,
+            825,
+            339
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dual-mode Convolution. Convolution layers, however, convolve feature across its neighbor timesteps within a fixed window (e.g., kernel size is 3, 5, or larger), and has been widely used in sequence modeling (Gehring et al., 2017; Han et al., 2020; Gulati et al., 2020). In conv-based streaming ASR models, causal convolution layers (Oord et al., 2016) are used where the convolution window is biased to the left (self-included). As shown in Figure 2 on the left, to support both streaming and full-context modes with shared weights, we first construct a normal symmetric convolution of kernel size $k$ which will be applied in full-context mode. Then we mimic the causal convolution of kernel size $( k + 1 ) / 2$ by constructing a Boolean mask and multiplying with the fullcontext convolution kernel before applying the actual convolution of streaming mode in Dual-mode ASR encoders. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            486
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The design of dual-mode convolution introduces $( k - 1 ) / 2$ additional parameters to support fullcontext convolution $( k )$ compared with streaming convolution $( ( k + 1 ) / 2 )$ . However, we note that in convolution-based models, these temporal-wise convolution layers only take a tiny amount of total model size and most of the weights are on $1 \\times 1$ convolution layers which are fully shared pointwise operators. For example, in ContextNet (Han et al., 2020), temporal-wise convolution has less than $1 \\%$ of total model size, thus parameters overhead is negligible. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dual-mode Average Pooling. Squeeze-and-excitation (Hu et al., 2018) (SE) modules are used in ContextNet to enhance the global context encoding. Each SE module is a sequential stack of average pooling (through time) layer, feed-forward layer, activation layer, another feed-forward layer and elementwise multiplication. To support both modes, dual-mode average pooling layer is used as shown in Figure 2 on the right. Dual-mode average pooling layer is parameter-free thus does not introduce additional model parameters. It also trains in parallel in streaming mode, easily implemented with “cumsum” function in both TensorFlow and PyTorch. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            681
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dual-mode Self-attention. Self-attention (a.k.a. intra-attention) is an attention mechanism weighting different positions of a single sequence in order to compute a representation of the same sequence. It is heavily used in Conformer (Gulati et al., 2020) ASR networks. The attention layer itself is parameter-free (projection layers before attention are fully shared), and is composed of matrix multiplication of the key and the query, followed by softmax over keys, before another matrix multiplication with the value. As shown in Figure 3, in dual-mode attention layer, the softmax is performed on the left context only in streaming mode (rectangle with solid line), compared with the full-context mode (rectangle with dash line). We find this simple form of dual-mode self-attention works well in practice. ",
+        "bbox": [
+            174,
+            689,
+            483,
+            917
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f528f18a6c4aa9e2a4f6bb67f082a371fc76eca55334f921678afdf1c5f1264.jpg",
+        "image_caption": [
+            "Figure 3: Dual-mode self-attention layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            705,
+            816,
+            885
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            910,
+            589,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Pseudocode of training Dual-mode ASR networks. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            596,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "# Requires: data_loader; context manager with support of mode switching by network.mode(); dual_mode_network with support of running both modes under context manager;   \nfor x, y in data_loader: # Load a minibatch of speech input x and text label y. with dual_mode_network.mode(’fullcontext’): # Switch context to ’fullcontext’ mode. # Compute full-context prediction given speech input x and text label y. fullcontext_pred $=$ dual_mode_network.forward_encoder_decoder(x, y) # Compute RNN-T loss of full-context mode. fullcontext_loss $=$ rnnt_loss(fullcontext_pred, y) ",
+        "bbox": [
+            173,
+            128,
+            808,
+            212
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "with dual_mode_network.mode(’streaming’): # Switch context to ’streaming’ mode. # Compute streaming prediction given speech input x and text label y. streaming_pred $=$ dual_mode_network.forward_encoder_decoder(x, y) # Compute RNN-T loss of streaming mode. streaming_loss $=$ rnnt_loss(streaming_pred, y) ",
+        "bbox": [
+            194,
+            219,
+            758,
+            266
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "# Add inplace knowledge distillation loss (full-context prediction as teacher). distill_loss $=$ inplace_distill_loss(streaming_pred, stop_gradient(fullcontext_pred) ",
+        "bbox": [
+            191,
+            273,
+            779,
+            294
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "# Compute total loss as a sum of full-context, streaming and distillation losses. loss $=$ fullcontext_loss $^ +$ streaming_loss $^ +$ distill_loss   \nloss.backward() # Update weights. ",
+        "bbox": [
+            192,
+            301,
+            764,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dual-mode Normalization. Moreover, following Yu et al. (2018), we also find the normalization statistics like means and variances are different in streaming and full-context modes. Thus, for normalization layers including BatchNorm (Ioffe & Szegedy, 2015) and LayerNorm (Ba et al., 2016) in Dual-mode ContextNet and Dual-mode Conformer, we instantiate two separate norm layers dedicated to streaming and full-context mode respectively. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            436
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 TRAINING DUAL-MODE ASR NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            455,
+            503,
+            469
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The training algorithm of Dual-mode ASR networks is outlined in Algorithm 1. In this section, we discuss two important training techniques: joint training and inplace knowledge distillation. ",
+        "bbox": [
+            174,
+            482,
+            823,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Joint Training. To train Dual-mode ASR networks, given a batch of data in each training iteration, we can either randomly sample one from two modes to train, or train both modes and aggregate their losses. In the former approach, referred as randomly sampled training, we can control the importance of streaming and full-context modes by setting different sampling probabilities during training. In the latter approach, referred as joint training, importance can also be controlled by assigning different loss weights to balance streaming and full-context modes. Empirically we find joint training leads to better model qualities overall thus is adopted in all of our experiments. We will show an ablation study comparing randomly sampled training and joint training. In all of our experiments, we treat streaming and full-context mode to be equally important by assigning equal importance during training. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inplace Knowledge Distillation. Additionally we propose to distill knowledge from the full-context mode (teacher) into the streaming mode (student) on the fly within the same Dual-mode ASR model, by encouraging consistency of the predicted token probabilities. Since in each iteration we always compute predictions of both modes, the teacher prediction comes for free (no additional computation or memory cost), as shown in Algorithm 1. We use the efficient knowledge distillation introduced by Panchapagesan et al., which is based on the KL-divergence between full-context and streaming over the probability of three parts: $P _ { l a b e l }$ , $P _ { b l a n k }$ and $1 - P _ { l a b e l } - P _ { b l a n k }$ . We note that the prediction of full-context mode (teacher) usually has lower latency (since it has no incentive to delay its output), thus we can control the target emission latency of streaming mode (student) by shifting the prediction of full-context mode, before applying distillation loss. We do a small-scale hyper-parameter sweep from -2 to 2 frames to shift for ContextNet and Conformer in our experiments. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            815
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            326,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 MAIN RESULT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            868,
+            313,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Measuring Latency. Latency measurement is itself challenging for streaming ASR systems. Motivated by Prefetching (Chang et al., 2020) technique, we measure latency as the difference of two timestamps: 1) when the last token is emitted in the finalized recognition result; 2) the end of the speech when a user finishes speaking. We find this is especially descriptive of user experience in real-world ASR applications like Voice Search. ASR models that capture stronger contexts can emit the full hypothesis even before they are spoken, leading to a negative latency. Moreover, instead of naively averaging latency over all utterances, we report both median and 90th percentile of all utterances in test set, denoted as Latency $\\textcircled{6} 5 \\mathbf { 0 }$ and Latency $@ 9 0$ , to better characterize latency by excluding outlier utterances. To evaluate the model quality, we report WER only for full-context models and both WER and latency for streaming models (full-context latency is meaningless). ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We conduct our experiments on two datasets: a public widely used dataset LibriSpeech (Panayotov et al., 2015) (1,000 hours of English reading speech) and a large-scale dataset MultiDomain (413,000 hours speech, 287 million utterances of a mixture across multiple domains including Voice Search, YouTube, and Meetings). Table 1 summarizes the information and statistics of two datasets. For LibriSpeech, we report our evaluation results on TestClean and TestOther (noisy) sets and compare with other published baselines. For MultiDomain, we report our evaluation results on Voice Search test set and compare with our reproduced baselines. For fair comparisons, on each dataset we train and report our models and baselines with the same settings (number of training iterations, hyper-parameters, optimizer, regularization, etc.). We note that these hyper-parameters are inherited from previous work Han et al. (2020); Gulati et al. (2020) and not specifically tuned for our dual-mode models. ",
+        "bbox": [
+            173,
+            222,
+            825,
+            375
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/be1805aabb344e0515a36ac5e6b0ba541b29fd5c01dde0e87d722b5384bd79c8.jpg",
+        "table_caption": [
+            "Table 1: Summary of datasets we used in our experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset Name</td><td>#Hours</td><td># Utterances</td><td>Speech Domain</td></tr><tr><td>LibriSpeech (Panayotov et al., 2015)</td><td>~970</td><td>~ 281,000</td><td>Single domain of English reading speech.</td></tr><tr><td>MultiDomain (Narayanan et al., 2018)</td><td>~ 413,000</td><td>~ 287,000,000</td><td>Multiple domains including: Voice Search, Farfield Speech, YouTube and Meetings.</td></tr></table>",
+        "bbox": [
+            187,
+            424,
+            810,
+            508
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ASR Networks. We use two recent state-of-the-art ASR networks to demonstrate the effectiveness of our proposed methods, ContextNet (Han et al., 2020) and Conformer (Gulati et al., 2020). The encoder of ContextNet is based on depthwise-separable convolution (Chollet, 2017) and squeezeand-excitation modules (Hu et al., 2018). In depthwise-separable convolution of Dual-mode ContextNet, the weights of $1 \\times 1$ convolutions are fully shared between streaming and full-context mode, whereas for temporal-wise convolution we follow the design of Dual-mode Convolution proposed in Section 3.1. Note that in ContextNet, temporal-wise convolutions only take less than $1 \\%$ of the model size thus the parameters overhead of full-context mode is negligible compared with steaming mode. In squeeze-and-excitation modules, we use dual-mode average pooling layers (Section 3.1) to support both streaming and full-context mode without additional parameters. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Conformer (Gulati et al., 2020) combines convolution and transformer to model both local and global dependencies of speech sequences in a parameter-efficient way. In Dual-mode Conformer, we replace all convolution and transformer layers with their dual-mode correspondents (Section 3.1). Moreover, for normalization layers including BatchNorm (Ioffe & Szegedy, 2015) and LayerNorm (Ba et al., 2016) in Dual-mode ContextNet and Dual-mode Conformer, we instantiate two separate norm layers for streaming and full-context mode respectively. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training Details and Results. We train our models exactly following our baselines ContextNet (Han et al., 2020) and Conformer (Gulati et al., 2020), using Adam optimizer (Kingma & Ba, 2014), SpecAugment (Park et al., 2019) and a transformer learning rate schedule (Vaswani et al., 2017) with warm-up (Goyal et al., 2017). Our main results are summarized in Table 2 and Table 3. We also add a streaming ContextNet Look-ahead baseline (6 frames, 10ms per frame, totally 60ms look-ahead latency) in Table 3 by padding additional frames at the end of the input utterances. As shown in the tables, the streaming mode in Dual-mode ASR models has significantly better latency and similar or higher WER results, surpassing other baselines including conventional models, LSTM-based transducers (Sainath et al., 2020), transformer-transducers (Zhang et al., 2020) and some others. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/01b3de26cded2e99da0350cf01143d9736b0ba8d84e81d9d1f824432ea64e781.jpg",
+        "table_caption": [
+            "Table 2: Summary of our results on MultiDomain dataset (Narayanan et al., 2018). We report WER on Voice Search test set. Compared with standalone ContextNet and Conformer models, Dual-mode ASR models have slightly higher accuracy and much better streaming latency. ASR models that capture stronger contexts can emit the full hypothesis even slightly before they are spoken, leading to a negative latency. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Mode</td><td># Params (M)</td><td>VS Test WER(%)</td><td>Latency @50 (ms)</td><td>Latency @90 (ms)</td></tr><tr><td>ContextNet Conformer</td><td>Full-context Full-context</td><td>133 142</td><td>5.1 5.2</td><td></td><td></td></tr><tr><td>LSTM (Sainath et al., 2020) ContextNet (Han et al.,2020)</td><td>Streaming Streaming</td><td>179 133</td><td>6.4 6.1</td><td>190 160</td><td>350 310</td></tr><tr><td>Conformer (Gulati et al., 2020) Dual-mode ContextNet</td><td>Streaming Full-context</td><td>142 133</td><td>6.1 4.9</td><td>160</td><td>300</td></tr><tr><td>Dual-mode Conformer</td><td>Streaming Full-context Streaming</td><td>142</td><td>6.0 (-0.1) 5.0 6.0 (-0.1)</td><td>10 (-150) -50 (-210)</td><td>220 (-90) 130 (-170)</td></tr></table>",
+        "bbox": [
+            173,
+            171,
+            830,
+            344
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d84d5519f37aa5c023b05761f09ba164efad25ece383d51837c7be6b531891a3.jpg",
+        "table_caption": [
+            "Table 3: Summary of our results on Librispeech dataset (Panayotov et al., 2015). We report WER on TestClean and TestOther (noisy) set. Compared with standalone ContextNet and Conformer models, Dual-mode ASR models have both higher accuracy in average and better streaming latency. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Mode</td><td># Params (M)</td><td>Test Clean/Other WER(%)</td><td></td><td>Latency@50 (ms)</td><td>Latency @90 (ms)</td></tr><tr><td>LSTM-LAS</td><td>Full-context</td><td>360</td><td>2.6 /</td><td>6.0</td><td></td><td></td></tr><tr><td>QuartzNet-CTC</td><td>Full-context</td><td>19</td><td>3.9 /</td><td>11.3</td><td></td><td></td></tr><tr><td>Transformer</td><td>Full-context</td><td>29</td><td>3.1 /</td><td>7.3</td><td></td><td></td></tr><tr><td>Transformer</td><td>Full-context</td><td>139</td><td>2.4 /</td><td>5.6</td><td></td><td></td></tr><tr><td>ContextNet</td><td>Full-context</td><td>31.4</td><td>2.4 /</td><td>5.4</td><td></td><td></td></tr><tr><td>Conformer</td><td>Full-context</td><td>30.7</td><td>2.3 /</td><td>5.0</td><td></td><td></td></tr><tr><td>Transformer</td><td>Streaming</td><td>18.9</td><td>5.0 /</td><td>11.6</td><td>80</td><td>190</td></tr><tr><td>ContextNet</td><td>Streaming</td><td>31.4</td><td>4.5 /</td><td>10.0</td><td>70</td><td>270</td></tr><tr><td>Conformer</td><td>Streaming</td><td>30.7</td><td>4.6</td><td>9.9</td><td>140</td><td>280</td></tr><tr><td>ContextNet Look-ahead</td><td>Streaming</td><td>31.4</td><td>4.1 /</td><td>9.0</td><td>150</td><td>420</td></tr><tr><td>Dual-mode Transformer</td><td>Full-context Streaming</td><td>29</td><td>3.1 4.4 (-0.6)</td><td>/7.9 ) / 11.5 (-0.1)</td><td>-50 (-130)</td><td>30 (-160)</td></tr><tr><td>Dual-mode ContextNet</td><td>Full-context Streaming Full-context</td><td>31.8</td><td>2.3 / 5.3 3.9 (-0.6) / 8.5 (-1.5) 2.5 / 5.9</td><td></td><td>40 (-30)</td><td>160 (-110)</td></tr><tr><td>Dual-mode Conformer</td><td>Streaming</td><td>30.7</td><td>3.7 (-0.9) /</td><td>/9.2 (-0.7)</td><td>10 (-130)</td><td>90 (-190)</td></tr></table>",
+        "bbox": [
+            171,
+            404,
+            841,
+            672
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            341,
+            715
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we perform various ablation studies to support and understand the effectiveness of each technique in Dual-mode ASR. We train Dual-mode ContextNet on LibriSpeech training set with exactly same settings and report WER, Latency $\\textcircled { a } 5 0$ and Latency $@ 9 0$ on TestOther set of streaming mode. We specifically study three techniques and their combinations including weight sharing, joint training and inplace knowledge distillation during the training. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            799
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "During the training we distill knowledge from full-context mode (teacher) into streaming mode (student) on the fly within the same dual-mode model. Inplace distillation during the training comes for free as shown in training Algorithm 1. But what if we simply share weights and jointly train them without distillation? As shown in the second row of Table 4, the model without inplace distillation during the training has worse results compared to the baseline. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Given a batch of data for each training iteration, we train both modes and aggregate their losses. We also show results of randomly sampled training in the third row of Table 4, which leads to even worse performance. Note that with randomly sampled training, we cannot apply inplace distillation easily either because in each training iteration there is only one prediction from either streaming mode or full-context mode. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Weight sharing reduces the model size which is one of the major motivation of Dual-mode ASR. However, what if we simply train two individual models and use knowledge distillation with fullcontext model as the teacher? As shown in the last row of Table 4, the results are better than other ablation but still worse than the Dual-mode ASR baseline. It might indicate that weight sharing itself encourages learning better deep representation for streaming ASR. Weight sharing has been shown empirically to improve Multilingual ASR (Kannan et al., 2019), Model Pruning (Wu et al., 2020), Endpointing (Hochreiter & Schmidhuber, 1997) and some Computer Vision problems (Yu et al., 2018) and this intriguing property need to be studied in more details as a future work. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ead80bc75e75cf88d2c485b40602d6d1a8dc4bc1e40084e078f2b5a90bc4adfb.jpg",
+        "table_caption": [
+            "Table 4: Ablation studies of weight sharing, joint training and inplace distillation. We report WER on TestOther (noisy) set (Panayotov et al., 2015) using ContextNet with same training settings. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Weight Sharing</td><td>Joint Training</td><td>Inplace Distillation</td><td>TestOther WER(%)</td><td>Latency@50 (ms)</td><td>Latency @90 (ms)</td></tr><tr><td></td><td></td><td>r</td><td>8.5</td><td>40</td><td>160</td></tr><tr><td>&lt;</td><td></td><td>×</td><td>10.2 (+1.7)</td><td>120 (+80)</td><td>310 (+150)</td></tr><tr><td>厂</td><td>×</td><td>×</td><td>10.6 (+2.1)</td><td>90 (+50)</td><td>290 (+130)</td></tr><tr><td>×</td><td></td><td>？</td><td>9.9 (+1.4)</td><td>50 (+10)</td><td>210 (+50)</td></tr></table>",
+        "bbox": [
+            181,
+            295,
+            815,
+            386
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Further, we visualize the emission lattices of dual-mode ASR models trained with and without inplace knowledge distillation. We randomly sampled two audio sequences on LibriSpeech TestOther set and plotted their emission lattices of streaming mode in Figure 4. X-axis represents the speech input frames while Y-axis represents the text output labels (tokens). Figure 4 shows that with knowledge distillation from full-context mode in Dual-mode ASR, streaming mode emits faster and has much less latency, which is very critical for product datasets like MultiDomain presented in our work. ",
+        "bbox": [
+            173,
+            402,
+            825,
+            500
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/2790e3f68de9406341cefca41a790dd745ff79ccd9bab20b7914a7f7f1c84193.jpg",
+        "image_caption": [
+            "Figure 4: Two speech-text pair comparison of Dual-model ASR models trained with and without inplace distillation by visualization of their streaming emission lattices. $\\mathbf { X }$ -axis represents the speech input frames while Y-axis represents the text output labels (tokens). Inplace distillation significantly reduces emission latency of streaming mode in Dual-mode ASR models which is critical in realworld applications. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            511,
+            825,
+            712
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            848,
+            318,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have proposed a unified framework, Dual-mode ASR, to unify and improve streaming ASR by joint full-context modeling. We hope our exploration will inspire streaming models in other fields such as simultaneous machine translation and video processing. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Naveen Arivazhagan, Colin Cherry, Wolfgang Macherey, Chung-Cheng Chiu, Semih Yavuz, Ruoming Pang, Wei Li, and Colin Raffel. Monotonic infinite lookback attention for simultaneous machine translation. In ACL, 2019. ",
+        "bbox": [
+            176,
+            126,
+            821,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. ",
+        "bbox": [
+            169,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Jan Chorowski, Dmitriy Serdyuk, Philemon Brakel, and Yoshua Bengio. Endto-end attention-based large vocabulary speech recognition. In 2016 IEEE international conference on acoustics, speech and signal processing (ICASSP), pp. 4945–4949. IEEE, 2016. ",
+        "bbox": [
+            174,
+            217,
+            823,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. arXiv preprint arXiv:1505.05424, 2015. ",
+        "bbox": [
+            173,
+            268,
+            821,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 ieee symposium on security and privacy (sp), pp. 39–57. IEEE, 2017. ",
+        "bbox": [
+            173,
+            308,
+            823,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "William Chan, Navdeep Jaitly, Quoc Le, and Oriol Vinyals. Listen, attend and spell: A neural network for large vocabulary conversational speech recognition. In 2016 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4960–4964. IEEE, 2016. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            391
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuo-Yiin Chang, Rohit Prabhavalkar, Yanzhang He, Tara N Sainath, and Gabor Simko. Joint endpointing and decoding with end-to-end models. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5626–5630. IEEE, 2019. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            443
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuo-Yiin Chang, Bo Li, David Rybach, Yanzhang He, Wei Li, Tara Sainath, and Trevor Strohman. Low latency speech recognition using end-to-end prefetching. In Interspeech. ISCA, 2020. ",
+        "bbox": [
+            171,
+            452,
+            823,
+            482
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Ian Goodfellow, and Jonathon Shlens. Net2net: Accelerating learning via knowledge transfer. arXiv preprint arXiv:1511.05641, 2015. ",
+        "bbox": [
+            171,
+            491,
+            823,
+            520
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chung-Cheng Chiu and Colin Raffel. Monotonic chunkwise attention. arXiv preprint arXiv:1712.05382, 2017. ",
+        "bbox": [
+            171,
+            530,
+            825,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chung-Cheng Chiu and Colin Raffel. Monotonic chunkwise attention. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            169,
+            568,
+            825,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chung-Cheng Chiu, Wei Han, Yu Zhang, Ruoming Pang, Sergey Kishchenko, Patrick Nguyen, Arun Narayanan, Hank Liao, Shuyuan Zhang, Anjuli Kannan, Rohit Prabhavalkar, Zhifeng Chen, Tara Sainath, and Yonghui Wu. A comparison of end-to-end models for long-form speech recognition. In ASRU, 2019. ",
+        "bbox": [
+            173,
+            607,
+            825,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1251–1258, 2017. ",
+        "bbox": [
+            173,
+            674,
+            821,
+            703
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jan Chorowski and Navdeep Jaitly. Towards better decoding and language model integration in sequence to sequence models. arXiv preprint arXiv:1612.02695, 2016. ",
+        "bbox": [
+            171,
+            712,
+            823,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jan Chorowski, Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. End-to-end continuous speech recognition using attention-based recurrent nn: First results. arXiv preprint arXiv:1412.1602, 2014. ",
+        "bbox": [
+            173,
+            751,
+            821,
+            794
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jan K Chorowski, Dzmitry Bahdanau, Dmitriy Serdyuk, Kyunghyun Cho, and Yoshua Bengio. Attention-based models for speech recognition. In Advances in neural information processing systems, pp. 577–585, 2015. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ruchao Fan, Pan Zhou, Wei Chen, Jia Jia, and Gang Liu. An online attention-based model for speech recognition. arXiv preprint arXiv:1811.05247, 2018. ",
+        "bbox": [
+            166,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N Dauphin. Convolutional sequence to sequence learning. arXiv preprint arXiv:1705.03122, 2017. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An-´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Sequence transduction with recurrent neural networks. arXiv preprint arXiv:1211.3711, 2012. ",
+        "bbox": [
+            173,
+            154,
+            823,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Generating sequences with recurrent neural networks, 2013. ",
+        "bbox": [
+            174,
+            190,
+            661,
+            207
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anmol Gulati, James Qin, Chung-Cheng Chiu, Niki Parmar, Yu Zhang, Jiahui Yu, Wei Han, Shibo Wang, Zhengdong Zhang, Yonghui Wu, et al. Conformer: Convolution-augmented transformer for speech recognition. arXiv preprint arXiv:2005.08100, 2020. ",
+        "bbox": [
+            176,
+            213,
+            823,
+            257
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Han, Zhengdong Zhang, Yu Zhang, Jiahui Yu, Chung-Cheng Chiu, James Qin, Anmol Gulati, Ruoming Pang, and Yonghui Wu. Contextnet: Improving convolutional neural networks for automatic speech recognition with global context. arXiv preprint arXiv:2005.03191, 2020. ",
+        "bbox": [
+            176,
+            263,
+            823,
+            308
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            315,
+            823,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yanzhang He, Tara N Sainath, Rohit Prabhavalkar, Ian McGraw, Raziel Alvarez, Ding Zhao, David Rybach, Anjuli Kannan, Yonghui Wu, Ruoming Pang, et al. Streaming end-to-end speech recognition for mobile devices. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6381–6385. IEEE, 2019. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            422
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            173,
+            430,
+            823,
+            459
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            467,
+            823,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 7132–7141, 2018. ",
+        "bbox": [
+            171,
+            503,
+            823,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017. ",
+        "bbox": [
+            176,
+            540,
+            825,
+            583
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenyong Huang, Wenchao Hu, Yu Ting Yeung, and Xiao Chen. Conv-transformer transducer: Low latency, low frame rate, streamable end-to-end speech recognition. arXiv preprint arXiv:2008.05750, 2020. ",
+        "bbox": [
+            174,
+            590,
+            823,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            169,
+            642,
+            823,
+            671
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Navdeep Jaitly, Quoc V Le, Oriol Vinyals, Ilya Sutskever, David Sussillo, and Samy Bengio. An online sequence-to-sequence model using partial conditioning. In Advances in Neural Information Processing Systems 29, pp. 5067–5075, 2016. ",
+        "bbox": [
+            174,
+            678,
+            823,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anjuli Kannan, Arindrima Datta, Tara N Sainath, Eugene Weinstein, Bhuvana Ramabhadran, Yonghui Wu, Ankur Bapna, Zhifeng Chen, and Seungji Lee. Large-scale multilingual speech recognition with a streaming end-to-end model. arXiv preprint arXiv:1909.05330, 2019. ",
+        "bbox": [
+            173,
+            729,
+            823,
+            772
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bo Li, Shuo-yiin Chang, Tara N Sainath, Ruoming Pang, Yanzhang He, Trevor Strohman, and Yonghui Wu. Towards fast and accurate streaming end-to-end asr. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6069–6073. IEEE, 2020a. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            873
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Li, James Qin, Chung-Cheng Chiu, Ruoming Pang, and Yanzhang He. Parallel rescoring with transformer for streaming on-device speech recognition. arXiv preprint arXiv:2008.13093, 2020b. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haoran Miao, Gaofeng Cheng, Changfeng Gao, Pengyuan Zhang, and Yonghong Yan. Transformerbased online ctc/attention end-to-end speech recognition architecture. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6084– 6088. IEEE, 2020. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Niko Moritz, Takaaki Hori, and Jonathan Le Roux. Triggered attention for end-to-end speech recognition. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5666–5670. IEEE, 2019. ",
+        "bbox": [
+            174,
+            170,
+            823,
+            213
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Niko Moritz, Takaaki Hori, and Jonathan Le. Streaming automatic speech recognition with the transformer model. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6074–6078. IEEE, 2020. ",
+        "bbox": [
+            171,
+            222,
+            825,
+            265
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arun Narayanan, Ananya Misra, Khe Chai Sim, Golan Pundak, Anshuman Tripathi, Mohamed Elfeky, Parisa Haghani, Trevor Strohman, and Michiel Bacchiani. Toward domain-invariant speech recognition via large scale training. In 2018 IEEE Spoken Language Technology Workshop (SLT), pp. 441–447. IEEE, 2018. ",
+        "bbox": [
+            173,
+            275,
+            825,
+            332
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arun Narayanan, Tara N Sainath, Ruoming Pang, Jiahui Yu, Chung-Cheng Chiu, Rohit Prabhavalkar, Ehsan Variani, and Trevor Strohman. Cascaded encoders for unifying streaming and non-streaming asr. arXiv preprint arXiv:2010.14606, 2020. ",
+        "bbox": [
+            174,
+            340,
+            823,
+            385
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016. ",
+        "bbox": [
+            173,
+            393,
+            823,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: an asr corpus based on public domain audio books. In 2015 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5206–5210. IEEE, 2015. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sankaran Panchapagesan, Daniel S Park, Chung-Cheng Chiu, Yuan Shangguan, Qiao Liang, and Alexander Gruenstein. Efficient knowledge distillation for rnn-transducer models. arXiv preprint arXiv:2011.06110, 2020. ",
+        "bbox": [
+            173,
+            498,
+            826,
+            541
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE Symposium on Security and Privacy (SP), pp. 582–597. IEEE, 2016. ",
+        "bbox": [
+            173,
+            551,
+            823,
+            594
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel S Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D Cubuk, and Quoc V Le. Specaugment: A simple data augmentation method for automatic speech recognition. arXiv preprint arXiv:1904.08779, 2019. ",
+        "bbox": [
+            174,
+            603,
+            823,
+            647
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rohit Prabhavalkar, Tara N Sainath, Yonghui Wu, Patrick Nguyen, Zhifeng Chen, Chung-Cheng Chiu, and Anjuli Kannan. Minimum word error rate training for attention-based sequence-tosequence models. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4839–4843. IEEE, 2018. ",
+        "bbox": [
+            173,
+            656,
+            825,
+            714
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C. Raffel, M. Luong, P. J. Liu, R.J. Weiss, and D. Eck. Online and Linear-Time Attention by Enforcing Monotonic Alignments. In Proc. ICML, 2017. ",
+        "bbox": [
+            174,
+            723,
+            823,
+            752
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Prajit Ramachandran, Barret Zoph, and Quoc V Le. Searching for activation functions. arXiv preprint arXiv:1710.05941, 2017. ",
+        "bbox": [
+            171,
+            762,
+            825,
+            791
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tara N Sainath, Ruoming Pang, David Rybach, Yanzhang He, Rohit Prabhavalkar, Wei Li, Mirko´ Visontai, Qiao Liang, Trevor Strohman, Yonghui Wu, et al. Two-pass end-to-end speech recognition. arXiv preprint arXiv:1908.10992, 2019. ",
+        "bbox": [
+            173,
+            801,
+            823,
+            843
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tara N Sainath, Yanzhang He, Bo Li, Arun Narayanan, Ruoming Pang, Antoine Bruguier, Shuoyiin Chang, Wei Li, Raziel Alvarez, Zhifeng Chen, et al. A streaming on-device end-to-end model surpassing server-side conventional model quality and latency. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6059–6063. IEEE, 2020. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Shen, Patrick Nguyen, Yonghui Wu, Zhifeng Chen, Mia X Chen, Ye Jia, Anjuli Kannan, Tara Sainath, Yuan Cao, Chung-Cheng Chiu, et al. Lingvo: a modular and scalable framework for sequence-to-sequence modeling. arXiv preprint arXiv:1902.08295, 2019. ",
+        "bbox": [
+            178,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            178,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Emiru Tsunoo, Yosuke Kashiwagi, Toshiyuki Kumakura, and Shinji Watanabe. Towards online end-to-end transformer automatic speech recognition. arXiv preprint arXiv:1910.11871, 2019. ",
+        "bbox": [
+            173,
+            205,
+            820,
+            236
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Emiru Tsunoo, Yosuke Kashiwagi, and Shinji Watanabe. Streaming transformer asr with blockwise synchronous inference. arXiv preprint arXiv:2006.14941, 2020. ",
+        "bbox": [
+            173,
+            244,
+            821,
+            272
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 4068–4076, 2015. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            324
+        ],
+        "page_idx": 12
+    },
+    {
+        "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. 5998–6008, 2017. ",
+        "bbox": [
+            174,
+            333,
+            826,
+            376
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chengyi Wang, Yu Wu, Shujie Liu, Jinyu Li, Liang Lu, Guoli Ye, and Ming Zhou. Low latency end-to-end streaming speech recognition with a scout network. arXiv preprint arXiv:2003.10369, 2020. ",
+        "bbox": [
+            174,
+            385,
+            826,
+            428
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shinji Watanabe, Takaaki Hori, Suyoun Kim, John R Hershey, and Tomoki Hayashi. Hybrid ctc/attention architecture for end-to-end speech recognition. IEEE Journal of Selected Topics in Signal Processing, 11(8):1240–1253, 2017. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            479
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams and David Zipser. A learning algorithm for continually running fully recurrent neural networks. Neural computation, 1(2):270–280, 1989. ",
+        "bbox": [
+            173,
+            488,
+            823,
+            517
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            582
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhaofeng Wu, Ding Zhao, Qiao Liang, Jiahui Yu, Anmol Gulati, and Ruoming Pang. Dynamic sparsity neural networks for automatic speech recognition. arXiv preprint arXiv:2005.10627, 2020. ",
+        "bbox": [
+            173,
+            590,
+            823,
+            633
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ching-Feng Yeh, Jay Mahadeokar, Kaustubh Kalgaonkar, Yongqiang Wang, Duc Le, Mahaveer Jain, Kjell Schubert, Christian Fuegen, and Michael L Seltzer. Transformer-transducer: End-toend speech recognition with self-attention. arXiv preprint arXiv:1910.12977, 2019. ",
+        "bbox": [
+            173,
+            642,
+            821,
+            685
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiahui Yu and Thomas Huang. Autoslim: Towards one-shot architecture search for channel numbers. arXiv preprint arXiv:1903.11728, 2019a. ",
+        "bbox": [
+            173,
+            694,
+            820,
+            723
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiahui Yu and Thomas S Huang. Universally slimmable networks and improved training techniques. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1803–1811, 2019b. ",
+        "bbox": [
+            173,
+            732,
+            820,
+            762
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiahui Yu, Linjie Yang, Ning Xu, Jianchao Yang, and Thomas Huang. Slimmable neural networks. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            770,
+            820,
+            799
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiahui Yu, Pengchong Jin, Hanxiao Liu, Gabriel Bender, Pieter-Jan Kindermans, Mingxing Tan, Thomas Huang, Xiaodan Song, Ruoming Pang, and Quoc Le. Bignas: Scaling up neural architecture search with big single-stage models. arXiv preprint arXiv:2003.11142, 2020. ",
+        "bbox": [
+            174,
+            808,
+            823,
+            851
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Qian Zhang, Han Lu, Hasim Sak, Anshuman Tripathi, Erik McDermott, Stephen Koo, and Shankar Kumar. Transformer transducer: A streamable speech recognition model with transformer encoders and rnn-t loss. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 7829–7833. IEEE, 2020. ",
+        "bbox": [
+            174,
+            859,
+            825,
+            916
+        ],
+        "page_idx": 12
+    }
+]

parse/train/SJlpYJBKvH/SJlpYJBKvH.md

@@ -0,0 +1,401 @@
+# MEASURING THE RELIABILITY OF REINFORCEMENT LEARNING ALGORITHMS
+
+Stephanie C.Y. Chan,1∗ Samuel Fishman,1 John Canny,1, 2 Anoop Korattikara,1   
+& Sergio Guadarrama1   
+1Google Research 2Berkeley EECS   
+{scychan,sfishman,canny,kbanoop,sguada}@google.com
+
+# ABSTRACT
+
+Lack of reliability is a well-known issue for reinforcement learning (RL) algorithms. This problem has gained increasing attention in recent years, and efforts to improve it have grown substantially. To aid RL researchers and production users with the evaluation and improvement of reliability, we propose a set of metrics that quantitatively measure different aspects of reliability. In this work, we focus on variability and risk, both during training and after learning (on a fixed policy). We designed these metrics to be general-purpose, and we also designed complementary statistical tests to enable rigorous comparisons on these metrics. In this paper, we first describe the desired properties of the metrics and their design, the aspects of reliability that they measure, and their applicability to different scenarios. We then describe the statistical tests and make additional practical recommendations for reporting results. The metrics and accompanying statistical tools have been made available as an open-source library.1 We apply our metrics to a set of common RL algorithms and environments, compare them, and analyze the results.
+
+# 1 INTRODUCTION
+
+Reinforcement learning (RL) algorithms, especially Deep RL algorithms, tend to be highly variable in performance and considerably sensitive to a range of different factors, including implementation details, hyper-parameters, choice of environments, and even random seeds (Henderson et al., 2017). This variability hinders reproducible research, and can be costly or even dangerous for real-world applications. Furthermore, it impedes scientific progress in the field when practitioners cannot reliably evaluate or predict the performance of any particular algorithm, compare different algorithms, or even compare different implementations of the same algorithm.
+
+Recently, Henderson et al. (2017) has performed a detailed analysis of reliability for several policy gradient algorithms, while Duan et al. (2016) has benchmarked average performance of different continuous-control algorithms. In other related work, Colas et al. (2018) have provided a detailed analysis on power analyses for mean performance in RL, and Colas et al. (2019) provide a comprehensive primer on statistical testing for mean and median performance in RL.
+
+In this work, we aim to devise a set of metrics that measure reliability of RL algorithms. Our analysis distinguishes between several typical modes to evaluate RL performance: "evaluation during training", which is computed over the course of training, vs. "evaluation after learning", which is evaluated on a fixed policy after it has been trained. These metrics are also designed to measure different aspects of reliability, e.g. reproducibility (variability across training runs and variability across rollouts of a fixed policy) or stability (variability within training runs). Additionally, the metrics capture multiple aspects of variability – dispersion (the width of a distribution), and risk (the heaviness and extremity of the lower tail of a distribution).
+
+Standardized measures of reliability can benefit the field of RL by allowing RL practitioners to compare algorithms in a rigorous and consistent way. This in turn allows the field to measure progress, and also informs the selection of algorithms for both research and production environments. By measuring various aspects of reliability, we can also identify particular strengths and weaknesses of algorithms, allowing users to pinpoint specific areas of improvement.
+
+In this paper, in addition to describing these reliability metrics, we also present practical recommendations for statistical tests to compare metric results and how to report the results more generally. As examples, we apply these metrics to a set of algorithms and environments (discrete and continuous, off-policy and on-policy). We have released the code used in this paper as an open-source Python package to ease the adoption of these metrics and their complementary statistics.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Dispersion (D)</td><td rowspan=1 colspan=1>Risk (R)</td></tr><tr><td rowspan=2 colspan=1>DUURNNTTIIINNN</td><td rowspan=1 colspan=1>Across Time (T)(within trainingruns)</td><td rowspan=1 colspan=1>IQR* within windows,afterdetrending</td><td rowspan=1 colspan=1>Short-term: CVaR† onfirst-order differencesLong-term: CVaR† onDrawdown</td></tr><tr><td rowspan=1 colspan=1>Across Runs (R)</td><td rowspan=1 colspan=1>IQR* across training runs,after low-pass filtering.</td><td rowspan=1 colspan=1>CVaR† across runs</td></tr><tr><td rowspan=1 colspan=1>LIIANINNTIEEH</td><td rowspan=1 colspan=1>Across rollouts ona Fixed Policy (F)</td><td rowspan=1 colspan=1>IQR* across rollouts for afixed policy</td><td rowspan=1 colspan=1>CVaR† across rollouts for afixed policy</td></tr></table>
+
+Table 1: Summary of our proposed reliability metrics. For evaluation DURING TRAINING, which measures reliability over the course of training an algorithm, the inputs to the metrics are the performance curves of an algorithm, evaluated at regular intervals during a single training run (or on a set of training runs). For evaluation AFTER LEARNING, which measures reliability of an alreadytrained policy, the inputs to the metrics are the performance scores of a set of rollouts of that fixed policy. $^ { * } \mathrm { I Q R }$ : inter-quartile range. ${ \dag } \mathrm { C V a R }$ : conditional value at risk.
+
+# 2 RELIABILITY METRICS
+
+We target three different axes of variability, and two different measures of variability along each axis. We denote each of these by a letter, and each metric as a combination of an axis $^ +$ a measure, e.g. "DR" for "Dispersion Across Runs". See Table 1 for a summary. Please see Appendix A for more detailed definitions of the terms used here.
+
+# 2.1 AXES OF VARIABILITY
+
+Our metrics target the following three axes of variability. The first two capture reliability "during training", while the last captures reliability of a fixed policy "after learning".
+
+During training: Across Time (T) In the setting of evaluation during training, one desirable property for an RL algorithm is to be stable "across time" within each training run. In general, smooth monotonic improvement is preferable to noisy fluctuations around a positive trend, or unpredictable swings in performance.
+
+This type of stability is important for several reasons. During learning, especially when deployed for real applications, it can be costly or even dangerous for an algorithm to have unpredictable levels of performance. Even in cases where bouts of poor performance do not directly cause harm, e.g. if training in simulation, high instability implies that algorithms have to be check-pointed and evaluated more frequently in order to catch the peak performance of the algorithm, which can be expensive. Furthermore, while training, it can be a waste of computational resources to train an unstable algorithm that tends to forget previously learned behaviors.
+
+During training: Across Runs (R) During training, RL algorithms should have easily and consistently reproducible performances across multiple training runs. Depending on the components that we allow to vary across training runs, this variability can encapsulate the algorithm’s sensitivity to a variety of factors, such as: random seed and initialization of the optimization, random seed and initialization of the environment, implementation details, and hyper-parameter settings. Depending on the goals of the analysis, these factors can be held constant or allowed to vary, in order to disentangle the contribution of each factor to variability in training performance. High variability on any of these dimensions leads to unpredictable performance, and also requires a large search in order to find a model with good performance.
+
+After learning: Across rollouts of a fixed policy (F) When evaluating a fixed policy, a natural concern is the variability in performance across multiple rollouts of that fixed policy. Each rollout may be specified e.g. in terms of a number of actions, environment steps, or episodes. Generally, this metric measures sensitivity to both stochasticity from the environment and stochasticity from the training procedure (the optimization). Practitioners may sometimes wish to keep one or the other constant if it is important to disentangle the two factors (e.g. holding constant the random seed of the environment while allowing the random seed controlling optimization to vary across rollouts).
+
+# 2.2 MEASURES OF VARIABILITY
+
+For each axis of variability, we have two kinds of measures: dispersion and risk.
+
+Dispersion Dispersion is the width of the distribution. To measure dispersion, we use "robust statistics" such as the Inter-quartile range (IQR) (i.e. the difference between the 75th and 25th percentiles) and the Median absolute deviation from the median (MAD), which are more robust statistics and don’t require assuming normality of the distributions. 2 We prefer to use IQR over MAD, because it is more appropriate for asymmetric distributions (Rousseeuw & Croux, 1993).
+
+Risk In many cases, we are concerned about the worst-case scenarios. Therefore, we define risk as the heaviness and extent of the lower tail of the distribution. This is complementary to measures of dispersion like IQR, which cuts off the tails of the distribution. To measure risk, we use the Conditional Value at Risk (CVaR), also known as “expected shortfall". CVaR measures the expected loss in the worst-case scenarios, defined by some quantile $\alpha$ . It is computed as the expected value in the left-most tail of a distribution (Acerbi & Tasche, 2002). We use the following definition for the CVaR of a random variable $X$ for a given quantile $\alpha$ :
+
+$$
+\mathrm { C V a R } _ { \alpha } ( X ) = \operatorname { \mathbb { E } } \left[ X | X \leq V a R _ { \alpha } ( X ) \right]
+$$
+
+where $\alpha \in ( 0 , 1 )$ and the $V a R _ { \alpha }$ (Value at Risk) is just the $\alpha$ -quantile of the distribution of $X$ . Originally developed in finance, CVaR has also seen recent adoption in Safe RL as an additional component of the objective function by applying it to the cumulative returns within an episode, e.g. Bäuerle & Ott (2011); Chow & Ghavamzadeh (2014); Tamar et al. (2015). In this work, we apply CVaR to the dimensions of reliability described in Section 2.1.
+
+# 2.3 DESIDERATA
+
+In designing our metrics and statistical tests, we required that they fulfill the following criteria:
+
+• A minimal number of configuration parameters – to facilitate standardization as well as to minimize “researcher degrees of freedom" (where flexibility may allow users to tune settings to produce more favorable results, leading to an inflated rate of false positives) (Simmons et al., 2011). • Robust statistics, when possible. Robust statistics are less sensitive to outliers and have more reliable performance for a wider range of distributions. Robust statistics are especially important when applied to training performance, which tends to be highly non-Gaussian, making metrics such as variance and standard deviation inappropriate. For example, training performance is often bi-modal, with a concentration of points near the starting level and another concentration at the level of asymptotic performance.
+
+• Invariance to sampling frequency – results should not be biased by the frequency at which an algorithm was evaluated during training. See Section 2.5 for further discussion.
+
+• Enable meaningful statistical comparisons on the metrics, while making minimal assumptions about the distribution of the results. We thus designed statistical procedures that are non-parametric (Section 4).
+
+# OpenAI Gym -- During Training
+
+![](images/8622396b34b55c3757bd48070b2e4afc29379a1358f8c5009ffb3f46074ccc82.jpg)  
+Figure 1: Reliability metrics and median performance for continuous control RL algorithms (DDPG, TD3, SAC, REINFORCE, and PPO) tested on OpenAI Gym environments. Rank 1 always indicates "best" reliability, e.g. lowest IQR across runs. Error bars are $9 5 \%$ bootstrap confidence intervals (# bootstraps $= 1 { , } 0 0 0 \rangle$ ). Significant pairwise differences in ranking between pairs of algorithms are indicated by black horizontal lines above the colored bars. ( $\langle \alpha = 0 . 0 5$ with Benjamini-Yekutieli correction, permutation test with # permutations $= 1 { , } 0 0 0 $ ). Note that the best algorithms by median performance are not always the best algorithms on reliability.
+
+# 2.4 METRIC DEFINITIONS
+
+Dispersion across Time (DT): IQR across Time To measure dispersion across time (DT), we wished to isolate higher-frequency variability, rather than capturing longer-term trends. We did not want our metrics to be influenced by positive trends of improvement during training, which are in fact desirable sources of variation in the training performance. Therefore, we apply detrending before computing dispersion metrics. For detrending, we used differencing (i.e. $y _ { t } \prime = y _ { t } - y _ { t - 1 } )$ .3 The final measure consisted of inter-quartile range (IQR) within a sliding window along the detrended training curve.
+
+![](images/c0f6add0daab1e92929de06c0d271ddac8d145b41450b22d233810e7f438292d.jpg)  
+Figure 2: Reliability metrics and median performance for four DQN-variants (C51, DQN: Deep Q-network, IQ: Implicit Quantiles, and RBW: Rainbow) tested on 60 Atari games. Rank 1 always indicates "best" reliability, e.g. lowest IQR across runs. Significant pairwise differences in ranking between pairs of algorithms are indicated by black lines above the colored circles. $\alpha = 0 . 0 5$ with Benjamini-Yekutieli correction, permutation test with # permutations $= 1 { , } 0 0 0 $ ). Note that the best algorithms by median performance are not always the best algorithms on reliability. Error bars are $9 5 \%$ bootstrap confidence intervals (# bootstraps $= 1 { , } 0 0 0 $ ).
+
+Short-term Risk across Time (SRT): CVaR on Differences For this measure, we wish to measure the most extreme short-term drop over time. To do this, we apply CVaR to the changes in performance from one evaluation point to the next. I.e., in Eq. 1, $X$ represents the differences from one evaluation time-point to the next. We first compute the time-point to time-point differences on each training run. These differences are normalized by the distance between time-points, to ensure invariance to evaluation frequency (see Section 2.5). Then, we obtain the distribution of these differences, and find the $\alpha$ -quantile. Finally, we compute the expected value of the distribution below the $\alpha$ -quantile. This gives us the worst-case expected drop in performance during training, from one point of evaluation to the next.
+
+Long-term Risk across Time (LRT): CVaR on Drawdown For this measure, we would also like to be able to capture whether an algorithm has the potential to lose a lot of performance relative to its peak, even if on a longer timescale, e.g. over an accumulation of small drops. For this measure, we apply CVaR to the Drawdown. The Drawdown at time $T$ is the drop in performance relative to the highest peak so far, and is another measure borrowed from economics (Chekhlov et al., 2005). I.e. Drawdown $\mathbf { \Psi } _ { T } = R _ { T } - \operatorname* { m a x } _ { t < - T } R _ { t }$ . Like the SRT metric, the LRT can capture unusually large short-term drops in performance, but can also capture unusually large drops that occur over longer timescales.
+
+Dispersion across Runs (DR): IQR across Runs Unlike the rest of the metrics described here, the dispersion across training runs has previously been used to characterize performance (e.g. Duan et al. (2016); Islam et al. (2017); Bellemare et al. (2017); Fortunato et al. (2017); Nagarajan et al. (2018)). This is usually measured by taking the variance or standard deviation across training runs at a set of evaluation points. We build on the existing practice by recommending first performing low-pass filtering of the training data, to filter out high-frequency variability within runs (this is instead measured using Dispersion across Time, DT). We also replace variance or standard deviation with robust statistics like IQR.
+
+Risk across Runs (RR): CVaR across Runs In order to measure Risk across Runs (RR), we apply CVaR to the final performance of all the training runs. This gives a measure of the expected performance of the worst runs.
+
+Dispersion across Fixed-Policy Rollouts (DF): IQR across Rollouts When evaluating a fixed policy, we are interested in variability in performance when the same policy is rolled out multiple times. To compute this metric, we simply compute the IQR on the performance of the rollouts.
+
+Risk across Fixed-Policy Rollouts (RF): CVaR across Rollouts This metric is similar to DF, except that we apply CVaR on the rollout performances.
+
+# 2.5 INVARIANCE TO FREQUENCY OF EVALUATION
+
+Different experiments and different tasks may produce evaluations at different frequencies during training. Therefore, the reliability metrics should be unbiased by the choice of evaluation frequency. As long as there are no cyclical patterns in performance, the frequency of evaluation will not bias any of the metrics except Long-Term Risk across Time (LRT). For all other metrics, changes in the frequency of evaluation will simply lead to more or less noisy estimates of these metrics. For LRT, comparisons should only be made if the frequency of evaluation is held constant across experiments.
+
+# 3 RECOMMENDATIONS FOR REPORTING METRICS AND PARAMETERS
+
+Whether evaluating an algorithm for practical use or for research, we recommend evaluating all of the reliability metrics described above. Each metric measures a different aspect of reliability, and can help pinpoint specific strengths and weaknesses of the algorithm. Evaluating the metrics is easy with the open-source Python package that we have released.
+
+Reporting parameters. Even given our purposeful efforts to minimize the number of parameters in the reliability metrics, a few remain to be specified by the user that can affect the results, namely: window size (for Dispersion across Time), frequency threshold for low-pass and high-pass filtering (Dispersion across Time, Dispersion across Runs), evaluation frequency (only for Long-term Risk across Time), and length of training runs. Therefore, when reporting these metrics, these parameters need to be clearly specified, and must also be held constant across experiments for meaningful comparisons. The same is true for any other parameters that affect evaluation, e.g., the number of roll-outs per evaluation, the parameters of the environment, whether on-line or off-line evaluation is used, and the random seeds chosen.
+
+Collapsing across evaluation points. Some of the in-training reliability metrics (Dispersion across Runs, Risk across Runs, and Dispersion across Time) need to be evaluated at multiple evaluation points along the training runs. If it is useful to obtain a small number of values to summarize each metric, we recommend dividing the training run into "time frames" (e.g. beginning, middle, and end), and collapsing across all evaluation points within each time frame.
+
+Normalization by performance. Different algorithms can have vastly different ranges of performance even on the same task, and variability in performance tends to scale with actual performance. Thus, we normalize our metrics in post-processing by a measure of the range of performance for each algorithm. For "during training" reliability, we recommend normalizing by the median range of performance, which we define as the $p _ { P _ { 9 } 5 } - p _ { t = 0 }$ , where $p _ { P { 5 } }$ is the 95th percentile and $p _ { t = 0 }$ is the starting performance. For "after learning" reliability, the range of performance may not be available, in which case we use the median performance directly.
+
+Ranking the algorithms. Because different environments have different ranges and distributions of reward, we must be careful when aggregating across environments or comparing between environments. Thus, if the analysis involves more than one environment, the per-environment median results for the algorithms are first converted to rankings, by ranking all algorithms within each task. To summarize the performance of a single algorithm across multiple tasks, we compute the mean ranking across tasks.
+
+Per-environment analysis. The same algorithm can have different patterns of reliability for different environments. Therefore, we recommend inspecting reliability metrics on a per-environment basis, as well as aggregating across environments as described above.
+
+# 4 CONFIDENCE INTERVALS AND STATISTICAL SIGNIFICANCE TESTS FOR COMPARISON
+
+# 4.1 CONFIDENCE INTERVALS
+
+We assume that the metric values have been converted to mean rankings, as explained in Section 3. To obtain confidence intervals on the mean rankings for each algorithm, we apply bootstrap sampling on the runs, by resampling runs with replacement (Efron & Tibshirani, 1986).
+
+For metrics that are evaluated per-run (e.g. Dispersion across Time), we can resample the metric values directly, and then recompute the mean rankings on each resampling to obtain a distribution over the rankings; this allow us to compute confidence intervals. For metrics that are evaluated across-runs, we need to resample the runs themselves, then evaluate the metrics on each resampling, before recomputing the mean rankings to obtain a distribution on the mean rankings.
+
+# 4.2 SIGNIFICANCE TESTS FOR COMPARING ALGORITHMS
+
+Commonly, we would like to compare algorithms evaluated on a fixed set of environments. To determine whether any two algorithms have statistically significant differences in their metric rankings, we perform an exact permutation test on each pair of algorithms. Such tests allow us to compute a $\mathsf { p }$ -value for the null hypothesis (probability that the methods are in fact indistinguishable on the reliability metric).
+
+We designed our permutation tests based on the null hypothesis that runs are exchangeable across the two algorithms being compared. In brief, let $A$ and $B$ be sets of performance measurements for algorithms $a$ and $b$ . Let $M e t r i c ( X )$ be a reliability metric, e.g. the inter-quartile range across runs, computed on a set of measurements $X$ . MetricRanking $( X )$ is the mean ranking across tasks on $X$ , compared to the other algorithms being considered. We compute test statistic
+
+$$
+s _ { M e t r i c R a n k i n g } ( A , B ) = M e t r i c R a n k i n g ( A ) - M e t r i c R a n k i n g ( B ) .
+$$
+
+Next we compute the distribution for $\AA ^ { S } M e t r i c R a n k i n g$ under the null hypothesis that the methods are equivalent, i.e. that performance measurements should have the same distribution for $a$ and $b$ . We do this by computing random partitions $A ^ { \prime } , B ^ { \prime }$ of $\{ A \cup B \}$ , and computing the test statistic $s _ { M e t r i c R a n k i n g } ( A ^ { \prime } , B ^ { \prime } )$ on each partition. This yields a distribution for sMetricRanking (for sufficiently many samples), and the $\mathsf { p }$ -value can be computed from the percentile value of $s _ { M e t r i c R a n k i n g } ( A , B )$ in this distribution. As with the confidence intervals, a different procedure is required for per-run vs across-run metrics. Please see Appendix C for diagrams illustrating the permutation test procedures.
+
+When performing pairwise comparisons between algorithms, it is critical to include corrections for multiple comparisons. This is because the probability of incorrect inferences increases with a greater number of simultaneous comparisons. We recommend using the Benjamini-Yekutieli method, which controls the false discovery rate (FDR), i.e., the proportion of rejected null hypotheses that are false.4
+
+# 4.3 REPORTING ON STATISTICAL TESTS
+
+It is important to report the details of any statistical tests performed, e.g. which test was used, the significance threshold, and the type of multiple-comparisons correction used.
+
+# 5 ANALYSIS OF RELIABILITY FOR COMMON ALGORITHMS AND ENVIRONMENTS
+
+In this section, we provide examples of applying the reliability metrics to a number of RL algorithms and environments, following the recommendations described above.
+
+# 5.1 CONTINUOUS CONTROL ALGORITHMS ON OPENAI GYM
+
+We applied the reliability metrics to algorithms tested on seven continuous control environments from the Open-AI Gym (Greg Brockman et al., 2016) run on the MuJoCo physics simulator (Todorov et al., 2012). We tested REINFORCE (Sutton et al., 2000), DDPG (Lillicrap et al., 2015), PPO (Schulman et al., 2017), TD3 (Fujimoto et al., 2018), and SAC (Haarnoja et al., 2018) on the following Gym environments: Ant-v2, HalfCheetah-v2, Humanoid-v2, Reacher-v2, Swimmer-v2, and Walker2d-v2. We used the implementations of DDPG, TD3, and SAC from the TF-Agents library (Guadarrama et al., 2018). Each algorithm was run on each environment for 30 independent training runs.
+
+We used a black-box optimizer (Golovin et al., 2017) to tune selected hyperparameters on a per-task basis, optimizing for final performance. The remaining hyperparameters were defined as stated in the corresponding original papers. See Appendix E for details of the hyperparameter search space and the final set of hyperparameters. During training, we evaluated the policies at a frequency of 1000 training steps. Each algorithm was run for a total of two million environment steps. For the “online” evaluations we used the generated training curves, averaging returns over recent training episodes collected using the exploration policy as it evolves. The raw training curves are shown in Appendix D. For evaluations after learning on a fixed policy, we took the last checkpoint from each training run as the fixed policy for evaluation. Each of these policies was then evaluated for 30 roll-outs, where each roll-out was defined as 1000 environment steps.
+
+# 5.2 DISCRETE CONTROL: DQN VARIANTS ON ATARI
+
+We also applied the reliability metrics to the RL algorithms and training data released as part of the Dopamine package (Castro et al., 2018). The data comprise the training runs of four RL algorithms, each applied to 60 Atari games. The RL algorithms are: DQN (Mnih et al., 2015), Implicit Quantile (IQN) (Dabney et al., 2018), C51 (Bellemare et al., 2017), and a variant of Rainbow implementing the three most important components (Hessel & Modayil, 2018). The algorithms were trained on each game for 5 training runs. Hyper-parameters follow the original papers, but were modified as necessary to follow Rainbow (Hessel & Modayil, 2018), to ensure apples-to-apples comparison. See Appendix E for the hyperparameters.
+
+During training, the algorithms were evaluated in an “online” fashion every 1 million frames, averaging across the training episodes as recommended for evaluations on the ALE (Machado et al., 2018). Each training run consisted of approximately 200 million Atari frames (rounding to the nearest episode boundary every 1 million frames).5 For evaluations after learning on a fixed policy (“after learning”), we took the last checkpoint from each training run as the fixed policies for evaluation. We then evaluated each of these policies for 125,000 environment steps.
+
+5.3 PARAMETERS FOR RELIABILITY METRICS, CONFIDENCE INTERVALS, AND STATISTICAL TESTS
+
+For the MuJoCo environments, we applied a sliding window of 100000 training steps for Dispersion across Time. For the Atari experiments, we used a sliding window size of 25 on top of the evaluations for the Dispersion across Time. For metrics with multiple evaluation points, we divided each training run into 3 time frames and averaged the metric rankings within each time frame. Because the results were extremely similar for all three time frames, we here report just for the final time frames.
+
+Statistical tests for comparing algorithms were performed according to the recommendations in Section 4. We used pairwise permutation tests using 10,000 permutations per test, with a significance threshold of 0.05 and Benjamini-Yekutieli multiple-comparisons correction.
+
+# 5.4 MEDIAN PERFORMANCE
+
+The median performance of an algorithm is not a reliability metric, but it is interesting to see side-byside with the reliability metrics. For analyzing median performance for the DQN variants, we used the normalization scheme of (Mnih et al., 2015), where an algorithm’s performance is normalized against a lower baseline (e.g. the performance of a random policy) and an upper baseline (e.g. the performance of a human): $\begin{array} { r } { \bar { P _ { \mathrm { n o r m a l i z e d } } } = \frac { P - B _ { \mathrm { l o w e r } } } { B _ { \mathrm { u p p e r } } - B _ { \mathrm { l o w e r } } } } \end{array}$ . Median performance was not normalized for the continuous control algorithms.
+
+# 5.5 RESULTS
+
+The reliability metric rankings are shown in Fig. 1 for the MuJoCo results. We see that, according to Median Performance during training, SAC and TD3 have the best performance and perform similarly well, while REINFORCE performs the worst. However, SAC outperforms TD3 on all reliability metrics during training. Furthermore, both SAC and TD3 perform relatively poorly on all reliability metrics after learning, despite performing best on median performance.
+
+The reliability metric rankings are shown in Fig. 2 for the Atari results. Here we see a similar result that, even though Rainbow performs significantly better than IQN in Median Performance, IQN performs numerically or significantly better than Rainbow on many of the reliability metrics.
+
+The differing patterns in these metrics demonstrates that reliability is a separate dimension that needs to be inspected separately from mean or median performance – two algorithms may have similar median performance but may nonetheless significantly differ in reliability, as with SAC and TD3 above. Additionally, these results demonstrate that reliability along one axis does not necessarily correlate with reliability on other axes, demonstrating the value of evaluating these different dimensions so that algorithms can be compared and selected based on the requirements of the problem at hand.
+
+To see metric results evaluated on a per-environment basis, please refer to Appendix F. Rank order of algorithms was often relatively consistent across the different environments evaluated. However, different environments did display different patterns across algorithms. For example, even though SAC showed the same or better Dispersion across Runs for most of the MuJoCo environments evaluated, it did show slightly worse Dispersion across Runs for the HalfCheetah environment (Fig 7a). This kind of result emphasizes the importance of inspecting reliability (and other performance metrics) on a per-environment basis, and also of evaluating reliability and performance on the environment of interest, if possible.
+
+# 6 CONCLUSION
+
+We have presented a number of metrics, designed to measure different aspects of reliability of RL algorithms. We motivated the design goals and choices made in constructing these metrics, and also presented practical recommendations for the measurement of reliability for RL. Additionally, we presented examples of applying these metrics to common RL algorithms and environments, and showed that these metrics can reveal strengths and weaknesses of an algorithm that are obscured when we only inspect mean or median performance.
+
+# ACKNOWLEDGMENTS
+
+Many thanks to the following people for helpful discussions during the formulation of these metrics and the writing of the paper: Mohammad Ghavamzadeh, Yinlam Chow, Danijar Hafner, Rohan Anil, Archit Sharma, Vikas Sindhwani, Krzysztof Choromanski, Joelle Pineau, Hal Varian, Shyue-Ming Loh, and Tim Hesterberg. Thanks also to Toby Boyd for his assistance in the open-sourcing process, Oscar Ramirez for code reviews, and Pablo Castro for his help with running experiments using the Dopamine baselines data.
+
+# REFERENCES
+
+Carlo Acerbi and Dirk Tasche. Expected Shortfall: A Natural Coherent Alternative to Value at Risk. Economic Notes, 31(2):379–388, July 2002. ISSN 0391-5026, 1468-0300. doi: 10.1111/ 1468-0300.00091. URL http://doi.wiley.com/10.1111/1468-0300.00091.
+
+Marc G. Bellemare, Will Dabney, and Rémi Munos. A Distributional Perspective on Reinforcement Learning. arXiv:1707.06887 [cs, stat], July 2017. URL http://arxiv.org/abs/1707. 06887. arXiv: 1707.06887.
+
+Nicole Bäuerle and Jonathan Ott. Markov Decision Processes with Average-Value-at-Risk criteria. Mathematical Methods of Operations Research, 74(3):361–379, December 2011. ISSN 1432-2994, 1432-5217. doi: 10.1007/s00186-011-0367-0. URL http://link.springer.com/10. 1007/s00186-011-0367-0.
+
+Pablo Samuel Castro, Subhodeep Moitra, Carles Gelada, Saurabh Kumar, and Marc G. Bellemare. Dopamine: A research framework for deep reinforcement learning. CoRR, abs/1812.06110, 2018. URL http://arxiv.org/abs/1812.06110.
+
+Alexei Chekhlov, Stanislav Uryasev, and Michael Zabarankin. Drawdown measure in portfolio optimization. International Journal of Theoretical and Applied Finance, 8(1):46, 2005.
+
+Yinlam Chow and Mohammad Ghavamzadeh. Algorithms for CVaR Optimization in MDPs. Advances in Neural Information Processing Systems, pp. 9, 2014.
+
+Cédric Colas, Olivier Sigaud, and Pierre-Yves Oudeyer. How Many Random Seeds? Statistical Power Analysis in Deep Reinforcement Learning Experiments. arXiv:1806.08295 [cs, stat], June 2018. URL http://arxiv.org/abs/1806.08295. arXiv: 1806.08295.
+
+Cédric Colas, Olivier Sigaud, and Pierre-Yves Oudeyer. A Hitchhiker’s Guide to Statistical Comparisons of Reinforcement Learning Algorithms. arXiv:1904.06979 [cs, stat], April 2019. URL http://arxiv.org/abs/1904.06979. arXiv: 1904.06979.
+
+Will Dabney, Georg Ostrovski, David Silver, and Rémi Munos. Implicit Quantile Networks for Distributional Reinforcement Learning. Thirty-fith International Conference on Machine Learning, pp. 10, 2018.
+
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking Deep Reinforcement Learning for Continuous Control. In International Conference on Machine Learning, pp. 1329–1338, June 2016. URL http://proceedings.mlr.press/v48/duan16.html.
+
+B. Efron and R. Tibshirani. Bootstrap Methods for Standard Errors, Confidence Intervals, and Other Measures of Statistical Accuracy. Statistical Science, 1(1):54–75, February 1986. ISSN 0883-4237, 2168-8745. doi: 10.1214/ss/1177013815. URL http://projecteuclid.org/euclid. ss/1177013815.
+
+Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, and Shane Legg. Noisy Networks for Exploration. arXiv:1706.10295 [cs, stat], June 2017. URL http://arxiv. org/abs/1706.10295. arXiv: 1706.10295.
+
+Scott Fujimoto, Herke van Hoof, and David Meger. Addressing Function Approximation Error in Actor-Critic Methods. arXiv:1802.09477 [cs, stat], February 2018. URL http://arxiv. org/abs/1802.09477. arXiv: 1802.09477.
+
+Daniel Golovin, Benjamin Solnik, Subhodeep Moitra, Greg Kochanski, John Karro, and D. Sculley. Google Vizier: A Service for Black-Box Optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining - KDD ’17, pp. 1487–1495, Halifax, NS, Canada, 2017. ACM Press. ISBN 978-1-4503-4887-4. doi: 10.1145/3097983. 3098043. URL http://dl.acm.org/citation.cfm?doid ${ . } = { }$ 3097983.3098043.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. OpenAI Gym, 2016.
+
+Sergio Guadarrama, Anoop Korattikara, Pablo Castro Oscar Ramirez, Ethan Holly, Sam Fishman, Ke Wang, Chris Harris Ekaterina Gonina, Vincent Vanhoucke, and Eugene Brevdo. TF-Agents: A library for reinforcement learning in tensorflow. https://github.com/tensorflow/ agents, 2018. URL https://github.com/tensorflow/agents. [Online; accessed 30-November-2018].
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor. arXiv:1801.01290 [cs, stat], January 2018. URL http://arxiv.org/abs/1801.01290. arXiv: 1801.01290.
+
+James D. Hamilton. Time Series Analysis. Princeton University Press, 1994.
+
+Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep Reinforcement Learning that Matters. arXiv:1709.06560 [cs, stat], September 2017. URL http://arxiv.org/abs/1709.06560. arXiv: 1709.06560.
+
+Matteo Hessel and Joseph Modayil. Rainbow: Combining Improvements in Deep Reinforcement Learning. AAAI, pp. 8, 2018.
+
+Riashat Islam, Peter Henderson, Maziar Gomrokchi, and Doina Precup. Reproducibility of Benchmarked Deep Reinforcement Learning Tasks for Continuous Control. arXiv:1708.04133 [cs], August 2017. URL http://arxiv.org/abs/1708.04133. arXiv: 1708.04133.
+
+Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv:1509.02971 [cs, stat], September 2015. URL http://arxiv.org/abs/1509. 02971. arXiv: 1509.02971.
+
+Marlos C. Machado, Marc G. Bellemare, Erik Talvitie, Joel Veness, Matthew Hausknecht, and Michael Bowling. Revisiting the Arcade Learning Environment: Evaluation Protocols and Open Problems for General Agents. Journal of Artificial Intelligence Research, 61:523–562, March 2018. ISSN 1076-9757. doi: 10.1613/jair.5699. URL https://www.jair.org/index. php/jair/article/view/11182.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, February 2015. ISSN 1476-4687. doi: 10.1038/nature14236. URL https://www.nature.com/articles/nature14236/.
+
+Prabhat Nagarajan, Garrett Warnell, and Peter Stone. Deterministic Implementations for Reproducibility in Deep Reinforcement Learning. arXiv:1809.05676 [cs], September 2018. URL http://arxiv.org/abs/1809.05676. arXiv: 1809.05676.
+
+Charles R Nelson and Charles I Plosser. Trends and random walks in macroeconomic time series. Journal of Monetary Economics, 10:139–162, 1982.
+
+Peter J. Rousseeuw and Christophe Croux. Alternatives to the MedianAbsolute Deviation. Journal of the American Statistical Association, 1993.
+
+Said E. Said and David A. Dickey. Testing for unit roots in autoregressive-moving average models of unknown order. Biometrika, 71(3):599–607, 1984.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal Policy Optimization Algorithms. arXiv:1707.06347 [cs], July 2017. URL http://arxiv.org/ abs/1707.06347. arXiv: 1707.06347.
+
+Joseph P. Simmons, Leif D. Nelson, and Uri Simonsohn. False-Positive Psychology: Undisclosed Flexibility in Data Collection and Analysis Allows Presenting Anything as Significant. Psychological Science, 22(11):1359–1366, November 2011. ISSN 0956-7976, 1467-9280. doi: 10.1177/0956797611417632. URL http://journals.sagepub.com/doi/10.1177/ 0956797611417632.
+
+Richard S Sutton, David A McAllester, Satinder P Singh, and Yishay Mansour. Policy Gradient Methods for Reinforcement Learning with Function Approximation. In NIPS’99 Proceedings of the 12th International Conference on Neural Information Processing Systems, pp. 7, 2000.
+
+Aviv Tamar, Yonatan Glassner, and Shie Mannor. Optimizing the CVaR via Sampling. Proceedings of the Twenty-Ninth AAAI Conference on Artificial Intelligence, pp. 7, 2015.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. MuJoCo: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033, Vilamoura-Algarve, Portugal, October 2012. IEEE. ISBN 978-1-4673-1736-8 978-1-4673-1737-5 978-1-4673-1735-1. doi: 10.1109/IROS.2012.6386109. URL http://ieeexplore.ieee. org/document/6386109/.
+
+# A ASSUMPTIONS AND DEFINITIONS
+
+Reinforcement Learning algorithms vary widely in design, and our metrics are based on certain notions that should span the gamut of RL algorithms.
+
+Policy A policy $\pi _ { \Theta } ( a _ { i } | s _ { i } )$ is a distribution over actions $a _ { i }$ given a current (input) state $s _ { i }$ . We assume policies are parameterized by a parameter $\Theta$ .   
+Agent An agent is defined as a distribution over policies (or equivalently a distribution over parameters $\Theta$ ). In many cases, an agent will be a single policy but for population-based RL methods, the agent is a discrete set of policies.   
+Window A window is a collection of states over which the agent is assumed to have small variation. A window could be a sequence of consecutive time steps for a sequential RL algorithm, or a collection of states at the same training step of a distributed RL algorithm with a parameter server (all agents share $\Theta$ ).   
+Performance The performance of an agent is the mean or median per-epoch reward from running that agent. If the agent is a single policy, then the performance $p ( \pi _ { \Theta } )$ is the mean or median per-epoch reward for that agent. If the agent is a distribution $D ( \Theta )$ of policies, then the performance is the median of $p ( \pi _ { \Theta } )$ with $\Theta \sim D$ .   
+Training Run A training run is a sequence of updates to the agent $D ( \Theta )$ from running a reinforcement learning algorithm. It leads to a trained agent $D _ { f i n a l } ( \Theta )$ . Multiple training runs share no information with each other.
+
+We cannot directly measure performance since it is a statistic across an infinite sample of evaluation runs of an agent. Instead we use windows to compute sample medians to approximate performance.
+
+# B DETRENDING BY DIFFERENCING
+
+Typically, de-trending can be performed in two main ways (Nelson & Plosser, 1982; Hamilton, 1994).   
+Differencing (i.e. $y _ { t } \prime = y _ { t } - y _ { t - 1 } )$ is more appropriate for difference-stationary (DS) processes (e.g.   
+a random walk: $y _ { t } = y _ { t - 1 } + b + \epsilon _ { t } )$ , where the shocks $\epsilon _ { t }$ accumulate over time. For trend-stationary (TS) processes, which are characterized by stationary fluctuations around a deterministic trend, e.g.   
+$y _ { t } = a + b * t + \epsilon _ { t }$ , it is more appropriate to fit and subtract that trend.
+
+We performed an analysis of real training runs and verified that the data are indeed approximately DS, and that differencing does indeed remove the majority of time-dependent structure. For this analysis we used the training runs on Atari as described in 5.2. Before differencing, the Augmented Dickey-Fuller test (ADF test, also known as a difference-stationarity test; Said E. Said & David A. Dickey (1984)) rejects the null hypothesis of a unit root on only $72 \%$ of the runs; after differencing, the ADF test rejects the null hypothesis on $92 \%$ of the runs (p-value threshold 0.05). For the ADF test, the rejection of a unit root (of the autoregressive lag polynomial) implies the alternate hypothesis, which is that the time series is trend-stationary.
+
+Therefore, our training curves are better characterized as an accumulation of shocks, i.e. as DS processes, rather than as mean-reverting TS processes. They are not actually purely DS because the shocks $\epsilon _ { t }$ are not stationary over time, but because we compute standard deviation within sliding windows, we can capture the non-stationarity and change in variability over time. Thus, we chose to detrend using differencing.
+
+As a further note in favor of detrending by differencing, it is useful to observe that many measures of variability are defined relative to the central tendency of the data, e.g. the median absolute deviation $\mathbf { M A D } = \mathbf { m e d i a n } ( | X _ { i } - \widetilde { X } | )$ where $\widetilde { X }$ is the median of $X$ . On the raw data (without differencing), the MAD would be defined relative to $\widetilde { X }$ as median performance, so that any improvements in performance are included in that computation of variability. On the other hand, if we compute MAD on the 1st-order differences, we are using a $\widetilde { X }$ that represents the median change in performance, which is a more reasonable baseline to compute variability against, when we are in fact concerned with the variability of those changes.
+
+A final benefit of differencing is that it is parameter-free.
+
+# C ILLUSTRATIONS OF PERMUTATION TEST PROCEDURES
+
+We illustrate the procedure for computing permutation tests to compare pairs of algorithms on a specified metric, in Figs. 3 (for per-run metrics) and 4 (for across-run metrics).
+
+# D RAW TRAINING CURVES FOR OPENAI MUJOCO TASKS
+
+In Figure 5, we show the raw training curves for the TF-Agents implementations of continuouscontrol algorithms, applied to the OpenAI MuJoCo tasks. These are compared against baselines from the literature, where available (DDPG and TD3: Fujimoto et al. (2018), PPO: Schulman et al. (2017), SAC: Haarnoja et al. (2018))
+
+# E HYPERPARAMETER SETTINGS
+
+For the continuous control experiments, hyperparameters were chosen on a per-environment basis according to the black-box optimization algorithm described in Golovin et al. (2017). The hyperparameter search space is shown in Table 2.
+
+For the discrete control experiments, hyperparameter selection is described in (Castro et al., 2018). Hyperparameters are shown in Table 8, duplicated for reference from https://github.com/google/dopamine/tree/master/baselines.
+
+# Comparing algorithms on per-run metrics
+
+Raw values e.g. 3 runs per (task, algo)
+
+<table><tr><td rowspan=3 colspan=1>algoAalgoBalgoc</td><td rowspan=1 colspan=1>-1,-7,3</td><td rowspan=1 colspan=1>2.5,7,3</td><td rowspan=1 colspan=1>77,90,4</td></tr><tr><td rowspan=1 colspan=1>-4,2,0</td><td rowspan=1 colspan=1>1.9,0.3,4</td><td rowspan=1 colspan=1>5,32,15</td></tr><tr><td rowspan=1 colspan=1>3,2,4</td><td rowspan=1 colspan=1>6,10,5</td><td rowspan=1 colspan=1>52,64,3</td></tr></table>
+
+task1 task2 task3
+
+Evaluate per-run metrics for each run
+
+# Metric values
+
+![](images/ed3269eab6188f2e31d92a52dd7ac6c371b0a746169bfb37b1a85a217fa685dd.jpg)  
+Figure 3: Diagram illustrating the computation of the permutation tests for per-run metrics (Dispersion across Time, Short-term Risk across Time, Long-term Risk across Time). In this example, we are comparing Algorithm A and Algorithm B, and there are only 3 algorithms, 3 tasks, and 3 runs per (task, algo) pair. To compute the difference in average rankings for two algorithms, follow the gray arrows. To compute a null distribution of difference in average rankings (by permuting the runs), follow the blue arrows a number of times (e.g. 1,000 times). Once the null distribution has been computed, the actual value of the difference can be compared with the null distribution to obtain a p-value.
+
+![](images/0c3f8dfbd4924b0d62b579477d339c12c77e7fa8904b822078909fc4e05deb56.jpg)  
+Comparing algorithms on across-run metrics   
+Figure 4: Diagram illustrating the computation of the permutation tests for across-run or acrossrollout metrics (Dispersion across Runs, Risk Across Runs, Dispersion across Fixed-policy rollouts, Risk across Fixed-Policy rollouts). In this example, we are comparing Algorithm A and Algorithm B, and there are only 3 algorithms, 3 tasks, and 3 runs per (task, algo) pair. To compute the difference in average rankings for two algorithms, follow the gray arrows. To compute a null distribution of difference in average rankings (by permuting the runs), follow the blue arrows a number of times (e.g. 1,000 times). Once the null distribution has been computed, the actual value of the difference can be compared with the null distribution to obtain a p-value.
+
+![](images/e662db76af853665422b459608b40a07e165e5e3654a2f6ed6d7dd410136c4b9.jpg)  
+Figure 5: Raw training curves for OpenAI MuJoCo tasks. The $\mathbf { X }$ -axes indicate environment steps, and the y-axes indicate average per-episode return. Dotted lines indicate baseline performance from the literature, where available.
+
+Table 2: Hyperparameter search space for continuous control algorithms.   
+
+<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Search min</td><td rowspan=1 colspan=1>Search max</td></tr><tr><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>actor learning rateα learning ratecritic learning rate target update T</td><td rowspan=1 colspan=1>0.0000010.0000010.0000010.00001</td><td rowspan=1 colspan=1>0.0010.0010.0011.0</td></tr><tr><td rowspan=1 colspan=1>TD3</td><td rowspan=1 colspan=1>actor learning ratecritic learning ratetarget update T</td><td rowspan=1 colspan=1>0.0000010.0000010.00001</td><td rowspan=1 colspan=1>0.0010.0011.0</td></tr><tr><td rowspan=1 colspan=1>PPO</td><td rowspan=1 colspan=1>learning rate</td><td rowspan=1 colspan=1>0.000001</td><td rowspan=1 colspan=1>0.001</td></tr><tr><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1>actor learning ratecritic learning ratetarget update T</td><td rowspan=1 colspan=1>0.0000010.0000010.00001</td><td rowspan=1 colspan=1>0.0010.0011.0</td></tr><tr><td rowspan=1 colspan=1>REINFORCE</td><td rowspan=1 colspan=1>learning rate# episodes before each train step</td><td rowspan=1 colspan=1>0.0000011.0</td><td rowspan=1 colspan=1>0.00110</td></tr></table>
+
+Table 3: Final hyperparameters for SAC.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>actor learning rate</td><td rowspan=1 colspan=1>α learning rate</td><td rowspan=1 colspan=1>critic learning rate</td><td rowspan=1 colspan=1>target update T</td></tr><tr><td rowspan=1 colspan=1>Ant-v2</td><td rowspan=1 colspan=1>0.000006</td><td rowspan=1 colspan=1>0.000009</td><td rowspan=1 colspan=1>0.0009</td><td rowspan=4 colspan=1>0.00020.020.80.00002</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-v2</td><td rowspan=1 colspan=1>0.0001</td><td rowspan=1 colspan=1>0.000005</td><td rowspan=1 colspan=1>0.0004</td></tr><tr><td rowspan=1 colspan=1>Humanoid-v2</td><td rowspan=1 colspan=1>0.0003</td><td rowspan=1 colspan=1>0.0008</td><td rowspan=1 colspan=1>0.0006</td></tr><tr><td rowspan=1 colspan=1>Reacher-v2</td><td rowspan=1 colspan=1>0.00001</td><td rowspan=1 colspan=1>0.000002</td><td rowspan=1 colspan=1>0.0005</td></tr><tr><td rowspan=1 colspan=1>Swimmer-v2</td><td rowspan=1 colspan=1>0.000004</td><td rowspan=1 colspan=1>0.000009</td><td rowspan=1 colspan=1>0.0002</td><td rowspan=2 colspan=1>0.0090.01</td></tr><tr><td rowspan=1 colspan=1>Walker2d-v2</td><td rowspan=1 colspan=1>0.0002</td><td rowspan=1 colspan=1>0.0009</td><td rowspan=1 colspan=1>0.0008</td></tr></table>
+
+Table 4: Final hyperparameters for TD3.   
+
+<table><tr><td></td><td>actor learning rate</td><td>critic learning rate</td><td>target update T</td></tr><tr><td>Ant-v2</td><td>0.000001</td><td>0.0002</td><td>0.0003</td></tr><tr><td>HalfCheetah-v2</td><td>0.0003</td><td>0.0005</td><td>0.02</td></tr><tr><td>Humanoid-v2</td><td>0.0001</td><td>0.0001</td><td>0.0002</td></tr><tr><td>Reacher-v2</td><td>0.000001</td><td>0.00003</td><td>0.00003</td></tr><tr><td>Swimmer-v2</td><td>0.0004</td><td>0.0002</td><td>0.01</td></tr><tr><td>Walker2d-v2</td><td>0.00006</td><td>0.00009</td><td>0.001</td></tr></table>
+
+Table 5: Final hyperparameters for PPO.   
+
+<table><tr><td></td><td>learning rate</td></tr><tr><td>Ant-v2</td><td>0.0008</td></tr><tr><td>HalfCheetah-v2</td><td>0.0008</td></tr><tr><td>Humanoid-v2</td><td>0.0008</td></tr><tr><td>Reacher-v2</td><td>0.00002</td></tr><tr><td>Swimmer-v2</td><td>0.0004</td></tr><tr><td>Walker2d-v2</td><td>0.0002</td></tr></table>
+
+Table 6: Final hyperparameters for DDPG.   
+
+<table><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>actor learning rate</td><td rowspan=1 colspan=1>critic learning rate</td><td rowspan=1 colspan=1>target update T</td></tr><tr><td rowspan=1 colspan=2>Ant-v2</td><td rowspan=1 colspan=1>0.00003</td><td rowspan=1 colspan=1>0.0004</td><td rowspan=3 colspan=1>0.00020.020.01</td></tr><tr><td rowspan=5 colspan=2>HalfCheetah-v2Humanoid-v2Reacher-v2Swimmer-v2Walker2d-v2</td><td rowspan=1 colspan=1>0.00006</td><td rowspan=1 colspan=1>0.0005</td></tr><tr><td rowspan=2 colspan=1>0.000060.00005</td><td rowspan=1 colspan=1>0.00009</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>0.0005</td><td rowspan=1 colspan=1>0.005</td></tr><tr><td rowspan=1 colspan=1>Swimmer-v2</td><td rowspan=1 colspan=1>0.0005</td><td rowspan=1 colspan=1>0.0003</td><td rowspan=2 colspan=1>0.0040.03</td></tr><tr><td rowspan=1 colspan=1>0.0003</td><td rowspan=1 colspan=1>0.0004</td></tr></table>
+
+Table 7: Final hyperparameters for REINFORCE.   
+
+<table><tr><td></td><td>learning rate</td><td># episodes before each train step</td></tr><tr><td>Ant-v2</td><td>0.00002</td><td>9</td></tr><tr><td>HalfCheetah-v2</td><td>0.0004</td><td>7</td></tr><tr><td>Humanoid-v2</td><td>0.0005</td><td>2</td></tr><tr><td>Reacher-v2</td><td>0.000004</td><td>6</td></tr><tr><td>Swimmer-v2</td><td>0.000005</td><td>3</td></tr><tr><td>Walker2d-v2</td><td>0.0001</td><td>6</td></tr></table>
+
+Table 8: Hyperparameters for discrete control algorithms.   
+
+<table><tr><td rowspan=1 colspan=1>Training ∈</td><td rowspan=1 colspan=1>Evaluation ∈</td><td rowspan=1 colspan=1>∈ decay schedule</td><td rowspan=1 colspan=1>Min. history to start learning</td><td rowspan=1 colspan=1>Target network update frequency</td></tr><tr><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>1,000,000 frames</td><td rowspan=1 colspan=1>80,000 frames</td><td rowspan=1 colspan=1>32,000 frames</td></tr></table>
+
+# F PER-TASK METRIC RESULTS
+
+Metric results are shown on a per-task basis in Figs. 6 to 8 for the OpenAI Gym MuJoCo tasks, and Figs. 9 to 23 for the Atari environments. Note that because we are no longer aggregating across tasks in this analysis, we do not need to convert the metric values to rankings.
+
+![](images/cec1c2995b0125b3db4f8df11a4260096c8a000b0b3d95b44278ab1b9e5a0d6f.jpg)
+
+![](images/cb3bb96377fa9630024aa345d04c53765bfdfe2cb4eda6f7dd7e5356d693d3aa.jpg)  
+(a) Dispersion across Time. Better reliability is indicated by less positive values. The x-axes indicate the number of environment steps.   
+Figure 6: Across-time reliability metrics for continuous control RL algorithms tested on OpenAI Gym environments, evaluated on a per-environment basis.
+
+![](images/176a0dc0ee915ad20c06b815fb91fe0bab25cfb83b45b0fe5cc642cefe3955f5.jpg)  
+(c) Median performance during training. Better performance is indicated by more positive values.   
+Figure 7: Across-run reliability metrics and median performance for continuous control RL algorithms tested on OpenAI Gym environments, evaluated on a per-environment basis. The $\mathbf { X }$ -axes indicate the number of environment steps.
+
+![](images/c40b95c7c205c5fa8f147f115ced50722e925bc3c1fd7d76aa073d1f78f7df76.jpg)  
+(c) Median performance on Fixed-policy rollouts. Better performance is indicated by more positive values.
+
+Figure 8: Reliability metrics and median performance on fixed-policy rollouts for continuous control RL algorithms tested on OpenAI Gym environments, evaluated on a per-environment basis.
+
+![](images/aecca9879d7a6eaeb66ab7aa37b8318cd8e92c32be8e7f68a12c2b7d1e6c00a6.jpg)  
+Figure 9: Dispersion across Time for DQN-variants tested on 60 Atari games, evaluated on a perenvironment basis (page 1). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/822d810b075264d2abade575dd47ea5f30457fd848733f1d4b4451a50f5ce8ad.jpg)  
+Figure 10: Dispersion across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/1f628d73d292181bde29ff809254d6e8e95df2e47c007b1318b6344eb3e43d30.jpg)  
+Figure 11: Dispersion across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/2f88232d4df466e1c963b90d94c96ff0f02b9b2e41799e72dcac78a7a7285712.jpg)  
+Figure 12: Short-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 1). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/6354ac16a00c441f4c100baa19bb1b82659cbab0f2c53e861f2ffd30202d7768.jpg)  
+Figure 13: Short-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by less positive values. The x-axes indicate millions of Atari frames.
+
+![](images/5eb59c4fe59ae9b38d5cd99e70adf1cb02b43e32d5a5e79990f7e628d54ae522.jpg)  
+Figure 14: Short-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/d257c73a7b2407b4d0eca08dce88d44ddb4e831dcea84141a1274f7b59d56a3a.jpg)  
+Figure 15: Long-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 1). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/412394c5e0322f1262d4d6db43375b80ab6e47074095e1c73e13b84fda1d07ff.jpg)  
+Figure 16: Long-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/44621f204f2db53c785fee2331ad5872eecdeca5e8bf9a8a22ab2a0e5b99fdc5.jpg)  
+Figure 17: Long-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/a7285425bea4ff7598ae9aa4c469ba5dbac3d5bdd86205c7b3b3bb44803dfcb4.jpg)  
+Figure 18: Dispersion across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 1). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/a3e1dc133f7c697d388b698368423059823c7edf8a45302a893cb1b9442a93c0.jpg)  
+Figure 19: Dispersion across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/5c46d632e8a936307828e2173f3cd2a21a3f456f7a995f9309167561e62ca3dd.jpg)  
+Figure 20: Dispersion across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by less positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/1ec713a7e3857947eb886dda91a755fcf04bbb19f257dcbd0fe0006eb86e994f.jpg)  
+Figure 21: Risk across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 1). Better reliability is indicated by more positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/5f9797ed72410b53b95f2527f66c4b43207fee4b1c4a188e5e076fe304274334.jpg)  
+Figure 22: Risk across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by more positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.
+
+![](images/98295ad14c1dcd95ebc855f8b7b1383bc4d44bd032bd9359f801674f9cb32ed1.jpg)  
+Figure 23: Risk across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by more positive values. The $\mathbf { X }$ -axes indicate millions of Atari frames.

parse/train/SJlpYJBKvH/SJlpYJBKvH_content_list.json

@@ -0,0 +1,2155 @@
+[
+    {
+        "type": "text",
+        "text": "MEASURING THE RELIABILITY OF REINFORCEMENT LEARNING ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            694,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stephanie C.Y. Chan,1∗ Samuel Fishman,1 John Canny,1, 2 Anoop Korattikara,1   \n& Sergio Guadarrama1   \n1Google Research 2Berkeley EECS   \n{scychan,sfishman,canny,kbanoop,sguada}@google.com ",
+        "bbox": [
+            186,
+            167,
+            741,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            273,
+            544,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lack of reliability is a well-known issue for reinforcement learning (RL) algorithms. This problem has gained increasing attention in recent years, and efforts to improve it have grown substantially. To aid RL researchers and production users with the evaluation and improvement of reliability, we propose a set of metrics that quantitatively measure different aspects of reliability. In this work, we focus on variability and risk, both during training and after learning (on a fixed policy). We designed these metrics to be general-purpose, and we also designed complementary statistical tests to enable rigorous comparisons on these metrics. In this paper, we first describe the desired properties of the metrics and their design, the aspects of reliability that they measure, and their applicability to different scenarios. We then describe the statistical tests and make additional practical recommendations for reporting results. The metrics and accompanying statistical tools have been made available as an open-source library.1 We apply our metrics to a set of common RL algorithms and environments, compare them, and analyze the results. ",
+        "bbox": [
+            233,
+            306,
+            766,
+            500
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            336,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning (RL) algorithms, especially Deep RL algorithms, tend to be highly variable in performance and considerably sensitive to a range of different factors, including implementation details, hyper-parameters, choice of environments, and even random seeds (Henderson et al., 2017). This variability hinders reproducible research, and can be costly or even dangerous for real-world applications. Furthermore, it impedes scientific progress in the field when practitioners cannot reliably evaluate or predict the performance of any particular algorithm, compare different algorithms, or even compare different implementations of the same algorithm. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            656
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, Henderson et al. (2017) has performed a detailed analysis of reliability for several policy gradient algorithms, while Duan et al. (2016) has benchmarked average performance of different continuous-control algorithms. In other related work, Colas et al. (2018) have provided a detailed analysis on power analyses for mean performance in RL, and Colas et al. (2019) provide a comprehensive primer on statistical testing for mean and median performance in RL. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            733
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we aim to devise a set of metrics that measure reliability of RL algorithms. Our analysis distinguishes between several typical modes to evaluate RL performance: \"evaluation during training\", which is computed over the course of training, vs. \"evaluation after learning\", which is evaluated on a fixed policy after it has been trained. These metrics are also designed to measure different aspects of reliability, e.g. reproducibility (variability across training runs and variability across rollouts of a fixed policy) or stability (variability within training runs). Additionally, the metrics capture multiple aspects of variability – dispersion (the width of a distribution), and risk (the heaviness and extremity of the lower tail of a distribution). ",
+        "bbox": [
+            174,
+            741,
+            825,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Standardized measures of reliability can benefit the field of RL by allowing RL practitioners to compare algorithms in a rigorous and consistent way. This in turn allows the field to measure progress, and also informs the selection of algorithms for both research and production environments. By measuring various aspects of reliability, we can also identify particular strengths and weaknesses of algorithms, allowing users to pinpoint specific areas of improvement. ",
+        "bbox": [
+            176,
+            858,
+            821,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, in addition to describing these reliability metrics, we also present practical recommendations for statistical tests to compare metric results and how to report the results more generally. As examples, we apply these metrics to a set of algorithms and environments (discrete and continuous, off-policy and on-policy). We have released the code used in this paper as an open-source Python package to ease the adoption of these metrics and their complementary statistics. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/036995dfa853c6dbd3a45a09f7e249ef68cd6dbd779b4de6b68aa9f62e6d42dc.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Dispersion (D)</td><td rowspan=1 colspan=1>Risk (R)</td></tr><tr><td rowspan=2 colspan=1>DUURNNTTIIINNN</td><td rowspan=1 colspan=1>Across Time (T)(within trainingruns)</td><td rowspan=1 colspan=1>IQR* within windows,afterdetrending</td><td rowspan=1 colspan=1>Short-term: CVaR† onfirst-order differencesLong-term: CVaR† onDrawdown</td></tr><tr><td rowspan=1 colspan=1>Across Runs (R)</td><td rowspan=1 colspan=1>IQR* across training runs,after low-pass filtering.</td><td rowspan=1 colspan=1>CVaR† across runs</td></tr><tr><td rowspan=1 colspan=1>LIIANINNTIEEH</td><td rowspan=1 colspan=1>Across rollouts ona Fixed Policy (F)</td><td rowspan=1 colspan=1>IQR* across rollouts for afixed policy</td><td rowspan=1 colspan=1>CVaR† across rollouts for afixed policy</td></tr></table>",
+        "bbox": [
+            178,
+            252,
+            820,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Summary of our proposed reliability metrics. For evaluation DURING TRAINING, which measures reliability over the course of training an algorithm, the inputs to the metrics are the performance curves of an algorithm, evaluated at regular intervals during a single training run (or on a set of training runs). For evaluation AFTER LEARNING, which measures reliability of an alreadytrained policy, the inputs to the metrics are the performance scores of a set of rollouts of that fixed policy. $^ { * } \\mathrm { I Q R }$ : inter-quartile range. ${ \\dag } \\mathrm { C V a R }$ : conditional value at risk. ",
+        "bbox": [
+            173,
+            481,
+            826,
+            565
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELIABILITY METRICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            590,
+            400,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We target three different axes of variability, and two different measures of variability along each axis. We denote each of these by a letter, and each metric as a combination of an axis $^ +$ a measure, e.g. \"DR\" for \"Dispersion Across Runs\". See Table 1 for a summary. Please see Appendix A for more detailed definitions of the terms used here. ",
+        "bbox": [
+            174,
+            622,
+            826,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 AXES OF VARIABILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            694,
+            370,
+            708
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our metrics target the following three axes of variability. The first two capture reliability \"during training\", while the last captures reliability of a fixed policy \"after learning\". ",
+        "bbox": [
+            174,
+            719,
+            823,
+            748
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "During training: Across Time (T) In the setting of evaluation during training, one desirable property for an RL algorithm is to be stable \"across time\" within each training run. In general, smooth monotonic improvement is preferable to noisy fluctuations around a positive trend, or unpredictable swings in performance. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This type of stability is important for several reasons. During learning, especially when deployed for real applications, it can be costly or even dangerous for an algorithm to have unpredictable levels of performance. Even in cases where bouts of poor performance do not directly cause harm, e.g. if training in simulation, high instability implies that algorithms have to be check-pointed and evaluated more frequently in order to catch the peak performance of the algorithm, which can be expensive. Furthermore, while training, it can be a waste of computational resources to train an unstable algorithm that tends to forget previously learned behaviors. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "During training: Across Runs (R) During training, RL algorithms should have easily and consistently reproducible performances across multiple training runs. Depending on the components that we allow to vary across training runs, this variability can encapsulate the algorithm’s sensitivity to a variety of factors, such as: random seed and initialization of the optimization, random seed and initialization of the environment, implementation details, and hyper-parameter settings. Depending on the goals of the analysis, these factors can be held constant or allowed to vary, in order to disentangle the contribution of each factor to variability in training performance. High variability on any of these dimensions leads to unpredictable performance, and also requires a large search in order to find a model with good performance. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After learning: Across rollouts of a fixed policy (F) When evaluating a fixed policy, a natural concern is the variability in performance across multiple rollouts of that fixed policy. Each rollout may be specified e.g. in terms of a number of actions, environment steps, or episodes. Generally, this metric measures sensitivity to both stochasticity from the environment and stochasticity from the training procedure (the optimization). Practitioners may sometimes wish to keep one or the other constant if it is important to disentangle the two factors (e.g. holding constant the random seed of the environment while allowing the random seed controlling optimization to vary across rollouts). ",
+        "bbox": [
+            174,
+            244,
+            825,
+            342
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 MEASURES OF VARIABILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            410,
+            372
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For each axis of variability, we have two kinds of measures: dispersion and risk. ",
+        "bbox": [
+            176,
+            385,
+            696,
+            400
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dispersion Dispersion is the width of the distribution. To measure dispersion, we use \"robust statistics\" such as the Inter-quartile range (IQR) (i.e. the difference between the 75th and 25th percentiles) and the Median absolute deviation from the median (MAD), which are more robust statistics and don’t require assuming normality of the distributions. 2 We prefer to use IQR over MAD, because it is more appropriate for asymmetric distributions (Rousseeuw & Croux, 1993). ",
+        "bbox": [
+            174,
+            415,
+            825,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Risk In many cases, we are concerned about the worst-case scenarios. Therefore, we define risk as the heaviness and extent of the lower tail of the distribution. This is complementary to measures of dispersion like IQR, which cuts off the tails of the distribution. To measure risk, we use the Conditional Value at Risk (CVaR), also known as “expected shortfall\". CVaR measures the expected loss in the worst-case scenarios, defined by some quantile $\\alpha$ . It is computed as the expected value in the left-most tail of a distribution (Acerbi & Tasche, 2002). We use the following definition for the CVaR of a random variable $X$ for a given quantile $\\alpha$ : ",
+        "bbox": [
+            173,
+            500,
+            825,
+            598
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9803223e85a0b7a96ee9da5c8ea4ee6528d4dafa78b97ac1a3549f3f34902fa1.jpg",
+        "text": "$$\n\\mathrm { C V a R } _ { \\alpha } ( X ) = \\operatorname { \\mathbb { E } } \\left[ X | X \\leq V a R _ { \\alpha } ( X ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            617,
+            625,
+            635
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha \\in ( 0 , 1 )$ and the $V a R _ { \\alpha }$ (Value at Risk) is just the $\\alpha$ -quantile of the distribution of $X$ . Originally developed in finance, CVaR has also seen recent adoption in Safe RL as an additional component of the objective function by applying it to the cumulative returns within an episode, e.g. Bäuerle & Ott (2011); Chow & Ghavamzadeh (2014); Tamar et al. (2015). In this work, we apply CVaR to the dimensions of reliability described in Section 2.1. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 DESIDERATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            732,
+            303,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In designing our metrics and statistical tests, we required that they fulfill the following criteria: ",
+        "bbox": [
+            173,
+            758,
+            792,
+            773
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• A minimal number of configuration parameters – to facilitate standardization as well as to minimize “researcher degrees of freedom\" (where flexibility may allow users to tune settings to produce more favorable results, leading to an inflated rate of false positives) (Simmons et al., 2011). • Robust statistics, when possible. Robust statistics are less sensitive to outliers and have more reliable performance for a wider range of distributions. Robust statistics are especially important when applied to training performance, which tends to be highly non-Gaussian, making metrics such as variance and standard deviation inappropriate. For example, training performance is often bi-modal, with a concentration of points near the starting level and another concentration at the level of asymptotic performance. ",
+        "bbox": [
+            214,
+            785,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            230,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Invariance to sampling frequency – results should not be biased by the frequency at which an algorithm was evaluated during training. See Section 2.5 for further discussion. ",
+        "bbox": [
+            215,
+            166,
+            823,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Enable meaningful statistical comparisons on the metrics, while making minimal assumptions about the distribution of the results. We thus designed statistical procedures that are non-parametric (Section 4). ",
+        "bbox": [
+            218,
+            200,
+            823,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "OpenAI Gym -- During Training ",
+        "text_level": 1,
+        "bbox": [
+            410,
+            268,
+            635,
+            282
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8622396b34b55c3757bd48070b2e4afc29379a1358f8c5009ffb3f46074ccc82.jpg",
+        "image_caption": [
+            "Figure 1: Reliability metrics and median performance for continuous control RL algorithms (DDPG, TD3, SAC, REINFORCE, and PPO) tested on OpenAI Gym environments. Rank 1 always indicates \"best\" reliability, e.g. lowest IQR across runs. Error bars are $9 5 \\%$ bootstrap confidence intervals (# bootstraps $= 1 { , } 0 0 0 \\rangle$ ). Significant pairwise differences in ranking between pairs of algorithms are indicated by black horizontal lines above the colored bars. ( $\\langle \\alpha = 0 . 0 5$ with Benjamini-Yekutieli correction, permutation test with # permutations $= 1 { , } 0 0 0 $ ). Note that the best algorithms by median performance are not always the best algorithms on reliability. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            290,
+            767,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4 METRIC DEFINITIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            367,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Dispersion across Time (DT): IQR across Time To measure dispersion across time (DT), we wished to isolate higher-frequency variability, rather than capturing longer-term trends. We did not want our metrics to be influenced by positive trends of improvement during training, which are in fact desirable sources of variation in the training performance. Therefore, we apply detrending before computing dispersion metrics. For detrending, we used differencing (i.e. $y _ { t } \\prime = y _ { t } - y _ { t - 1 } )$ .3 The final measure consisted of inter-quartile range (IQR) within a sliding window along the detrended training curve. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c0f6add0daab1e92929de06c0d271ddac8d145b41450b22d233810e7f438292d.jpg",
+        "image_caption": [
+            "Figure 2: Reliability metrics and median performance for four DQN-variants (C51, DQN: Deep Q-network, IQ: Implicit Quantiles, and RBW: Rainbow) tested on 60 Atari games. Rank 1 always indicates \"best\" reliability, e.g. lowest IQR across runs. Significant pairwise differences in ranking between pairs of algorithms are indicated by black lines above the colored circles. $\\alpha = 0 . 0 5$ with Benjamini-Yekutieli correction, permutation test with # permutations $= 1 { , } 0 0 0 $ ). Note that the best algorithms by median performance are not always the best algorithms on reliability. Error bars are $9 5 \\%$ bootstrap confidence intervals (# bootstraps $= 1 { , } 0 0 0 $ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            106,
+            772,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            685,
+            825,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Short-term Risk across Time (SRT): CVaR on Differences For this measure, we wish to measure the most extreme short-term drop over time. To do this, we apply CVaR to the changes in performance from one evaluation point to the next. I.e., in Eq. 1, $X$ represents the differences from one evaluation time-point to the next. We first compute the time-point to time-point differences on each training run. These differences are normalized by the distance between time-points, to ensure invariance to evaluation frequency (see Section 2.5). Then, we obtain the distribution of these differences, and find the $\\alpha$ -quantile. Finally, we compute the expected value of the distribution below the $\\alpha$ -quantile. This gives us the worst-case expected drop in performance during training, from one point of evaluation to the next. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Long-term Risk across Time (LRT): CVaR on Drawdown For this measure, we would also like to be able to capture whether an algorithm has the potential to lose a lot of performance relative to its peak, even if on a longer timescale, e.g. over an accumulation of small drops. For this measure, we apply CVaR to the Drawdown. The Drawdown at time $T$ is the drop in performance relative to the highest peak so far, and is another measure borrowed from economics (Chekhlov et al., 2005). I.e. Drawdown $\\mathbf { \\Psi } _ { T } = R _ { T } - \\operatorname* { m a x } _ { t < - T } R _ { t }$ . Like the SRT metric, the LRT can capture unusually large short-term drops in performance, but can also capture unusually large drops that occur over longer timescales. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dispersion across Runs (DR): IQR across Runs Unlike the rest of the metrics described here, the dispersion across training runs has previously been used to characterize performance (e.g. Duan et al. (2016); Islam et al. (2017); Bellemare et al. (2017); Fortunato et al. (2017); Nagarajan et al. (2018)). This is usually measured by taking the variance or standard deviation across training runs at a set of evaluation points. We build on the existing practice by recommending first performing low-pass filtering of the training data, to filter out high-frequency variability within runs (this is instead measured using Dispersion across Time, DT). We also replace variance or standard deviation with robust statistics like IQR. ",
+        "bbox": [
+            173,
+            231,
+            825,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Risk across Runs (RR): CVaR across Runs In order to measure Risk across Runs (RR), we apply CVaR to the final performance of all the training runs. This gives a measure of the expected performance of the worst runs. ",
+        "bbox": [
+            174,
+            358,
+            823,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dispersion across Fixed-Policy Rollouts (DF): IQR across Rollouts When evaluating a fixed policy, we are interested in variability in performance when the same policy is rolled out multiple times. To compute this metric, we simply compute the IQR on the performance of the rollouts. ",
+        "bbox": [
+            174,
+            416,
+            821,
+            458
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Risk across Fixed-Policy Rollouts (RF): CVaR across Rollouts This metric is similar to DF, except that we apply CVaR on the rollout performances. ",
+        "bbox": [
+            174,
+            473,
+            823,
+            502
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.5 INVARIANCE TO FREQUENCY OF EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            520,
+            531,
+            534
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Different experiments and different tasks may produce evaluations at different frequencies during training. Therefore, the reliability metrics should be unbiased by the choice of evaluation frequency. As long as there are no cyclical patterns in performance, the frequency of evaluation will not bias any of the metrics except Long-Term Risk across Time (LRT). For all other metrics, changes in the frequency of evaluation will simply lead to more or less noisy estimates of these metrics. For LRT, comparisons should only be made if the frequency of evaluation is held constant across experiments. ",
+        "bbox": [
+            174,
+            546,
+            826,
+            630
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 RECOMMENDATIONS FOR REPORTING METRICS AND PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            651,
+            754,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Whether evaluating an algorithm for practical use or for research, we recommend evaluating all of the reliability metrics described above. Each metric measures a different aspect of reliability, and can help pinpoint specific strengths and weaknesses of the algorithm. Evaluating the metrics is easy with the open-source Python package that we have released. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Reporting parameters. Even given our purposeful efforts to minimize the number of parameters in the reliability metrics, a few remain to be specified by the user that can affect the results, namely: window size (for Dispersion across Time), frequency threshold for low-pass and high-pass filtering (Dispersion across Time, Dispersion across Runs), evaluation frequency (only for Long-term Risk across Time), and length of training runs. Therefore, when reporting these metrics, these parameters need to be clearly specified, and must also be held constant across experiments for meaningful comparisons. The same is true for any other parameters that affect evaluation, e.g., the number of roll-outs per evaluation, the parameters of the environment, whether on-line or off-line evaluation is used, and the random seeds chosen. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            878
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Collapsing across evaluation points. Some of the in-training reliability metrics (Dispersion across Runs, Risk across Runs, and Dispersion across Time) need to be evaluated at multiple evaluation points along the training runs. If it is useful to obtain a small number of values to summarize each metric, we recommend dividing the training run into \"time frames\" (e.g. beginning, middle, and end), and collapsing across all evaluation points within each time frame. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Normalization by performance. Different algorithms can have vastly different ranges of performance even on the same task, and variability in performance tends to scale with actual performance. Thus, we normalize our metrics in post-processing by a measure of the range of performance for each algorithm. For \"during training\" reliability, we recommend normalizing by the median range of performance, which we define as the $p _ { P _ { 9 } 5 } - p _ { t = 0 }$ , where $p _ { P { 5 } }$ is the 95th percentile and $p _ { t = 0 }$ is the starting performance. For \"after learning\" reliability, the range of performance may not be available, in which case we use the median performance directly. ",
+        "bbox": [
+            174,
+            161,
+            825,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ranking the algorithms. Because different environments have different ranges and distributions of reward, we must be careful when aggregating across environments or comparing between environments. Thus, if the analysis involves more than one environment, the per-environment median results for the algorithms are first converted to rankings, by ranking all algorithms within each task. To summarize the performance of a single algorithm across multiple tasks, we compute the mean ranking across tasks. ",
+        "bbox": [
+            174,
+            275,
+            825,
+            358
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Per-environment analysis. The same algorithm can have different patterns of reliability for different environments. Therefore, we recommend inspecting reliability metrics on a per-environment basis, as well as aggregating across environments as described above. ",
+        "bbox": [
+            174,
+            375,
+            826,
+            416
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 CONFIDENCE INTERVALS AND STATISTICAL SIGNIFICANCE TESTS FOR COMPARISON ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            438,
+            794,
+            470
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 CONFIDENCE INTERVALS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            487,
+            388,
+            501
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We assume that the metric values have been converted to mean rankings, as explained in Section 3. To obtain confidence intervals on the mean rankings for each algorithm, we apply bootstrap sampling on the runs, by resampling runs with replacement (Efron & Tibshirani, 1986). ",
+        "bbox": [
+            174,
+            513,
+            825,
+            555
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For metrics that are evaluated per-run (e.g. Dispersion across Time), we can resample the metric values directly, and then recompute the mean rankings on each resampling to obtain a distribution over the rankings; this allow us to compute confidence intervals. For metrics that are evaluated across-runs, we need to resample the runs themselves, then evaluate the metrics on each resampling, before recomputing the mean rankings to obtain a distribution on the mean rankings. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 SIGNIFICANCE TESTS FOR COMPARING ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            648,
+            584,
+            664
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Commonly, we would like to compare algorithms evaluated on a fixed set of environments. To determine whether any two algorithms have statistically significant differences in their metric rankings, we perform an exact permutation test on each pair of algorithms. Such tests allow us to compute a $\\mathsf { p }$ -value for the null hypothesis (probability that the methods are in fact indistinguishable on the reliability metric). ",
+        "bbox": [
+            174,
+            675,
+            825,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We designed our permutation tests based on the null hypothesis that runs are exchangeable across the two algorithms being compared. In brief, let $A$ and $B$ be sets of performance measurements for algorithms $a$ and $b$ . Let $M e t r i c ( X )$ be a reliability metric, e.g. the inter-quartile range across runs, computed on a set of measurements $X$ . MetricRanking $( X )$ is the mean ranking across tasks on $X$ , compared to the other algorithms being considered. We compute test statistic ",
+        "bbox": [
+            174,
+            752,
+            825,
+            821
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4bf903962dd4b4bef59257e18d2840e88f4b6af457eac0e667b574b25e398b6b.jpg",
+        "text": "$$\ns _ { M e t r i c R a n k i n g } ( A , B ) = M e t r i c R a n k i n g ( A ) - M e t r i c R a n k i n g ( B ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            830,
+            736,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next we compute the distribution for $\\AA ^ { S } M e t r i c R a n k i n g$ under the null hypothesis that the methods are equivalent, i.e. that performance measurements should have the same distribution for $a$ and $b$ . We do this by computing random partitions $A ^ { \\prime } , B ^ { \\prime }$ of $\\{ A \\cup B \\}$ , and computing the test statistic $s _ { M e t r i c R a n k i n g } ( A ^ { \\prime } , B ^ { \\prime } )$ on each partition. This yields a distribution for sMetricRanking (for sufficiently many samples), and the $\\mathsf { p }$ -value can be computed from the percentile value of $s _ { M e t r i c R a n k i n g } ( A , B )$ in this distribution. As with the confidence intervals, a different procedure is required for per-run vs across-run metrics. Please see Appendix C for diagrams illustrating the permutation test procedures. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When performing pairwise comparisons between algorithms, it is critical to include corrections for multiple comparisons. This is because the probability of incorrect inferences increases with a greater number of simultaneous comparisons. We recommend using the Benjamini-Yekutieli method, which controls the false discovery rate (FDR), i.e., the proportion of rejected null hypotheses that are false.4 ",
+        "bbox": [
+            174,
+            152,
+            825,
+            208
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 REPORTING ON STATISTICAL TESTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            228,
+            460,
+            242
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It is important to report the details of any statistical tests performed, e.g. which test was used, the significance threshold, and the type of multiple-comparisons correction used. ",
+        "bbox": [
+            173,
+            256,
+            823,
+            284
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 ANALYSIS OF RELIABILITY FOR COMMON ALGORITHMS AND ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            306,
+            718,
+            340
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide examples of applying the reliability metrics to a number of RL algorithms and environments, following the recommendations described above. ",
+        "bbox": [
+            174,
+            357,
+            823,
+            385
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 CONTINUOUS CONTROL ALGORITHMS ON OPENAI GYM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            406,
+            604,
+            420
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We applied the reliability metrics to algorithms tested on seven continuous control environments from the Open-AI Gym (Greg Brockman et al., 2016) run on the MuJoCo physics simulator (Todorov et al., 2012). We tested REINFORCE (Sutton et al., 2000), DDPG (Lillicrap et al., 2015), PPO (Schulman et al., 2017), TD3 (Fujimoto et al., 2018), and SAC (Haarnoja et al., 2018) on the following Gym environments: Ant-v2, HalfCheetah-v2, Humanoid-v2, Reacher-v2, Swimmer-v2, and Walker2d-v2. We used the implementations of DDPG, TD3, and SAC from the TF-Agents library (Guadarrama et al., 2018). Each algorithm was run on each environment for 30 independent training runs. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            529
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We used a black-box optimizer (Golovin et al., 2017) to tune selected hyperparameters on a per-task basis, optimizing for final performance. The remaining hyperparameters were defined as stated in the corresponding original papers. See Appendix E for details of the hyperparameter search space and the final set of hyperparameters. During training, we evaluated the policies at a frequency of 1000 training steps. Each algorithm was run for a total of two million environment steps. For the “online” evaluations we used the generated training curves, averaging returns over recent training episodes collected using the exploration policy as it evolves. The raw training curves are shown in Appendix D. For evaluations after learning on a fixed policy, we took the last checkpoint from each training run as the fixed policy for evaluation. Each of these policies was then evaluated for 30 roll-outs, where each roll-out was defined as 1000 environment steps. ",
+        "bbox": [
+            173,
+            536,
+            825,
+            675
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 DISCRETE CONTROL: DQN VARIANTS ON ATARI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            695,
+            552,
+            709
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also applied the reliability metrics to the RL algorithms and training data released as part of the Dopamine package (Castro et al., 2018). The data comprise the training runs of four RL algorithms, each applied to 60 Atari games. The RL algorithms are: DQN (Mnih et al., 2015), Implicit Quantile (IQN) (Dabney et al., 2018), C51 (Bellemare et al., 2017), and a variant of Rainbow implementing the three most important components (Hessel & Modayil, 2018). The algorithms were trained on each game for 5 training runs. Hyper-parameters follow the original papers, but were modified as necessary to follow Rainbow (Hessel & Modayil, 2018), to ensure apples-to-apples comparison. See Appendix E for the hyperparameters. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "During training, the algorithms were evaluated in an “online” fashion every 1 million frames, averaging across the training episodes as recommended for evaluations on the ALE (Machado et al., 2018). Each training run consisted of approximately 200 million Atari frames (rounding to the nearest episode boundary every 1 million frames).5 For evaluations after learning on a fixed policy (“after learning”), we took the last checkpoint from each training run as the fixed policies for evaluation. We then evaluated each of these policies for 125,000 environment steps. ",
+        "bbox": [
+            176,
+            840,
+            823,
+            882
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 PARAMETERS FOR RELIABILITY METRICS, CONFIDENCE INTERVALS, AND STATISTICAL TESTS ",
+        "bbox": [
+            174,
+            174,
+            813,
+            200
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the MuJoCo environments, we applied a sliding window of 100000 training steps for Dispersion across Time. For the Atari experiments, we used a sliding window size of 25 on top of the evaluations for the Dispersion across Time. For metrics with multiple evaluation points, we divided each training run into 3 time frames and averaged the metric rankings within each time frame. Because the results were extremely similar for all three time frames, we here report just for the final time frames. ",
+        "bbox": [
+            174,
+            217,
+            825,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Statistical tests for comparing algorithms were performed according to the recommendations in Section 4. We used pairwise permutation tests using 10,000 permutations per test, with a significance threshold of 0.05 and Benjamini-Yekutieli multiple-comparisons correction. ",
+        "bbox": [
+            176,
+            294,
+            825,
+            337
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 MEDIAN PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            363,
+            383,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The median performance of an algorithm is not a reliability metric, but it is interesting to see side-byside with the reliability metrics. For analyzing median performance for the DQN variants, we used the normalization scheme of (Mnih et al., 2015), where an algorithm’s performance is normalized against a lower baseline (e.g. the performance of a random policy) and an upper baseline (e.g. the performance of a human): $\\begin{array} { r } { \\bar { P _ { \\mathrm { n o r m a l i z e d } } } = \\frac { P - B _ { \\mathrm { l o w e r } } } { B _ { \\mathrm { u p p e r } } - B _ { \\mathrm { l o w e r } } } } \\end{array}$ . Median performance was not normalized for the continuous control algorithms. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            508,
+            277,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The reliability metric rankings are shown in Fig. 1 for the MuJoCo results. We see that, according to Median Performance during training, SAC and TD3 have the best performance and perform similarly well, while REINFORCE performs the worst. However, SAC outperforms TD3 on all reliability metrics during training. Furthermore, both SAC and TD3 perform relatively poorly on all reliability metrics after learning, despite performing best on median performance. ",
+        "bbox": [
+            174,
+            539,
+            823,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The reliability metric rankings are shown in Fig. 2 for the Atari results. Here we see a similar result that, even though Rainbow performs significantly better than IQN in Median Performance, IQN performs numerically or significantly better than Rainbow on many of the reliability metrics. ",
+        "bbox": [
+            176,
+            616,
+            823,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The differing patterns in these metrics demonstrates that reliability is a separate dimension that needs to be inspected separately from mean or median performance – two algorithms may have similar median performance but may nonetheless significantly differ in reliability, as with SAC and TD3 above. Additionally, these results demonstrate that reliability along one axis does not necessarily correlate with reliability on other axes, demonstrating the value of evaluating these different dimensions so that algorithms can be compared and selected based on the requirements of the problem at hand. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To see metric results evaluated on a per-environment basis, please refer to Appendix F. Rank order of algorithms was often relatively consistent across the different environments evaluated. However, different environments did display different patterns across algorithms. For example, even though SAC showed the same or better Dispersion across Runs for most of the MuJoCo environments evaluated, it did show slightly worse Dispersion across Runs for the HalfCheetah environment (Fig 7a). This kind of result emphasizes the importance of inspecting reliability (and other performance metrics) on a per-environment basis, and also of evaluating reliability and performance on the environment of interest, if possible. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            881
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have presented a number of metrics, designed to measure different aspects of reliability of RL algorithms. We motivated the design goals and choices made in constructing these metrics, and also presented practical recommendations for the measurement of reliability for RL. Additionally, we presented examples of applying these metrics to common RL algorithms and environments, and showed that these metrics can reveal strengths and weaknesses of an algorithm that are obscured when we only inspect mean or median performance. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            233,
+            326,
+            244
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Many thanks to the following people for helpful discussions during the formulation of these metrics and the writing of the paper: Mohammad Ghavamzadeh, Yinlam Chow, Danijar Hafner, Rohan Anil, Archit Sharma, Vikas Sindhwani, Krzysztof Choromanski, Joelle Pineau, Hal Varian, Shyue-Ming Loh, and Tim Hesterberg. Thanks also to Toby Boyd for his assistance in the open-sourcing process, Oscar Ramirez for code reviews, and Pablo Castro for his help with running experiments using the Dopamine baselines data. ",
+        "bbox": [
+            174,
+            255,
+            826,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            285,
+            375
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Carlo Acerbi and Dirk Tasche. Expected Shortfall: A Natural Coherent Alternative to Value at Risk. Economic Notes, 31(2):379–388, July 2002. ISSN 0391-5026, 1468-0300. doi: 10.1111/ 1468-0300.00091. URL http://doi.wiley.com/10.1111/1468-0300.00091. ",
+        "bbox": [
+            174,
+            382,
+            826,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc G. Bellemare, Will Dabney, and Rémi Munos. A Distributional Perspective on Reinforcement Learning. arXiv:1707.06887 [cs, stat], July 2017. URL http://arxiv.org/abs/1707. 06887. arXiv: 1707.06887. ",
+        "bbox": [
+            176,
+            431,
+            825,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicole Bäuerle and Jonathan Ott. Markov Decision Processes with Average-Value-at-Risk criteria. Mathematical Methods of Operations Research, 74(3):361–379, December 2011. ISSN 1432-2994, 1432-5217. doi: 10.1007/s00186-011-0367-0. URL http://link.springer.com/10. 1007/s00186-011-0367-0. ",
+        "bbox": [
+            174,
+            481,
+            826,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pablo Samuel Castro, Subhodeep Moitra, Carles Gelada, Saurabh Kumar, and Marc G. Bellemare. Dopamine: A research framework for deep reinforcement learning. CoRR, abs/1812.06110, 2018. URL http://arxiv.org/abs/1812.06110. ",
+        "bbox": [
+            178,
+            545,
+            825,
+            588
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexei Chekhlov, Stanislav Uryasev, and Michael Zabarankin. Drawdown measure in portfolio optimization. International Journal of Theoretical and Applied Finance, 8(1):46, 2005. ",
+        "bbox": [
+            173,
+            594,
+            823,
+            625
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yinlam Chow and Mohammad Ghavamzadeh. Algorithms for CVaR Optimization in MDPs. Advances in Neural Information Processing Systems, pp. 9, 2014. ",
+        "bbox": [
+            173,
+            631,
+            823,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cédric Colas, Olivier Sigaud, and Pierre-Yves Oudeyer. How Many Random Seeds? Statistical Power Analysis in Deep Reinforcement Learning Experiments. arXiv:1806.08295 [cs, stat], June 2018. URL http://arxiv.org/abs/1806.08295. arXiv: 1806.08295. ",
+        "bbox": [
+            174,
+            666,
+            823,
+            710
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cédric Colas, Olivier Sigaud, and Pierre-Yves Oudeyer. A Hitchhiker’s Guide to Statistical Comparisons of Reinforcement Learning Algorithms. arXiv:1904.06979 [cs, stat], April 2019. URL http://arxiv.org/abs/1904.06979. arXiv: 1904.06979. ",
+        "bbox": [
+            174,
+            717,
+            823,
+            761
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Will Dabney, Georg Ostrovski, David Silver, and Rémi Munos. Implicit Quantile Networks for Distributional Reinforcement Learning. Thirty-fith International Conference on Machine Learning, pp. 10, 2018. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            810
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking Deep Reinforcement Learning for Continuous Control. In International Conference on Machine Learning, pp. 1329–1338, June 2016. URL http://proceedings.mlr.press/v48/duan16.html. ",
+        "bbox": [
+            176,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "B. Efron and R. Tibshirani. Bootstrap Methods for Standard Errors, Confidence Intervals, and Other Measures of Statistical Accuracy. Statistical Science, 1(1):54–75, February 1986. ISSN 0883-4237, 2168-8745. doi: 10.1214/ss/1177013815. URL http://projecteuclid.org/euclid. ss/1177013815. ",
+        "bbox": [
+            176,
+            867,
+            828,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, and Shane Legg. Noisy Networks for Exploration. arXiv:1706.10295 [cs, stat], June 2017. URL http://arxiv. org/abs/1706.10295. arXiv: 1706.10295. ",
+        "bbox": [
+            174,
+            103,
+            828,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, Herke van Hoof, and David Meger. Addressing Function Approximation Error in Actor-Critic Methods. arXiv:1802.09477 [cs, stat], February 2018. URL http://arxiv. org/abs/1802.09477. arXiv: 1802.09477. ",
+        "bbox": [
+            173,
+            170,
+            826,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Golovin, Benjamin Solnik, Subhodeep Moitra, Greg Kochanski, John Karro, and D. Sculley. Google Vizier: A Service for Black-Box Optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining - KDD ’17, pp. 1487–1495, Halifax, NS, Canada, 2017. ACM Press. ISBN 978-1-4503-4887-4. doi: 10.1145/3097983. 3098043. URL http://dl.acm.org/citation.cfm?doid ${ . } = { }$ 3097983.3098043. ",
+        "bbox": [
+            173,
+            222,
+            826,
+            292
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. OpenAI Gym, 2016. ",
+        "bbox": [
+            171,
+            301,
+            825,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergio Guadarrama, Anoop Korattikara, Pablo Castro Oscar Ramirez, Ethan Holly, Sam Fishman, Ke Wang, Chris Harris Ekaterina Gonina, Vincent Vanhoucke, and Eugene Brevdo. TF-Agents: A library for reinforcement learning in tensorflow. https://github.com/tensorflow/ agents, 2018. URL https://github.com/tensorflow/agents. [Online; accessed 30-November-2018]. ",
+        "bbox": [
+            174,
+            340,
+            826,
+            411
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor. arXiv:1801.01290 [cs, stat], January 2018. URL http://arxiv.org/abs/1801.01290. arXiv: 1801.01290. ",
+        "bbox": [
+            174,
+            420,
+            826,
+            463
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James D. Hamilton. Time Series Analysis. Princeton University Press, 1994. ",
+        "bbox": [
+            173,
+            472,
+            674,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep Reinforcement Learning that Matters. arXiv:1709.06560 [cs, stat], September 2017. URL http://arxiv.org/abs/1709.06560. arXiv: 1709.06560. ",
+        "bbox": [
+            174,
+            497,
+            826,
+            540
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matteo Hessel and Joseph Modayil. Rainbow: Combining Improvements in Deep Reinforcement Learning. AAAI, pp. 8, 2018. ",
+        "bbox": [
+            173,
+            550,
+            823,
+            579
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Riashat Islam, Peter Henderson, Maziar Gomrokchi, and Doina Precup. Reproducibility of Benchmarked Deep Reinforcement Learning Tasks for Continuous Control. arXiv:1708.04133 [cs], August 2017. URL http://arxiv.org/abs/1708.04133. arXiv: 1708.04133. ",
+        "bbox": [
+            173,
+            588,
+            825,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv:1509.02971 [cs, stat], September 2015. URL http://arxiv.org/abs/1509. 02971. arXiv: 1509.02971. ",
+        "bbox": [
+            174,
+            641,
+            828,
+            696
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marlos C. Machado, Marc G. Bellemare, Erik Talvitie, Joel Veness, Matthew Hausknecht, and Michael Bowling. Revisiting the Arcade Learning Environment: Evaluation Protocols and Open Problems for General Agents. Journal of Artificial Intelligence Research, 61:523–562, March 2018. ISSN 1076-9757. doi: 10.1613/jair.5699. URL https://www.jair.org/index. php/jair/article/view/11182. ",
+        "bbox": [
+            174,
+            707,
+            826,
+            779
+        ],
+        "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):529–533, February 2015. ISSN 1476-4687. doi: 10.1038/nature14236. URL https://www.nature.com/articles/nature14236/. ",
+        "bbox": [
+            174,
+            787,
+            826,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Prabhat Nagarajan, Garrett Warnell, and Peter Stone. Deterministic Implementations for Reproducibility in Deep Reinforcement Learning. arXiv:1809.05676 [cs], September 2018. URL http://arxiv.org/abs/1809.05676. arXiv: 1809.05676. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Charles R Nelson and Charles I Plosser. Trends and random walks in macroeconomic time series. Journal of Monetary Economics, 10:139–162, 1982. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peter J. Rousseeuw and Christophe Croux. Alternatives to the MedianAbsolute Deviation. Journal of the American Statistical Association, 1993. ",
+        "bbox": [
+            173,
+            143,
+            823,
+            172
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Said E. Said and David A. Dickey. Testing for unit roots in autoregressive-moving average models of unknown order. Biometrika, 71(3):599–607, 1984. ",
+        "bbox": [
+            173,
+            185,
+            823,
+            214
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal Policy Optimization Algorithms. arXiv:1707.06347 [cs], July 2017. URL http://arxiv.org/ abs/1707.06347. arXiv: 1707.06347. ",
+        "bbox": [
+            174,
+            226,
+            825,
+            268
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Joseph P. Simmons, Leif D. Nelson, and Uri Simonsohn. False-Positive Psychology: Undisclosed Flexibility in Data Collection and Analysis Allows Presenting Anything as Significant. Psychological Science, 22(11):1359–1366, November 2011. ISSN 0956-7976, 1467-9280. doi: 10.1177/0956797611417632. URL http://journals.sagepub.com/doi/10.1177/ 0956797611417632. ",
+        "bbox": [
+            173,
+            280,
+            826,
+            351
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, David A McAllester, Satinder P Singh, and Yishay Mansour. Policy Gradient Methods for Reinforcement Learning with Function Approximation. In NIPS’99 Proceedings of the 12th International Conference on Neural Information Processing Systems, pp. 7, 2000. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            405
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aviv Tamar, Yonatan Glassner, and Shie Mannor. Optimizing the CVaR via Sampling. Proceedings of the Twenty-Ninth AAAI Conference on Artificial Intelligence, pp. 7, 2015. ",
+        "bbox": [
+            171,
+            416,
+            823,
+            446
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. MuJoCo: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033, Vilamoura-Algarve, Portugal, October 2012. IEEE. ISBN 978-1-4673-1736-8 978-1-4673-1737-5 978-1-4673-1735-1. doi: 10.1109/IROS.2012.6386109. URL http://ieeexplore.ieee. org/document/6386109/. ",
+        "bbox": [
+            174,
+            458,
+            826,
+            529
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A ASSUMPTIONS AND DEFINITIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            558,
+            490,
+            574
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement Learning algorithms vary widely in design, and our metrics are based on certain notions that should span the gamut of RL algorithms. ",
+        "bbox": [
+            173,
+            590,
+            823,
+            619
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Policy A policy $\\pi _ { \\Theta } ( a _ { i } | s _ { i } )$ is a distribution over actions $a _ { i }$ given a current (input) state $s _ { i }$ . We assume policies are parameterized by a parameter $\\Theta$ .   \nAgent An agent is defined as a distribution over policies (or equivalently a distribution over parameters $\\Theta$ ). In many cases, an agent will be a single policy but for population-based RL methods, the agent is a discrete set of policies.   \nWindow A window is a collection of states over which the agent is assumed to have small variation. A window could be a sequence of consecutive time steps for a sequential RL algorithm, or a collection of states at the same training step of a distributed RL algorithm with a parameter server (all agents share $\\Theta$ ).   \nPerformance The performance of an agent is the mean or median per-epoch reward from running that agent. If the agent is a single policy, then the performance $p ( \\pi _ { \\Theta } )$ is the mean or median per-epoch reward for that agent. If the agent is a distribution $D ( \\Theta )$ of policies, then the performance is the median of $p ( \\pi _ { \\Theta } )$ with $\\Theta \\sim D$ .   \nTraining Run A training run is a sequence of updates to the agent $D ( \\Theta )$ from running a reinforcement learning algorithm. It leads to a trained agent $D _ { f i n a l } ( \\Theta )$ . Multiple training runs share no information with each other. ",
+        "bbox": [
+            173,
+            630,
+            826,
+            881
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We cannot directly measure performance since it is a statistic across an infinite sample of evaluation runs of an agent. Instead we use windows to compute sample medians to approximate performance. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B DETRENDING BY DIFFERENCING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            478,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Typically, de-trending can be performed in two main ways (Nelson & Plosser, 1982; Hamilton, 1994).   \nDifferencing (i.e. $y _ { t } \\prime = y _ { t } - y _ { t - 1 } )$ is more appropriate for difference-stationary (DS) processes (e.g.   \na random walk: $y _ { t } = y _ { t - 1 } + b + \\epsilon _ { t } )$ , where the shocks $\\epsilon _ { t }$ accumulate over time. For trend-stationary (TS) processes, which are characterized by stationary fluctuations around a deterministic trend, e.g.   \n$y _ { t } = a + b * t + \\epsilon _ { t }$ , it is more appropriate to fit and subtract that trend. ",
+        "bbox": [
+            174,
+            133,
+            826,
+            204
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We performed an analysis of real training runs and verified that the data are indeed approximately DS, and that differencing does indeed remove the majority of time-dependent structure. For this analysis we used the training runs on Atari as described in 5.2. Before differencing, the Augmented Dickey-Fuller test (ADF test, also known as a difference-stationarity test; Said E. Said & David A. Dickey (1984)) rejects the null hypothesis of a unit root on only $72 \\%$ of the runs; after differencing, the ADF test rejects the null hypothesis on $92 \\%$ of the runs (p-value threshold 0.05). For the ADF test, the rejection of a unit root (of the autoregressive lag polynomial) implies the alternate hypothesis, which is that the time series is trend-stationary. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            321
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Therefore, our training curves are better characterized as an accumulation of shocks, i.e. as DS processes, rather than as mean-reverting TS processes. They are not actually purely DS because the shocks $\\epsilon _ { t }$ are not stationary over time, but because we compute standard deviation within sliding windows, we can capture the non-stationarity and change in variability over time. Thus, we chose to detrend using differencing. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            398
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As a further note in favor of detrending by differencing, it is useful to observe that many measures of variability are defined relative to the central tendency of the data, e.g. the median absolute deviation $\\mathbf { M A D } = \\mathbf { m e d i a n } ( | X _ { i } - \\widetilde { X } | )$ where $\\widetilde { X }$ is the median of $X$ . On the raw data (without differencing), the MAD would be defined relative to $\\widetilde { X }$ as median performance, so that any improvements in performance are included in that computation of variability. On the other hand, if we compute MAD on the 1st-order differences, we are using a $\\widetilde { X }$ that represents the median change in performance, which is a more reasonable baseline to compute variability against, when we are in fact concerned with the variability of those changes. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            523
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A final benefit of differencing is that it is parameter-free. ",
+        "bbox": [
+            174,
+            531,
+            544,
+            546
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C ILLUSTRATIONS OF PERMUTATION TEST PROCEDURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            565,
+            663,
+            582
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We illustrate the procedure for computing permutation tests to compare pairs of algorithms on a specified metric, in Figs. 3 (for per-run metrics) and 4 (for across-run metrics). ",
+        "bbox": [
+            176,
+            597,
+            825,
+            626
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D RAW TRAINING CURVES FOR OPENAI MUJOCO TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            645,
+            663,
+            662
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5, we show the raw training curves for the TF-Agents implementations of continuouscontrol algorithms, applied to the OpenAI MuJoCo tasks. These are compared against baselines from the literature, where available (DDPG and TD3: Fujimoto et al. (2018), PPO: Schulman et al. (2017), SAC: Haarnoja et al. (2018)) ",
+        "bbox": [
+            174,
+            678,
+            826,
+            733
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E HYPERPARAMETER SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            753,
+            455,
+            770
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the continuous control experiments, hyperparameters were chosen on a per-environment basis according to the black-box optimization algorithm described in Golovin et al. (2017). The hyperparameter search space is shown in Table 2. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            827
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the discrete control experiments, hyperparameter selection is described in (Castro et al., 2018). Hyperparameters are shown in Table 8, duplicated for reference from https://github.com/google/dopamine/tree/master/baselines. ",
+        "bbox": [
+            174,
+            834,
+            825,
+            877
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Comparing algorithms on per-run metrics ",
+        "text_level": 1,
+        "bbox": [
+            334,
+            169,
+            594,
+            181
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Raw values e.g. 3 runs per (task, algo) ",
+        "bbox": [
+            191,
+            190,
+            405,
+            204
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/6ea836b9d65460e10dfeac7faa021a747c2c5a16ccf352e7d11244ce7648a22e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=3 colspan=1>algoAalgoBalgoc</td><td rowspan=1 colspan=1>-1,-7,3</td><td rowspan=1 colspan=1>2.5,7,3</td><td rowspan=1 colspan=1>77,90,4</td></tr><tr><td rowspan=1 colspan=1>-4,2,0</td><td rowspan=1 colspan=1>1.9,0.3,4</td><td rowspan=1 colspan=1>5,32,15</td></tr><tr><td rowspan=1 colspan=1>3,2,4</td><td rowspan=1 colspan=1>6,10,5</td><td rowspan=1 colspan=1>52,64,3</td></tr></table>",
+        "bbox": [
+            200,
+            207,
+            395,
+            275
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "task1 task2 task3 ",
+        "bbox": [
+            254,
+            276,
+            383,
+            286
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Evaluate per-run metrics for each run ",
+        "bbox": [
+            287,
+            295,
+            421,
+            320
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Metric values ",
+        "text_level": 1,
+        "bbox": [
+            196,
+            324,
+            281,
+            335
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed3269eab6188f2e31d92a52dd7ac6c371b0a746169bfb37b1a85a217fa685dd.jpg",
+        "image_caption": [
+            "Figure 3: Diagram illustrating the computation of the permutation tests for per-run metrics (Dispersion across Time, Short-term Risk across Time, Long-term Risk across Time). In this example, we are comparing Algorithm A and Algorithm B, and there are only 3 algorithms, 3 tasks, and 3 runs per (task, algo) pair. To compute the difference in average rankings for two algorithms, follow the gray arrows. To compute a null distribution of difference in average rankings (by permuting the runs), follow the blue arrows a number of times (e.g. 1,000 times). Once the null distribution has been computed, the actual value of the difference can be compared with the null distribution to obtain a p-value. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            330,
+            815,
+            733
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c3f8dfbd4924b0d62b579477d339c12c77e7fa8904b822078909fc4e05deb56.jpg",
+        "image_caption": [
+            "Comparing algorithms on across-run metrics ",
+            "Figure 4: Diagram illustrating the computation of the permutation tests for across-run or acrossrollout metrics (Dispersion across Runs, Risk Across Runs, Dispersion across Fixed-policy rollouts, Risk across Fixed-Policy rollouts). In this example, we are comparing Algorithm A and Algorithm B, and there are only 3 algorithms, 3 tasks, and 3 runs per (task, algo) pair. To compute the difference in average rankings for two algorithms, follow the gray arrows. To compute a null distribution of difference in average rankings (by permuting the runs), follow the blue arrows a number of times (e.g. 1,000 times). Once the null distribution has been computed, the actual value of the difference can be compared with the null distribution to obtain a p-value. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            167,
+            787,
+            742
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/e662db76af853665422b459608b40a07e165e5e3654a2f6ed6d7dd410136c4b9.jpg",
+        "image_caption": [
+            "Figure 5: Raw training curves for OpenAI MuJoCo tasks. The $\\mathbf { X }$ -axes indicate environment steps, and the y-axes indicate average per-episode return. Dotted lines indicate baseline performance from the literature, where available. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            247,
+            810,
+            719
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/32f24ed94c694333639a770e0705ac1ef38e05d24845688dce6ddaa4df6caf4b.jpg",
+        "table_caption": [
+            "Table 2: Hyperparameter search space for continuous control algorithms. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Search min</td><td rowspan=1 colspan=1>Search max</td></tr><tr><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>actor learning rateα learning ratecritic learning rate target update T</td><td rowspan=1 colspan=1>0.0000010.0000010.0000010.00001</td><td rowspan=1 colspan=1>0.0010.0010.0011.0</td></tr><tr><td rowspan=1 colspan=1>TD3</td><td rowspan=1 colspan=1>actor learning ratecritic learning ratetarget update T</td><td rowspan=1 colspan=1>0.0000010.0000010.00001</td><td rowspan=1 colspan=1>0.0010.0011.0</td></tr><tr><td rowspan=1 colspan=1>PPO</td><td rowspan=1 colspan=1>learning rate</td><td rowspan=1 colspan=1>0.000001</td><td rowspan=1 colspan=1>0.001</td></tr><tr><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1>actor learning ratecritic learning ratetarget update T</td><td rowspan=1 colspan=1>0.0000010.0000010.00001</td><td rowspan=1 colspan=1>0.0010.0011.0</td></tr><tr><td rowspan=1 colspan=1>REINFORCE</td><td rowspan=1 colspan=1>learning rate# episodes before each train step</td><td rowspan=1 colspan=1>0.0000011.0</td><td rowspan=1 colspan=1>0.00110</td></tr></table>",
+        "bbox": [
+            225,
+            136,
+            772,
+            383
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/c50d53b9d199a43e6b88369ef09948bda0db117d56567772cbeec0ad4153e0e7.jpg",
+        "table_caption": [
+            "Table 3: Final hyperparameters for SAC. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>actor learning rate</td><td rowspan=1 colspan=1>α learning rate</td><td rowspan=1 colspan=1>critic learning rate</td><td rowspan=1 colspan=1>target update T</td></tr><tr><td rowspan=1 colspan=1>Ant-v2</td><td rowspan=1 colspan=1>0.000006</td><td rowspan=1 colspan=1>0.000009</td><td rowspan=1 colspan=1>0.0009</td><td rowspan=4 colspan=1>0.00020.020.80.00002</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-v2</td><td rowspan=1 colspan=1>0.0001</td><td rowspan=1 colspan=1>0.000005</td><td rowspan=1 colspan=1>0.0004</td></tr><tr><td rowspan=1 colspan=1>Humanoid-v2</td><td rowspan=1 colspan=1>0.0003</td><td rowspan=1 colspan=1>0.0008</td><td rowspan=1 colspan=1>0.0006</td></tr><tr><td rowspan=1 colspan=1>Reacher-v2</td><td rowspan=1 colspan=1>0.00001</td><td rowspan=1 colspan=1>0.000002</td><td rowspan=1 colspan=1>0.0005</td></tr><tr><td rowspan=1 colspan=1>Swimmer-v2</td><td rowspan=1 colspan=1>0.000004</td><td rowspan=1 colspan=1>0.000009</td><td rowspan=1 colspan=1>0.0002</td><td rowspan=2 colspan=1>0.0090.01</td></tr><tr><td rowspan=1 colspan=1>Walker2d-v2</td><td rowspan=1 colspan=1>0.0002</td><td rowspan=1 colspan=1>0.0009</td><td rowspan=1 colspan=1>0.0008</td></tr></table>",
+        "bbox": [
+            179,
+            435,
+            818,
+            560
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/6ef52fca750030eac55114214b7316d7ec9635389dcf32d851cf242bf3ecb7c5.jpg",
+        "table_caption": [
+            "Table 4: Final hyperparameters for TD3. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>actor learning rate</td><td>critic learning rate</td><td>target update T</td></tr><tr><td>Ant-v2</td><td>0.000001</td><td>0.0002</td><td>0.0003</td></tr><tr><td>HalfCheetah-v2</td><td>0.0003</td><td>0.0005</td><td>0.02</td></tr><tr><td>Humanoid-v2</td><td>0.0001</td><td>0.0001</td><td>0.0002</td></tr><tr><td>Reacher-v2</td><td>0.000001</td><td>0.00003</td><td>0.00003</td></tr><tr><td>Swimmer-v2</td><td>0.0004</td><td>0.0002</td><td>0.01</td></tr><tr><td>Walker2d-v2</td><td>0.00006</td><td>0.00009</td><td>0.001</td></tr></table>",
+        "bbox": [
+            236,
+            611,
+            759,
+            737
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/862206ba07d19d692146a14ca61fedad5708dc451ff3b4a82a1ccd3e7974204b.jpg",
+        "table_caption": [
+            "Table 5: Final hyperparameters for PPO. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>learning rate</td></tr><tr><td>Ant-v2</td><td>0.0008</td></tr><tr><td>HalfCheetah-v2</td><td>0.0008</td></tr><tr><td>Humanoid-v2</td><td>0.0008</td></tr><tr><td>Reacher-v2</td><td>0.00002</td></tr><tr><td>Swimmer-v2</td><td>0.0004</td></tr><tr><td>Walker2d-v2</td><td>0.0002</td></tr></table>",
+        "bbox": [
+            383,
+            787,
+            612,
+            912
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/94c4307a2f0f1077b3f5afbce036b8548eb451f5812c05e2a66628f6e28d9443.jpg",
+        "table_caption": [
+            "Table 6: Final hyperparameters for DDPG. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>actor learning rate</td><td rowspan=1 colspan=1>critic learning rate</td><td rowspan=1 colspan=1>target update T</td></tr><tr><td rowspan=1 colspan=2>Ant-v2</td><td rowspan=1 colspan=1>0.00003</td><td rowspan=1 colspan=1>0.0004</td><td rowspan=3 colspan=1>0.00020.020.01</td></tr><tr><td rowspan=5 colspan=2>HalfCheetah-v2Humanoid-v2Reacher-v2Swimmer-v2Walker2d-v2</td><td rowspan=1 colspan=1>0.00006</td><td rowspan=1 colspan=1>0.0005</td></tr><tr><td rowspan=2 colspan=1>0.000060.00005</td><td rowspan=1 colspan=1>0.00009</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>0.0005</td><td rowspan=1 colspan=1>0.005</td></tr><tr><td rowspan=1 colspan=1>Swimmer-v2</td><td rowspan=1 colspan=1>0.0005</td><td rowspan=1 colspan=1>0.0003</td><td rowspan=2 colspan=1>0.0040.03</td></tr><tr><td rowspan=1 colspan=1>0.0003</td><td rowspan=1 colspan=1>0.0004</td></tr></table>",
+        "bbox": [
+            236,
+            133,
+            759,
+            258
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "table",
+        "img_path": "images/d63d87cc9e18af7095992e0de999b3c7fd21c95b598622b7ebd8c79ee65b27ec.jpg",
+        "table_caption": [
+            "Table 7: Final hyperparameters for REINFORCE. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>learning rate</td><td># episodes before each train step</td></tr><tr><td>Ant-v2</td><td>0.00002</td><td>9</td></tr><tr><td>HalfCheetah-v2</td><td>0.0004</td><td>7</td></tr><tr><td>Humanoid-v2</td><td>0.0005</td><td>2</td></tr><tr><td>Reacher-v2</td><td>0.000004</td><td>6</td></tr><tr><td>Swimmer-v2</td><td>0.000005</td><td>3</td></tr><tr><td>Walker2d-v2</td><td>0.0001</td><td>6</td></tr></table>",
+        "bbox": [
+            318,
+            318,
+            681,
+            460
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "table",
+        "img_path": "images/215b4fb9082040e6d7604a44431fdd3edb6bd62a42663cf865f70023201a7a5c.jpg",
+        "table_caption": [
+            "Table 8: Hyperparameters for discrete control algorithms. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Training ∈</td><td rowspan=1 colspan=1>Evaluation ∈</td><td rowspan=1 colspan=1>∈ decay schedule</td><td rowspan=1 colspan=1>Min. history to start learning</td><td rowspan=1 colspan=1>Target network update frequency</td></tr><tr><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>1,000,000 frames</td><td rowspan=1 colspan=1>80,000 frames</td><td rowspan=1 colspan=1>32,000 frames</td></tr></table>",
+        "bbox": [
+            209,
+            520,
+            789,
+            575
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "F PER-TASK METRIC RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            439,
+            699
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Metric results are shown on a per-task basis in Figs. 6 to 8 for the OpenAI Gym MuJoCo tasks, and Figs. 9 to 23 for the Atari environments. Note that because we are no longer aggregating across tasks in this analysis, we do not need to convert the metric values to rankings. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            757
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/cec1c2995b0125b3db4f8df11a4260096c8a000b0b3d95b44278ab1b9e5a0d6f.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            122,
+            799,
+            338
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb3bb96377fa9630024aa345d04c53765bfdfe2cb4eda6f7dd7e5356d693d3aa.jpg",
+        "image_caption": [
+            "(a) Dispersion across Time. Better reliability is indicated by less positive values. The x-axes indicate the number of environment steps. ",
+            "Figure 6: Across-time reliability metrics for continuous control RL algorithms tested on OpenAI Gym environments, evaluated on a per-environment basis. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            372,
+            808,
+            859
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/176a0dc0ee915ad20c06b815fb91fe0bab25cfb83b45b0fe5cc642cefe3955f5.jpg",
+        "image_caption": [
+            "(c) Median performance during training. Better performance is indicated by more positive values. ",
+            "Figure 7: Across-run reliability metrics and median performance for continuous control RL algorithms tested on OpenAI Gym environments, evaluated on a per-environment basis. The $\\mathbf { X }$ -axes indicate the number of environment steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            69,
+            803,
+            823
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/c40b95c7c205c5fa8f147f115ced50722e925bc3c1fd7d76aa073d1f78f7df76.jpg",
+        "image_caption": [
+            "(c) Median performance on Fixed-policy rollouts. Better performance is indicated by more positive values. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            73,
+            807,
+            845
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Figure 8: Reliability metrics and median performance on fixed-policy rollouts for continuous control RL algorithms tested on OpenAI Gym environments, evaluated on a per-environment basis. ",
+        "bbox": [
+            174,
+            864,
+            823,
+            895
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/aecca9879d7a6eaeb66ab7aa37b8318cd8e92c32be8e7f68a12c2b7d1e6c00a6.jpg",
+        "image_caption": [
+            "Figure 9: Dispersion across Time for DQN-variants tested on 60 Atari games, evaluated on a perenvironment basis (page 1). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            125,
+            812,
+            842
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/822d810b075264d2abade575dd47ea5f30457fd848733f1d4b4451a50f5ce8ad.jpg",
+        "image_caption": [
+            "Figure 10: Dispersion across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            122,
+            812,
+            844
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/1f628d73d292181bde29ff809254d6e8e95df2e47c007b1318b6344eb3e43d30.jpg",
+        "image_caption": [
+            "Figure 11: Dispersion across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            308,
+            818,
+            662
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "image",
+        "img_path": "images/2f88232d4df466e1c963b90d94c96ff0f02b9b2e41799e72dcac78a7a7285712.jpg",
+        "image_caption": [
+            "Figure 12: Short-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 1). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            122,
+            816,
+            844
+        ],
+        "page_idx": 24
+    },
+    {
+        "type": "image",
+        "img_path": "images/6354ac16a00c441f4c100baa19bb1b82659cbab0f2c53e861f2ffd30202d7768.jpg",
+        "image_caption": [
+            "Figure 13: Short-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by less positive values. The x-axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            122,
+            810,
+            849
+        ],
+        "page_idx": 25
+    },
+    {
+        "type": "image",
+        "img_path": "images/5eb59c4fe59ae9b38d5cd99e70adf1cb02b43e32d5a5e79990f7e628d54ae522.jpg",
+        "image_caption": [
+            "Figure 14: Short-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            303,
+            813,
+            665
+        ],
+        "page_idx": 26
+    },
+    {
+        "type": "image",
+        "img_path": "images/d257c73a7b2407b4d0eca08dce88d44ddb4e831dcea84141a1274f7b59d56a3a.jpg",
+        "image_caption": [
+            "Figure 15: Long-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 1). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            123,
+            808,
+            844
+        ],
+        "page_idx": 27
+    },
+    {
+        "type": "image",
+        "img_path": "images/412394c5e0322f1262d4d6db43375b80ab6e47074095e1c73e13b84fda1d07ff.jpg",
+        "image_caption": [
+            "Figure 16: Long-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            116,
+            810,
+            849
+        ],
+        "page_idx": 28
+    },
+    {
+        "type": "image",
+        "img_path": "images/44621f204f2db53c785fee2331ad5872eecdeca5e8bf9a8a22ab2a0e5b99fdc5.jpg",
+        "image_caption": [
+            "Figure 17: Long-term Risk across Time for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            303,
+            812,
+            665
+        ],
+        "page_idx": 29
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7285425bea4ff7598ae9aa4c469ba5dbac3d5bdd86205c7b3b3bb44803dfcb4.jpg",
+        "image_caption": [
+            "Figure 18: Dispersion across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 1). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            123,
+            807,
+            848
+        ],
+        "page_idx": 30
+    },
+    {
+        "type": "image",
+        "img_path": "images/a3e1dc133f7c697d388b698368423059823c7edf8a45302a893cb1b9442a93c0.jpg",
+        "image_caption": [
+            "Figure 19: Dispersion across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            104,
+            813,
+            853
+        ],
+        "page_idx": 31
+    },
+    {
+        "type": "image",
+        "img_path": "images/5c46d632e8a936307828e2173f3cd2a21a3f456f7a995f9309167561e62ca3dd.jpg",
+        "image_caption": [
+            "Figure 20: Dispersion across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by less positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            300,
+            820,
+            670
+        ],
+        "page_idx": 32
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ec713a7e3857947eb886dda91a755fcf04bbb19f257dcbd0fe0006eb86e994f.jpg",
+        "image_caption": [
+            "Figure 21: Risk across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 1). Better reliability is indicated by more positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            138,
+            808,
+            842
+        ],
+        "page_idx": 33
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f9797ed72410b53b95f2527f66c4b43207fee4b1c4a188e5e076fe304274334.jpg",
+        "image_caption": [
+            "Figure 22: Risk across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 2). Better reliability is indicated by more positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            111,
+            810,
+            845
+        ],
+        "page_idx": 34
+    },
+    {
+        "type": "image",
+        "img_path": "images/98295ad14c1dcd95ebc855f8b7b1383bc4d44bd032bd9359f801674f9cb32ed1.jpg",
+        "image_caption": [
+            "Figure 23: Risk across Fixed-policy Rollouts for DQN-variants tested on 60 Atari games, evaluated on a per-environment basis (page 3). Better reliability is indicated by more positive values. The $\\mathbf { X }$ -axes indicate millions of Atari frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            306,
+            810,
+            664
+        ],
+        "page_idx": 35
+    }
+]

parse/train/SkE6PjC9KX/SkE6PjC9KX.md

@@ -0,0 +1,298 @@
+# ATTENTIVE NEURAL PROCESSES
+
+Hyunjik $\mathbf { K i m ^ { 1 , 2 * } }$ , Andriy ${ \bf { M } } { \bf { n i h } } ^ { 1 }$ , Jonathan Schwarz1, Marta Garnelo1, Ali Eslami1,   
+Dan Rosenbaum1, Oriol Vinyals1, Yee Whye Teh1,2   
+DeepMind1, University of Oxford2
+
+# ABSTRACT
+
+Neural Processes (NPs) (Garnelo et al., 2018a;b) approach regression by learning to map a context set of observed input-output pairs to a distribution over regression functions. Each function models the distribution of the output given an input, conditioned on the context. NPs have the benefit of fitting observed data efficiently with linear complexity in the number of context input-output pairs, and can learn a wide family of conditional distributions; they learn predictive distributions conditioned on context sets of arbitrary size. Nonetheless, we show that NPs suffer a fundamental drawback of underfitting, giving inaccurate predictions at the inputs of the observed data they condition on. We address this issue by incorporating attention into NPs, allowing each input location to attend to the relevant context points for the prediction. We show that this greatly improves the accuracy of predictions, results in noticeably faster training, and expands the range of functions that can be modelled.
+
+# 1 INTRODUCTION
+
+Regression tasks are usually cast as modelling the distribution of a vector-valued output $\textbf {  { y } }$ given a vector-valued input $_ { \textbf { \em x } }$ via a deterministic function, such as a neural network, taking $_ { \textbf { \em x } }$ as an input. In this setting, the model is trained on a dataset of input-output pairs, and predictions of the outputs are independent of each other given the inputs. An alternative approach to regression involves using the training data to compute a distribution over functions that map inputs to outputs, and using draws from that distribution to make predictions on test inputs. This approach allows for reasoning about multiple functions consistent with the data, and can capture the co-variability in outputs given inputs. In the Bayesian machine learning literature, non-parametric models such as Gaussian Processes (GPs) are popular choices of this approach.
+
+Neural Processes (NPs) (Garnelo et al., 2018a;b) offer an efficient method to modelling a distribution over regression functions, with prediction complexity linear in the context set size. Once trained, they can predict the distribution of an arbitrary target output conditioned on a set of context inputoutput pairs of an arbitrary size. This flexibility of NPs enables them to model data that can be interpreted as being generated from a stochastic process. It is important to note however that NPs and GPs have different training regimes. NPs are trained on samples from multiple realisations of a stochastic process (i.e. trained on many different functions), whereas GPs are usually trained on observations from one realisation of the stochastic process (a single function). Hence a direct comparison between the two is usually not plausible.
+
+Despite their many appealing properties, one substantial weakness of NPs is that they tend to underfit the context set. This manifests in the 1D curve fitting example on the left half of Figure 1 as inaccurate predictive means and overestimated variances at the input locations of the context set. The right half of the figure shows this phenomenon when predicting the bottom half of a face image from its top half: although the prediction is globally coherent, the model’s reconstruction of the top-half is far from perfect. In an NP, the encoder aggregates the context set to a fixed-length latent summary via a permutation invariant function, and the decoder maps the latent and target input to the target output. We hypothesise that the underfitting behaviour is because the mean-aggregation step in the encoder acts as a bottleneck: since taking the mean across context representations gives the same weight to each context point, it is difficult for the decoder to learn which context points provide relevant information for a given target prediction. In theory, increasing the dimensionality of the representation could address this issue, but we show in Section 4 that in practice, this is not sufficient.
+
+![](images/ba54f692bcc35600ad5cde87d8bae38ca586a2197e4f891cbf69108e1052b875.jpg)  
+Figure 1: Comparison of predictions given by a fully trained NP and Attentive NP (ANP) in 1D function regression (left) / 2D image regression (right). The contexts (crosses/top half pixels) are used to predict the target outputs $y$ -values of all $x \in [ - 2 , 2 ] / \mathrm { a l l }$ pixels in image). The ANP predictions are noticeably more accurate than for NP at the context points.
+
+To address this issue, we draw inspiration from GPs, which also define a family of conditional distributions for regression. In GPs, the kernel can be interpreted as a measure of similarity among two points in the input domain, and shows which context points $( { \pmb x } _ { i } , { \pmb y } _ { i } )$ are relevant for a given query $^ { \mathbf { \delta x } }$ . Hence when $^ { \mathbf { \delta x } }$ is close to some $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ , its $y$ -value prediction $^ { \pmb { y } _ { \ast } }$ is necessarily close to $\mathbf { \nabla } _ { \mathbf { \boldsymbol { y } } _ { i } }$ (assuming small likelihood noise), and there is no risk of underfitting. We implement a similar mechanism in NPs using differentiable attention that learns to attend to the contexts relevant to the given target, while preserving the permutation invariance in the contexts. We evaluate the resulting Attentive Neural Processes (ANPs) on 1D function regression and on 2D image regression. Our results show that ANPs greatly improve upon NPs in terms of reconstruction of contexts as well as speed of training, both against iterations and wall clock time. We also demonstrate that ANPs show enhanced expressiveness relative to the NP and is able to model a wider range of functions.
+
+# 2 BACKGROUND
+
+# 2.1 NEURAL PROCESSES
+
+The NP is a model for regression functions that map an input $\pmb { x } _ { i } \in \mathbb { R } ^ { d _ { x } }$ to an output $\boldsymbol { y } _ { i } \in \mathbb { R } ^ { d _ { y } }$ . In particular, the NP defines a (infinite) family of conditional distributions, where one may condition on an arbitrary number of observed contexts $( \pmb { x } _ { C } , \pmb { y } _ { C } ) : = ( \pmb { x } _ { i } , \pmb { y } _ { i } ) _ { i \in C }$ to model an arbitrary number of targets $( { \pmb x } _ { T } , { \pmb y } _ { T } ) : = ( { \pmb x } _ { i } , { \pmb y } _ { i } ) _ { i \in T }$ in a way that is invariant to ordering of the contexts and ordering of the targets. The model is defined for arbitrary $C$ and $T$ but in practice we use $C \subset T$ . The deterministic NP models these conditional distributions as:
+
+$$
+p ( { \pmb y } _ { T } | { \pmb x } _ { T } , { \pmb x } _ { C } , { \pmb y } _ { C } ) : = p ( { \pmb y } _ { T } | { \pmb x } _ { T } , { \pmb r } _ { C } )
+$$
+
+with $r _ { C } : = r ( \pmb { x } _ { C } , \pmb { y } _ { C } ) \in \mathbb { R } ^ { d }$ where $r$ is a deterministic function that aggregates $( \pmb { x } _ { C } , \pmb { y } _ { C } )$ into a finite dimensional representation with permutation invariance in $C$ . In practice, each context $( { \pmb x } , { \pmb y } )$ pair is passed through an MLP to form a representation of each pair, and these are aggregated by taking the mean to form $r _ { C }$ . The likelihood $p ( { \pmb y } _ { T } | { \pmb x } _ { T } , { \pmb r } _ { C } )$ is modelled by a Gaussian factorised across the targets $( { \pmb x } _ { i } , { \pmb y } _ { i } ) _ { i \in T }$ with mean and variance given by passing $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ and $\mathbf { \Delta } _ { \mathbf { \left. r _ { C } \right. } }$ through an MLP. The unconditional distribution $p ( { \pmb y } _ { T } | { \pmb x } _ { T } )$ (when $C = \varnothing$ ) is defined by letting $r _ { \emptyset }$ be a fixed vector.
+
+The latent variable version of the NP model includes a global latent $_ z$ to account for uncertainty in the predictions of $\mathbf { \pmb { y } } _ { T }$ for a given observed $( \pmb { x } _ { C } , \pmb { y } _ { C } )$ . It is incorporated into the model via a latent path that complements the deterministic path described above. Here $_ { z }$ is modelled by a factorised Gaussian parametrised by $\pmb { s } _ { C } : = \pmb { s } ( \pmb { x } _ { C } , \pmb { y } _ { C } )$ , with $s$ being a function of the same properties as $r$
+
+$$
+p ( \pmb { y } _ { T } | \pmb { x } _ { T } , \pmb { x } _ { C } , \pmb { y } _ { C } ) : = \int p ( \pmb { y } _ { T } | \pmb { x } _ { T } , \pmb { r } _ { C } , z ) q ( z | \pmb { s } _ { C } ) d z
+$$
+
+with $q ( z | s _ { \emptyset } ) : = p ( z )$ , the prior on $_ z$ . The likelihood is referred to as the decoder, and $q , r , s$ form the encoder. See Figure 2 for diagrams of these models.
+
+The motivation for having a global latent is to model different realisations of the data generating stochastic process — each sample of $_ z$ would correspond to one realisation of the stochastic process. One can define the model using either just the deterministic path, just the latent path, or both. In this
+
+work we investigate the case of using both paths, which gives the most expressive model and also gives a sensible setup for incorporating attention, as we will show later in Section 3.
+
+The parameters of the encoder and decoder are learned by maximising the following ELBO
+
+$$
+\log p ( y _ { T } | x _ { T } , x _ { C } , y _ { C } ) \geq \mathbb { E } _ { q ( z | s _ { T } ) } [ \log p ( y _ { T } | x _ { T } , r _ { C } , z ) ] - D _ { \mathrm { K L } } ( q ( z | s _ { T } ) | | q ( z | s _ { C } ) )
+$$
+
+for a random subset of contexts $C$ and targets $T$ via the reparametrisation trick (Kingma & Welling, 2014; Rezende et al., 2014). In other words, the NP learns to reconstruct targets, regularised by a KL term that encourages the summary of the contexts to be not too far from the summary of the targets. This is sensible since we are assuming that the contexts and targets come from the same realisation of the data-generating stochastic process, and especially so if targets contain contexts. At each training iteration, the number of contexts and targets are also chosen randomly (as well as being randomly sampled from the training data), so that the NP can learn a wide family of conditional distributions.
+
+NPs have many desirable properties, namely (i) Scalability: computation scales linearly at $O ( n { + } m )$ for $n$ contexts and $m$ targets at train and prediction time. (ii) Flexibility: defines a very wide family of distributions, where one can condition on an arbitrary number of contexts to predict an arbitrary number of targets. (iii) Permutation invariance: the predictions of the targets are order invariant in the contexts. However these advantages come at the cost of not satisfying consistency in the contexts. For example, if $\mathbf { \boldsymbol { \mathsf { y } } } _ { 1 : m }$ is generated given some context set, then its distribution need not match the distribution you would obtain if $\pmb { y } _ { 1 : n }$ is generated first, appended to the context set then ${ \pmb y } _ { n + 1 : m }$ is generated. However maximum-likelihood learning can be interpreted as minimising the KL between the (consistent) conditional distributions of the data-generating stochastic process and the corresponding conditional distributions of the NP. Hence we could view the NP as approximating the conditionals of the consistent data-generating stochastic process.
+
+# 2.2 ATTENTION
+
+Given a set of key-value pairs $( k _ { i } , v _ { i } ) _ { i \in \mathbb { Z } }$ and a query $q$ , an attention mechanism computes weights of each key with respect to the query, and aggregates the values with these weights to form the value corresponding to the query. In other words, the query attends to the key-value pairs. The queried values are invariant to the ordering of the key-value pairs; this permutation invariance property of attention is key in its application to NPs. The idea of using a differentiable addressing mechanism that can be learned from the data has been applied successfully in various areas of Deep Learning, namely handwriting generation and recognition (Graves, 2012) and neural machine translation (Bahdanau et al., 2015). More recently, there has been work employing self-attention (where keys and queries are identical) to give expressive sequence-to-sequence mappings in natural language processing (Vaswani et al., 2017) and image modelling (Parmar et al., 2018).
+
+We give some examples of attention mechanisms which are used in the paper. Suppose we have $n$ key-value pairs arranged as matrices $K \in \mathbb { R } ^ { n \times d _ { k } }$ , $V \in \mathbb { R } ^ { n \times d _ { v } }$ , and $m$ queries $Q \in \mathbb { R } ^ { m \times d _ { k } }$ . Simple forms of attention based on locality (weighting keys according to distance from query) are given by various stationary kernels. For example, the (normalised) Laplace kernel gives the queried values as
+
+$$
+\mathbf { L a p l a c e } ( Q , K , V ) : = W V \in \mathbb { R } ^ { m \times d _ { v } } , \qquad W _ { i } : = \mathrm { s o f t m a x } ( ( - | | Q _ { i } , - K _ { j } . | | _ { 1 } ) _ { j = 1 } ^ { n } ) \in \mathbb { R } ^ { n }
+$$
+
+Similarly (scaled) dot-product attention uses the dot-product between the query and keys as a measure of similarity, and weights the keys according to the values
+
+$$
+\mathbf { D o t P r o d u c t } ( Q , K , V ) : = \operatorname { s o f t m a x } ( Q K ^ { \top } / \sqrt { d _ { k } } ) V \in \mathbb { R } ^ { m \times d _ { v } }
+$$
+
+The use of dot-product attention allows the query values to be computed with two matrix multiplications and a softmax, allowing for use of highly optimised matrix multiplication code.
+
+multihead attention (Vaswani et al., 2017) is a parametrised extension where for each head, the keys, values and queries are linearly transformed, then dot-product attention is applied to give headspecific values. These values are concatenated and linearly transformed to produce the final values:
+
+$$
+\begin{array} { r l } & { \mathbf { M u l t i H e a d } ( Q , K , V ) : = \mathrm { c o n c a t } ( \mathrm { h e a d } _ { 1 } , \dots , \mathrm { h e a d } _ { H } ) W \in \mathbb { R } ^ { m \times d _ { v } } } \\ & { \qquad \mathrm { w h e r e ~ h e a d } _ { h } : = \mathrm { D o t P r o d u c t } ( Q W _ { h } ^ { Q } , K W _ { h } ^ { K } , V W _ { h } ^ { V } ) \in \mathbb { R } ^ { m \times d _ { v } } } \end{array}
+$$
+
+This multihead architecture allows the query to attend to different keys for each head and tends to give smoother query-values than dot-product attention (c.f. Section 4).
+
+# 3 ATTENTIVE NEURAL PROCESSES
+
+![](images/be70b3d915e9d80198e52c93260a723933b03c9d3d58fc0220b12c7fcb48d6cf.jpg)  
+Figure 2: Model architecture for the NP (left) and Attentive NP (right)
+
+Figure 2 describes how attention is incorporated into NP to give the Attentive NP (ANP). In summary, self-attention is applied to the context points to compute representations of each $( { \pmb x } , { \pmb y } )$ pair, and the target input attends to these context representations (cross-attention) to predict the target output. In detail, the representation of each context pair $( { \pmb x } _ { i } , { \pmb y } _ { i } ) _ { i \in C }$ before the mean-aggregation step is computed by a self-attention mechanism, in both the deterministic and latent path. The intuition for the self-attention is to model interactions between the context points. For example, if many context points overlap, then the query need not attend to all of these points, but only give high weight to one or a few. The self-attention will help obtain richer representations of the context points that encode these types of relations between the context points. We model higher order interactions by simply stacking the self-attention, as is done in Vaswani et al. (2017).
+
+In the deterministic path, the mean-aggregation of the context representations that produces $\mathbf { \Delta } _ { \mathbf { \left. r _ { C } \right. } }$ is replaced by a cross-attention mechanism, where each target query $^ { \mathbf { x } } { } ^ { \mathrm { ~ } }$ attends to the context $\scriptstyle { \mathbf { { \mathit { x } } } } _ { C } : =$ $( { \bar { \pmb { x } } } _ { i } ) _ { i \in C }$ to produce a query-specific representation $\pmb { r } _ { * } : = r ^ { * } ( \pmb { x } _ { C } , \pmb { y } _ { C } , \pmb { x } _ { * } )$ . This is precisely where the model allows each query to attend more closely to the context points that it deems relevant for the prediction. The reason we do not have an analogous mechanism in the latent path is that we would like to preserve the global latent, that induces dependencies between the target predictions. The interpretation of the latent path is that $_ z$ gives rise to correlations in the marginal distribution of the target predictions $\mathbf { \pmb { y } } _ { T }$ , modelling the global structure of the stochastic process realisation, whereas the deterministic path models the fine-grained local structure.
+
+The decoder remains the same, except we replace the shared context representation $\mathbf { \Delta } _ { \mathbf { \left. r _ { C } \right. } }$ with the query-specific representation $\mathbf { \Delta } _ { \mathbf { r } _ { * } }$ . Note that permutation invariance in the contexts is preserved with the attention mechanism. If we use uniform attention (all contexts given the same weight) throughout, we recover the NP. ANP is trained using the same loss (3) as the original NP, also using Gaussian likelihood $p ( \pmb { y } _ { i } | \pmb { x } _ { i } , r ^ { * } ( \pmb { x } _ { C } , \pmb { y } _ { C } , \pmb { x } _ { i } ) , z )$ and diagonal Gaussian $q ( \boldsymbol { z } | \boldsymbol { s } _ { C } )$ .
+
+The added expressivity and resulting accuracy of the NP with attention comes at a cost. The computational complexity is raised from $\bar { O } ( n + m ) $ to $O ( n ( n + m ) )$ , since we apply self-attention across the contexts and for every target point we compute weights for all contexts. However most of the computation for the (self-)attention is done via matrix multiplication (c.f. Section 2.2), and so can be done in parallel across the contexts and across the targets. In practice, the training time for ANPs remains comparable to NPs, and in fact we show that ANPs learn significantly faster than NPs not only in terms of training iterations but also in wall-clock time, despite being slower at prediction time (c.f. Section 4).
+
+# 4 EXPERIMENTAL RESULTS
+
+Note that the (A)NP learns a stochastic process, so should be trained on multiple functions that are realisations of the stochastic process. At each training iteration, we draw a batch of realisations from the data generating stochastic process, and select random points on these realisations to be the targets and a subset to be the contexts to optimise the loss in Equation (3). We use the same decoder architecture for all experiments, and 8 heads for multihead. See Appendix A for architectural details.
+
+![](images/8805bccfaf2156eb10fc3567a04022b03d867dfe5ee24067f4304d47926b47fb.jpg)  
+Figure 3: Qualitative and quantitative results of different attention mechanisms for 1D GP function regression with random kernel hyperparameters. Left: moving average of context reconstruction error (top) and target negative log likelihood (NLL) given contexts (bottom) plotted against training iterations (left) and wall clock time (right). $d$ denotes the bottleneck size i.e. hidden layer size of all MLPs and the dimensionality of $r$ and $z$ . Right: predictive mean and variance of different attention mechanisms given the same context. Best viewed in colour.
+
+1D Function regression on synthetic GP data We first explore the (A)NPs trained on data that is generated from a Gaussian Process with a squared-exponential kernel and small likelihood noise1. We emphasise that (A)NPs need not be trained on GP data or data generated from a known stochastic process, and this is just an illustrative example. We explore two settings: one where the hyperparameters of the kernel are fixed throughout training, and another where they vary randomly at each training iteration. The number of contexts $( n )$ and number of targets $( m )$ are chosen randomly at each iteration $( n \sim U [ 3 , 1 0 0 ]$ , $m \sim n + U [ 0 , 1 0 0 - n ] )$ . Each $x$ -value is drawn uniformly at random in $[ - 2 , 2 ]$ . For this simple 1D data, we do not use self-attention and just explore the use of cross-attention in the deterministic path (c.f. Figure 2). Thus we use the same encoder/decoder architecture for NP and ANP, except for the cross-attention. See Appendix B for experimental details.
+
+Figure 3 (left) shows context reconstruction error $\begin{array} { r } { \frac { 1 } { | C | } \sum _ { i \in C } \mathbb { E } _ { q ( z | s _ { C } ) } [ \log p ( \pmb { y } _ { i } | \pmb { x } _ { i } , r ^ { * } ( \pmb { x } _ { C } , \pmb { y } _ { C } , \pmb { x } _ { i } ) , z ) ] } \end{array}$ and NLL of targets given contexts $\begin{array} { r } { \frac { 1 } { | T | } \sum _ { i \in T } \mathbb { E } _ { q ( z | s _ { C } ) } [ \log p ( \pmb { y } _ { i } | \pmb { x } _ { i } , r ^ { * } ( \pmb { x } _ { C } , \pmb { y } _ { C } , \pmb { x } _ { i } ) , z ) ] } \end{array}$ for the different attention mechanisms, trained on a GP with random kernel hyperparameters. ANP shows a much more rapid decrease in reconstruction error and lower values at convergence compared to the NP, especially for dot product and multihead attention. This holds not only against training iteration but also against wall clock time, so learning is fast despite the added computational cost of attention. The right column plots show that the computation times of Laplace and dot-product ANP are similar to the NP for the same value of $d$ , and multihead ANP takes around twice the time. We also show how the size of the bottleneck $( d )$ in the deterministic and latent paths of the NP affects the underfitting behaviour of NPs. The figure shows that raising $d$ does help achieve better reconstructions, but there appears to be a limit in how much reconstructions can improve. Beyond a certain value of $d$ , the learning for the NP becomes too slow, and the value of reconstruction error at convergence is still higher than that achieved by multihead ANP with $10 \%$ of the wall-clock time. Hence using ANPs has significant benefits over simply raising the bottleneck size in NPs.
+
+In Figure 3 (right) we visualise the learned conditional distribution for a qualitative comparison of the attention mechanisms. The context is drawn from the GP with the hyperparameter values that give the most fluctuation. Note that the predictive mean of the NP underfits the context, and tries to explain the data by learning a large likelihood noise. Laplace shows similar behaviour, whereas dotproduct attention gives predictive means that accurately predict almost all context points. Note that Laplace attention is parameter-free (keys and queries are the x-coordinates) whereas for dot-product attention we have set the keys and queries to be parameterised representations of the x-values (output of learned MLP that takes $\mathbf { X } ^ { \prime }$ -coordinates as inputs). So the dot-product similarities are computed in a learned representation space, whereas for Laplace attention the similarities are computed based on L1 distance in the $\mathbf { X }$ -coordinate domain, hence it is expected that dot-product attention outperforms Laplace attention. However dot-product attention displays non-smooth predictions, shown more (a) Reconstructions of full CelebA image from a varying number of random context points for NP (left) and Stacked Multihead ANP (right).
+
+![](images/9aae810eb2780d7beb0bdfb1b682c13682a2b3ac1fdd73d66b794ca0d962c69e.jpg)
+
+![](images/d0c19bab9627523cd98792461e1b139dcfed710249f95b8d040dad5392fe199b.jpg)  
+(b) Context NLL (top) and unseen target NLL given contexts (bottom).
+
+![](images/2a77a83787ef0d15fe250b575d0f3bb0a92ce7fef4ab4dcee671f0ecc1b8649e.jpg)  
+Figure 4: Qualitative and quantitative results on test set for 2D CelebA function regression.   
+Figure 5: Reconstruction of full image from top half. The CelebA results use the same models (with the same parameter values) as Figure 4a.
+
+clearly in the predictive standard deviations (c.f. Appendix C for an explanation). The multiple heads in multihead attention appear to help smooth out the interpolations, giving good reconstruction of the contexts as well as prediction of the targets, while preserving increased predictive uncertainty away from the contexts as in a GP. The results for (A)NP trained on fixed GP kernel hyperparameters are similar (c.f. Appendix C), except that the NP underfits to a lesser degree because of the reduced variety of sample curves (functions) in the data. This difference in performance for the two kernel hyperparameter settings provides evidence of how the ANP is more expressive than the NP and can learn a wider range of functions.
+
+Using the trained (A)NPs we tackle a toy Bayesian Optimisation (BO) problem, where the task is to find the minimum of test functions drawn from a GP prior. This is a proof-of-concept experiment showing the utility of being able to sample entire functions from the (A)NP and having accurate context reconstructions. See Appendix C for the details and an analysis of results.
+
+2D Function regression on image data Image data can also be interpreted as being generated from a stochastic process (since there are dependencies between pixel values), and predicting the pixel values can be cast as a regression problem mapping a 2D pixel location $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ to its pixel intensity $\mathbf { \nabla } _ { \mathbf { \psi } _ { 3 } } \mathbf { \psi } _ { 2 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \qquad \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 }$ $\mathbf { \Lambda } \in \mathbb { R } ^ { 1 }$ for greyscale, $\in \mathbb { R } ^ { 3 }$ for RGB). Each image corresponds to one realisation of the process sampled on a fixed 2 dimensional grid. We train the ANP on MNIST (LeCun et al., 1998) and $3 2 \times 3 2$ CelebA (Liu et al., 2015) using the standard train/test split with up to 200 context/target points at training. For this application we explore the use of self-attentional layers in the encoder, stacking them as is done in Parmar et al. (2018). See Appendix D for experimental details.
+
+On both datasets we show results of three different models: NP, ANP with multihead cross-attention in the deterministic path (Multihead ANP), and ANP with both multihead attention in the deterministic path and two layers of stacked self-attention in both the deterministic and latent paths (Stacked Multihead ANP). Figure 4a shows predictions of the full image (i.e. full target) with a varying number of random context pixels, from 10 to 1024 (full image) for a randomly selected image (see Appendix E for other images). For each we generate predictions that correspond to the mean of $p ( \bar { \pmb { y } } _ { T } | \pmb { x } _ { T } , \pmb { r } _ { C } , z )$ for three different samples of $\bar { z } \sim q ( z | s _ { C } )$ . The NP (left) gives reasonable predictions with a fair amount of diversity for fewer contexts, but the reconstructions of the whole image are not accurate, compared to Stacked Multihead ANP (right) where the reconstructions are indistinguishable from the original. The use of attention also helps achieve crisper inpaintings when the target pixels are filled in, enhancing the ANP’s ability to model less smooth 2D functions compared to the NP. The diversity in faces and digits obtained with different values of $_ { z }$ is apparent the different samples, providing evidence for the claim that $_ { z }$ can model global structure of the image, with one sample corresponding to one realisation of the data generating stochastic process. Similar conclusions hold for MNIST (see Appendix E) and for the full image prediction using the top half as context in Figure 5. In the latter task, note that the model has never been trained on more than 200 context points, yet it manages to generalise to when the context is of size 512 (half the image).
+
+![](images/31f7034be116e24c1905201fe39547e6a1000932ab40174555f34fb1ac32309a.jpg)  
+Figure 6: Mapping between different resolutions by the same model (with the same parameter values) as Stacked Multihead ANP in Figures 4a, 5b. The two rightmost columns show the results of baseline methods, namely linear and cubic interpolation to $2 5 6 \times 2 5 6$ .
+
+Figure 4b verifies quantitatively that both Multihead and Stacked Multihead ANP give a much improved context reconstruction error compared to the NP. Similarly the NLL for the target points (that are not included in the context) is improved with multihead crossattention, showing small gains with stacked self-attention. However qualitatively, there are noticeable gains in crispness and global coherence when using stacked self-attention (see Appendix E). In Figure 7 we visualise each head of Multihead ANP for CelebA. We let the target pixel (cross) attend to all pixels, and see where each head of the attention focuses on. We colour-code the pixels with the top 20 weights per head, with intensity proportional to the attention weight. We can see that each head has different roles: the cyan head only looks at the target pixel and nothing else; the red head looks at a few pixels nearby; the green head looks at a larger region nearby; the yellow looks at the pixels on the column of the target; the orange looks at some band of the image; the purple head (interestingly) looks at the other side of the image, trying to exploit the symmetry of faces. We observe consistent behaviour in these heads for other target pixels (see Figure 16 of Appendix E).
+
+![](images/2fbb03c971104c2f9e6974bb1eb842001d5d27ad25d86c826990bc5fd9e119d5.jpg)  
+Figure 7: Pixels attended to by each head of multihead attention in Multihead ANP given a target pixel. Each head is given a different colour and the target pixel is marked with a cross.
+
+One other illustrative application of (A)NPs trained on images is that one can map images from one resolution to another, even if the model has only been trained on one resolution. Because the two dimensional $_ { \textbf { \em x } }$ (pixel locations) are modelled as real values that live in a continuous space, the model can predict the $\textbf {  { y } }$ (pixel intensities) of any point in this space, and not just the grid of points that it was trained on. Hence using one grid as the context and a finer grid as the target, the model can map a given resolution to a higher resolution. This could, however, be problematic for NPs whose reconstructions can be inaccurate, so the prediction of the target resolution can look very different to the original image (see Figure 19 of Appendix E). The reconstructions of ANPs may be accurate enough to give reliable mappings between different resolutions. We show results for such mappings given by the same Stacked Multihead ANP (the same model used to produce Figures 4a, 5b) in Figure 6. On the left, we see that the ANP (trained on $3 2 \times 3 2$ images) is capable of mapping low resolutions $4 \times 4$ or $8 \times 8$ ) to fairly realistic $3 2 \times 3 2$ target outputs with some diversity for different values of $_ z$ (more diversity for the $4 \times 4$ contexts as expected). Perhaps this performance is to be expected since the model has been trained on data that has $3 2 \times 3 2$ resolution. The same model allows us to map to even higher resolutions, namely from the original $3 2 \times 3 2$ images to $2 5 6 \times 2 5 6$ , displayed on the right of the figure. We see that even though the model has never seen any images beyond the original resolution, the model learns a fairly realistic high resolution image with sharper edges compared to the baseline interpolation methods. Moreover, there is some evidence that it learns an internal representation of the appearance of faces, when for example it learns to fill in the eye even when the original image is too coarse to separate the iris (coloured part) from the sclera (white part) (e.g. top row image), a feature that is not possible with simple interpolation. See Figure 19 in Appendix E for larger versions of the images.
+
+For each of MNIST and CelebA, all qualitative plots in this section were given from the same model (with the same parameter values) for each attention mechanism, learned by optimising the loss in Equation (3) over random context pixels and random target pixels at each iteration. It is important to note that we do not claim the ANP to be a replacement of state of the art algorithms of image inpainting or super-resolution, and rather we show these image applications to highlight the flexibility of the ANP in modelling a wide family of conditional distributions.
+
+# 5 RELATED WORK
+
+The work related to NPs in the domain of Gaussian Processes, Meta-Learning, conditional latent variable models and Bayesian Learning have been discussed extensively in the original works of Garnelo et al. (2018a;b), hence we focus on works that are particularly relevant for ANPs.
+
+Gaussian Processes (GPs) Returning to our motivation for using attention in NPs, there is a clear parallel between GP kernels and attention, in that they both give a measure of similarity between two points in the same domain. The use of attention in an embedding space that we explore is related to Deep Kernel Learning (Wilson et al., 2016) where a GP is applied to learned representations of data. Here, however, learning is still done in a GP framework by maximising the marginal likelihood. We reiterate that the training regimes of GPs and NPs are different, so a direct comparison between the methods is difficult. One possibility for comparison is to learn the GP via the training regime of NPs, namely updating the kernel hyperparameters at each iteration via one gradient step of the marginal likelihood on the mini-batch of data. However, this would still have a $\mathsf { \bar { O } } ( n ^ { 3 } )$ computational cost in the naive setting and may require kernel approximations. In general, the predictive uncertainties of GPs depend heavily on the choice of the kernel, whereas NPs learn predictive uncertainties directly from the data. Despite these drawbacks, GPs have the benefit of being consistent stochastic processes, and the covariance between the predictions at different $x$ -values and the marginal variance of each prediction can be expressed exactly in closed form, a feature that the current formulation of (A)NPs do not have. Variational Implicit Processes (VIP) (Ma et al., 2018) are also related to NPs, where VIP defines a stochastic process using the same decoder setup with a finite dimensional $_ { z }$ . Here, however, the process and its posterior given observed data are both approximated by a GP and learned via a generalisation of the Wake-Sleep algorithm (Hinton et al., 1995).
+
+Meta-Learning (A)NPs can be seen as models that do few-shot learning, although this is not the focus of our work. Given input-output pairs drawn from a new function at test time, one can reason about this function by looking at the predictive distribution conditioning on these input-output pairs. There is a plethora of works in few-shot classification, of which Vinyals et al. (2016); Snell et al. (2017); Santoro et al. (2016) use attention to locate the relevant observed image/prototype given a query image. Attention has also been used for tasks in Meta-RL such as continuous control and visual navigation (Mishra et al., 2018). Few-shot density estimation using attention has also been explored extensively in numerous works (Rezende et al., 2016; Reed et al., 2017; Bornschein et al., 2017; Bartunov & Vetrov, 2018). Especially relevant are the Neural Statistician (Edwards & Storkey, 2017) and the Variational Homoencoder (Hewitt et al., 2018) who have a similar permutation invariant encoder (that outputs summaries of a data set), but use local latents on top of a global latent. For ANPs, we look at the less-explored regression setting. The authors of Vfunc (Bachman et al., 2018) also explore regression on a toy 1D domain, using a similar setup to NPs but optimising an approximation to the entropy of the latent function, without any attention mechanisms. Multitask learning has also been tackled in the GP literature by various works (Teh et al., 2005; Bonilla et al., 2008; Alvarez et al., 2012; Dai et al., 2017).
+
+Generative Query Networks (Eslami et al., 2018; Kumar et al., 2018) are models for spatial prediction that render a frame of a scene given a viewpoint. Their model corresponds to a special case of NPs where the $_ { \textbf { \em x } }$ are viewpoints and the $\textbf {  { y } }$ are frames of a scene. Rosenbaum et al. (2018) apply the GQN to the task of 3D localisation with an attention mechanism, but attention is applied to patches of context frames $( y )$ instead of a parametric representation of viewpoints $( { \pmb x } )$ . Note that in our work the targets attend to the contexts via the $_ { \textbf { \em x } }$ .
+
+# 6 CONCLUSION AND DISCUSSION
+
+We have proposed ANPs, which augment NPs with attention to resolve the fundamental problem of underfitting. We have shown that this greatly improves the accuracy of predictions in terms of context and target NLL, results in faster training, and expands the range of functions that can be modelled. There is a wide scope of future work for ANPs. Regarding model architecture, one way of incorporating cross-attention into the latent path and modelling the dependencies across the resulting local latents is to also have a global latent, much like the setup of the Neural Statistician but translated to the regression setting. An interesting further application would be to train ANPs on text data, enabling them to fill in the blanks in a stochastic manner. For the image application, the Image Transformer (ImT) (Parmar et al., 2018) has some interesting connections with ANPs: its local self-attention used to predict consecutive pixel blocks from previous blocks has parallels with how our model attends to context pixels to predict target pixels. Replacing the MLP in the decoder of the ANP with self-attention across the target pixels, we have a model that closely resembles an ImT defined on arbitrary orderings of pixels. This is in contrast to the original ImT, which presumes a fixed ordering and is trained autoregressively. We plan to equip ANPs with self-attention in the decoder, and see how far their expressiveness can be extended. In this setup, however, the targets will affect each other’s predictions, so the ordering and grouping of the targets will become important.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Ali Razavi for his advice on implementing multihead attention, and Michael Figurnov for helpful discussion.
+
+# REFERENCES
+
+Mauricio A Alvarez, Lorenzo Rosasco, Neil D Lawrence, et al. Kernels for vector-valued functions: A review. Foundations and Trends $\textsuperscript { \textregistered }$ in Machine Learning, 4(3):195–266, 2012.
+
+Philip Bachman, Riashat Islam, Alessandro Sordoni, and Zafarali Ahmed. Vfunc: a deep generative model for functions. arXiv preprint arXiv:1807.04106, 2018.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015.
+
+Sergey Bartunov and Dmitry P Vetrov. Fast adaptation in generative models with generative matching networks. In AISTATS, 2018.
+
+Edwin V Bonilla, Kian M Chai, and Christopher Williams. Multi-task gaussian process prediction. In NIPS, 2008.
+
+Jorg Bornschein, Andriy Mnih, Daniel Zoran, and Danilo Jimenez Rezende. Variational memory ¨ addressing in generative models. In NIPS, 2017.
+
+Zhenwen Dai, Mauricio A Alvarez, and Neil Lawrence. Efficient modeling of latent information in ´ supervised learning using gaussian processes. In NIPS, 2017.
+
+Harrison Edwards and Amos Storkey. Towards a neural statistician. In ICLR, 2017.
+
+SM Ali Eslami, Danilo Jimenez Rezende, Frederic Besse, Fabio Viola, Ari S Morcos, Marta Garnelo, Avraham Ruderman, Andrei A Rusu, Ivo Danihelka, Karol Gregor, et al. Neural scene representation and rendering. Science, 360(6394):1204–1210, 2018.
+
+Marta Garnelo, Dan Rosenbaum, Christopher Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo Rezende, and SM Ali Eslami. Conditional neural processes. In ICML, 2018a.
+
+Marta Garnelo, Jonathan Schwarz, Dan Rosenbaum, Fabio Viola, Danilo J Rezende, SM Eslami, and Yee Whye Teh. Neural processes. In ICML Workshop on Theoretical Foundations and Applications of Deep Generative Models, 2018b.
+
+Alex Graves. Supervised sequence labelling with recurrent neural networks. Springer, 2012.
+
+Luke B Hewitt, Maxwell I Nye, Andreea Gane, Tommi Jaakkola, and Joshua B Tenenbaum. The variational homoencoder: Learning to learn high capacity generative models from few examples. In UAI, 2018.
+
+Geoffrey E Hinton, Peter Dayan, Brendan J Frey, and Radford M Neal. The” wake-sleep” algorithm for unsupervised neural networks. Science, 268(5214):1158–1161, 1995.
+
+D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In ICLR, 2015.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014.
+
+Ananya Kumar, SM Eslami, Danilo J Rezende, Marta Garnelo, Fabio Viola, Edward Lockhart, and Murray Shanahan. Consistent generative query networks. arXiv preprint arXiv:1807.02033, 2018.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Z. Liu, P. Luo, X. Wang, and X. Tang. Deep learning face attributes in the wild. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3730–3738, 2015.
+
+Chao Ma, Yingzhen Li, and Jose Miguel Hern ´ andez-Lobato. Variational implicit processes. ´ arXiv preprint arXiv:1806.02390, 2018.
+
+Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. A simple neural attentive metalearner. In ICLR, 2018.
+
+Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Łukasz Kaiser, Noam Shazeer, and Alexander Ku. Image transformer. In ICML, 2018.
+
+Scott Reed, Yutian Chen, Thomas Paine, Aaron van den Oord, SM Eslami, Danilo Rezende, Oriol ¨ Vinyals, and Nando de Freitas. Few-shot autoregressive density estimation: Towards learning to learn distributions. arXiv preprint arXiv:1710.10304, 2017.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In ICML, pp. 1278–1286, 2014.
+
+Danilo Jimenez Rezende, Shakir Mohamed, Ivo Danihelka, Karol Gregor, and Daan Wierstra. Oneshot generalization in deep generative models. arXiv preprint arXiv:1603.05106, 2016.
+
+Dan Rosenbaum, Frederic Besse, Fabio Viola, Danilo J Rezende, and SM Eslami. Learning models for visual 3d localization with implicit mapping. arXiv preprint arXiv:1807.03149, 2018.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Oneshot learning with memory-augmented neural networks. arXiv preprint arXiv:1605.06065, 2016.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In NIPS, 2017.
+
+Yee Whye Teh, Matthias Seeger, and Michael Jordan. Semiparametric latent factor models. In AISTATS, 2005.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NIPS, 2017.
+
+Oriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In NIPS, 2016.
+
+Andrew Gordon Wilson, Zhiting Hu, Ruslan Salakhutdinov, and Eric P Xing. Deep kernel learning. In Artificial Intelligence and Statistics, pp. 370–378, 2016.
+
+# APPENDIX
+
+# A ARCHITECTURAL DETAILS FOR (A)NP
+
+We show the architectural details of the NP and the Multihead ANP models used for the 1D and 2D regression experiments below in Figure 8. All MLPs have relu non-linearities except the final layer, which has no non-linearity. The latent path outputs $\mu _ { z } , \omega _ { z } \in \mathbb { R } ^ { d }$ , which parameterises $q ( z | \dot { s _ { C } } ) = N ( z | \mu _ { z } , 0 . 1 + 0 . 9 \sigma ( \omega _ { z } ) )$ where $\sigma$ is the sigmoid function. Similarly the decoder outputs $\mu _ { y } , \omega _ { y }$ , which parameterises $p ( \check { \pmb { y } } _ { i } | \mathbf { z } , \mathbf { x } _ { C } , \pmb { y } _ { C } , \pmb { x } _ { i } ) = \mathcal { N } ( \pmb { y } _ { i } | \mu _ { y } , 0 . 1 + 0 . 9 f ( \omega _ { y } ) )$ where $f$ is the softplus function.
+
+The 1D regression experiments use the basic formulation of multihead cross-attention (denoted M ultihead1) in Figure 8, whereas the 2D regression experiments uses a form of multihead crossattention used in the Image Transformer (Parmar et al., 2018). The only difference is that we do not use dropout, to limit the stochasticity of the model to the latent $z$ .
+
+Self-attention uses the same architecture as cross-attention but with $k _ { i } = v _ { i }$ , $q = k _ { j }$ for each $j \in C$ , to output $| C |$ representations given $| C |$ input representations. Since the self-attention module has the same number of inputs and outputs, it can be stacked. We stack 2 layers of self-attention for Stacked Multihead ANP in the 2D Image regression experiments. Stacking more layers did not lead to noticeable gains qualitatively and quantitatively.
+
+# B EXPERIMENTAL DETAILS OF 1D FUNCTION REGRESSION EXPERIMENT
+
+For the squared exponential kernel of the data generating GP, we use a length scale $l = 0 . 6$ and kernel scale $\sigma _ { f } ^ { 2 } = \mathrm { \bar { 1 } }$ for the fixed kernel hyperparameter experiments. For the random kernel hyperparameter case, we sample $l \sim U [ 0 . 1 , 0 . 6 ]$ , $\sigma _ { f } \sim U [ 0 . 1 , 1 ]$ . For both, the likelihood noise is $\sigma _ { n } = 0 . 0 2$ . We use a batch size of 16 — in the fixed hyperparameter setting, we draw 16 curves from a GP with these hyperparameters, and in the random hyperparameter setting, we sample 16 random values of hyperparameters and draw a curve from GPs with each of these hyperparameters. We use the Adam Optimiser (Kingma & Ba, 2015) with a fixed learning rate of 5e-5 and Tensorflow defaults for the other hyperparameters. We use one sample of $q ( z | \mathbf { \mathit { s } } _ { C } )$ to form a MC estimate of the loss in Equation (3) during training and evaluation.
+
+For NP, $d$ is varied between $\{ 1 2 8 , 2 5 6 , 5 1 2 , 1 0 2 4 \}$ whereas for ANP we always use $d = 1 2 8$ .
+
+![](images/8cf6eafd11824217a59e31319e0e8dec929cdfc6a5a2e934999ca93095b32568.jpg)  
+Figure 8: The model architecture for NP and ANP for both 1D and 2D regression.
+
+# C ADDITIONAL FIGURES FOR 1D REGRESSION ON GP DATA
+
+![](images/21a7bfa76c05b01245d704f5574832eab8a49f6f8d18829dba783e77e31bd953.jpg)  
+Figure 9: Same as right of Figure 3 but also comparing against the oracle GP from which context was drawn.
+
+In Figure 9 we also compare the trained (A)NP models against the oracle GP from which the contexts were drawn. We see that the predictions Multihead ANP is notably closer to that of the oracle GP than the NP, but still underestimates the predictive variance. One possible explanation for this is that variational inference (used for learning the ANP) usually leads to underestimates of predictive variance. It would be interesting to investigate how this issue can be addressed.
+
+![](images/e8424775eaa265e1b44fe1b2a4c1bf534e70de9b55d46acd462f9dd68107c120.jpg)  
+Figure 10: Same as Figure 3 but for fixed kernel hyperparameters.
+
+The right of Figure 10 shows the conditional distributions for fixed kernel hyperparameters (with contexts drawn from the GP with these kernel hyperparameters), with highly non-smooth behaviour for dot-product attention as with the random kernel hyperparameter case. This behaviour seems to arise when the dot-product attention collapses to the local minimum of learning to be a nearest neighbour predictor (with one entry of the softmax becoming saturated), hence giving good reconstructions but poor interpolations between context points.
+
+![](images/e1d944521282fff47edf9afec80b595c135a710e7bd7d3d10e1f694f45a4d603.jpg)  
+Figure 11: KL term in NP loss throughout training for data generated from a GP with fixed (left) and random (right) kernel hyperparameters, using the same colour scheme as Figure 10.
+
+Figure 11 shows how the KL term in the (A)NP loss differs between training on the fixed kernel hyperparameter GP data and on the random kernel hyperparameter GP data. In the fixed hyperparameter case, the KL for multihead ANP quickly goes to 0, indicating that the model deems the deterministic path sufficient to make accurate predictions. However in the random hyperparameter case, there is added variation in the data, hence the attention gives a non-zero KL and uses the latents to model the uncertainty in the realisation of the stochastic process given some context points. In other words, given a context set, the model believes that there are multiple realisations of the stochastic process that can explain these contexts well, hence uses the latents to model this variation.
+
+![](images/0ee4c67b8ede6dd2fa6e6dbdb2aeee44dfdeeb7504d69cfebe1f20e561cd29de.jpg)  
+Figure 12: Simple and cumulative regret for BO.
+
+Using the same (A)NPs trained on the 1D GP data, we tackle the BO problem of finding the minimum of test functions drawn from a GP prior. We compare ANPs trained with different attention mechanisms to an oracle GP for which we set the kernel hyperparameters to their true value. (A)NPs can be used for BO by considering all previous function evaluations as context points, thus obtaining an informed surrogate of the target function. While other choices are possible, we use Thompson sampling to drawing a simple function from the surrogate and acting according to its minimal predicted value. We show results averaged over 100 test functions in Figure 12. We can see that the simple regret (the difference between the predicted and true minimum) is consistently smallest for a NP with multihead attention, approaching the oracle GP. Among the NPs, the slope of the cumulative regret (simple regret summed up to given iteration) decreases most rapidly for multihead, indicating that previous function evaluations are being put to good use for subsequent predictions of the function minimum. The reason that the cumulative regret is initially lower than the oracle GP is a consequence of under-exploration, due to the uncertainties of ANP away from the context being smaller than that of the oracle GP.
+
+# D EXPERIMENTAL DETAILS OF 2D IMAGE REGRESSION EXPERIMENT
+
+Analogous to the 1D experiments, we take random pixels of a given image at training as targets, and select a subset of this as contexts, again choosing the number of contexts and targets randomly $\mathrm { \Delta } n \sim U [ 3 , 2 0 0 ]$ , $m \sim n + U [ 0 , 2 0 0 - \bar { n } ] )$ . The $_ { \textbf { \em x } }$ are rescaled to $[ - 1 , 1 ]$ and the $\textbf {  { y } }$ are rescaled to $[ - 0 . 5 , 0 . 5 ]$ . We use a batch size of 16 for both MNIST and CelebA, i.e. use 16 randomly selected images for each batch. We use a learning rate of 5e-5 and 4e-5 respectively for MNIST and CelebA using the Adam optimiser with Tensorflow defaults for the other hyperparameters. The stacked self-attention architecture is the same as in the Image Transformer (Parmar et al., 2018), except that we do not use Dropout to restrict the stochasticity of the model to the global latent $_ z$ , and do not use positional embeddings of the pixels. We use the same architecture for both Mnist and CelebA, and highlight that little tuning has been done regarding the architectural hyperparameters. We again use one sample of $q ( \boldsymbol { z } | \boldsymbol { s } _ { C } )$ to form a MC estimate of the loss in Equation (3) during training and evaluation.
+
+# E ADDITIONAL FIGURES FOR 2D IMAGE REGRESSION ON MNIST AND CELEBA
+
+We can see visually that the NP overestimates the predictive variance by looking at the plot of the standard deviation (bottom row) of Figure 13a. We see that the original NP shows noticeable uncertainty around the edges of the reconstruction for all context sets, whereas for the NP with attention, the uncertainty is reduced significantly as you increase the number of contexts until it almost disappears for the full context.
+
+![](images/949bac79d4cddf0a8c5099f1f1156af3cfcea2a1919ca9f872c00c6e9af89d59.jpg)  
+(b) Same as Figure 4b but for MNIST.
+
+(a) Same as Figure 4a but for MNIST.
+
+![](images/28eab2cdc533d57564d926bf752144c5c69d007c242554d1a75deeeaa608b8af.jpg)  
+Figure 13: Qualitative and quantitative results of different attention mechanisms on test set for 2D MNIST function regression.
+
+![](images/4e47e791cd12a926ebc2e0d7d9f86ef163f653dd9268b3723fecc066a504185c.jpg)  
+Figure 14: More MNIST reconstruction of full image from top half.499th export - 5e6 iter, xid=1650728, num_contexts=200, lr=5e-4   
+Figure 15: More CelebA reconstruction of full image from top half.
+
+From Figures 14 and 15 we see that Stacked Multihead ANP improves results significantly over Multihead ANP, giving sharper images with better global coherence even in the case where the face isn’t axis-aligned (see Figure 15a).
+
+Note that in Figure 7, the contexts contain the target, relying on the cyan head would be enough to give an accurate prediction, but the different roles of these heads also hold in the case where the target is disjoint from the context. This is shown in Figure 16 where the context is disjoint from the target. Here all heads become useful for the target prediction.
+
+![](images/c1ca98b476ba0edb8716ab6204cf13514d1468c0603f38bc6b88a6881cf98dd7.jpg)  
+Figure 16: Visualisation of pixels attended by each head of multihead attention in the NP given a target pixel and a separate context of 100 random pixels. Each head is given a different colour (consistent with the colours in Figure 7 and the target pixel is marked by a cross.
+
+![](images/4f96913df6f84f7596017ea6090da7387f53f286daf6efa445a107920678ff8c.jpg)  
+Figure 17: Same as Figure 4a but for a different image.
+
+![](images/779adeb3f18e4efcc71266c32815e77ce550a7c399631f49dc312aabd8143e42.jpg)  
+Figure 18: Same as Figure 4a but for a different image.
+
+![](images/8df6ea84c309649d04e7d3c77526511cc065c016c2daa79ab93190f291dc161f.jpg)  
+Figure 19: Mapping from $3 2 \times 3 2$ to $2 5 6 \times 2 5 6$ for different images.

parse/train/SkE6PjC9KX/SkE6PjC9KX_content_list.json

@@ -0,0 +1,1630 @@
+[
+    {
+        "type": "text",
+        "text": "ATTENTIVE NEURAL PROCESSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            570,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hyunjik $\\mathbf { K i m ^ { 1 , 2 * } }$ , Andriy ${ \\bf { M } } { \\bf { n i h } } ^ { 1 }$ , Jonathan Schwarz1, Marta Garnelo1, Ali Eslami1,   \nDan Rosenbaum1, Oriol Vinyals1, Yee Whye Teh1,2   \nDeepMind1, University of Oxford2 ",
+        "bbox": [
+            183,
+            143,
+            769,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            224,
+            544,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural Processes (NPs) (Garnelo et al., 2018a;b) approach regression by learning to map a context set of observed input-output pairs to a distribution over regression functions. Each function models the distribution of the output given an input, conditioned on the context. NPs have the benefit of fitting observed data efficiently with linear complexity in the number of context input-output pairs, and can learn a wide family of conditional distributions; they learn predictive distributions conditioned on context sets of arbitrary size. Nonetheless, we show that NPs suffer a fundamental drawback of underfitting, giving inaccurate predictions at the inputs of the observed data they condition on. We address this issue by incorporating attention into NPs, allowing each input location to attend to the relevant context points for the prediction. We show that this greatly improves the accuracy of predictions, results in noticeably faster training, and expands the range of functions that can be modelled. ",
+        "bbox": [
+            233,
+            257,
+            764,
+            436
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            336,
+            481
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Regression tasks are usually cast as modelling the distribution of a vector-valued output $\\textbf {  { y } }$ given a vector-valued input $_ { \\textbf { \\em x } }$ via a deterministic function, such as a neural network, taking $_ { \\textbf { \\em x } }$ as an input. In this setting, the model is trained on a dataset of input-output pairs, and predictions of the outputs are independent of each other given the inputs. An alternative approach to regression involves using the training data to compute a distribution over functions that map inputs to outputs, and using draws from that distribution to make predictions on test inputs. This approach allows for reasoning about multiple functions consistent with the data, and can capture the co-variability in outputs given inputs. In the Bayesian machine learning literature, non-parametric models such as Gaussian Processes (GPs) are popular choices of this approach. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            622
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural Processes (NPs) (Garnelo et al., 2018a;b) offer an efficient method to modelling a distribution over regression functions, with prediction complexity linear in the context set size. Once trained, they can predict the distribution of an arbitrary target output conditioned on a set of context inputoutput pairs of an arbitrary size. This flexibility of NPs enables them to model data that can be interpreted as being generated from a stochastic process. It is important to note however that NPs and GPs have different training regimes. NPs are trained on samples from multiple realisations of a stochastic process (i.e. trained on many different functions), whereas GPs are usually trained on observations from one realisation of the stochastic process (a single function). Hence a direct comparison between the two is usually not plausible. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            755
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite their many appealing properties, one substantial weakness of NPs is that they tend to underfit the context set. This manifests in the 1D curve fitting example on the left half of Figure 1 as inaccurate predictive means and overestimated variances at the input locations of the context set. The right half of the figure shows this phenomenon when predicting the bottom half of a face image from its top half: although the prediction is globally coherent, the model’s reconstruction of the top-half is far from perfect. In an NP, the encoder aggregates the context set to a fixed-length latent summary via a permutation invariant function, and the decoder maps the latent and target input to the target output. We hypothesise that the underfitting behaviour is because the mean-aggregation step in the encoder acts as a bottleneck: since taking the mean across context representations gives the same weight to each context point, it is difficult for the decoder to learn which context points provide relevant information for a given target prediction. In theory, increasing the dimensionality of the representation could address this issue, but we show in Section 4 that in practice, this is not sufficient. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ba54f692bcc35600ad5cde87d8bae38ca586a2197e4f891cbf69108e1052b875.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of predictions given by a fully trained NP and Attentive NP (ANP) in 1D function regression (left) / 2D image regression (right). The contexts (crosses/top half pixels) are used to predict the target outputs $y$ -values of all $x \\in [ - 2 , 2 ] / \\mathrm { a l l }$ pixels in image). The ANP predictions are noticeably more accurate than for NP at the context points. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            71,
+            820,
+            170
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            253,
+            821,
+            296
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address this issue, we draw inspiration from GPs, which also define a family of conditional distributions for regression. In GPs, the kernel can be interpreted as a measure of similarity among two points in the input domain, and shows which context points $( { \\pmb x } _ { i } , { \\pmb y } _ { i } )$ are relevant for a given query $^ { \\mathbf { \\delta x } }$ . Hence when $^ { \\mathbf { \\delta x } }$ is close to some $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ , its $y$ -value prediction $^ { \\pmb { y } _ { \\ast } }$ is necessarily close to $\\mathbf { \\nabla } _ { \\mathbf { \\boldsymbol { y } } _ { i } }$ (assuming small likelihood noise), and there is no risk of underfitting. We implement a similar mechanism in NPs using differentiable attention that learns to attend to the contexts relevant to the given target, while preserving the permutation invariance in the contexts. We evaluate the resulting Attentive Neural Processes (ANPs) on 1D function regression and on 2D image regression. Our results show that ANPs greatly improve upon NPs in terms of reconstruction of contexts as well as speed of training, both against iterations and wall clock time. We also demonstrate that ANPs show enhanced expressiveness relative to the NP and is able to model a wider range of functions. ",
+        "bbox": [
+            173,
+            303,
+            825,
+            455
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            326,
+            500
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 NEURAL PROCESSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            520,
+            359,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The NP is a model for regression functions that map an input $\\pmb { x } _ { i } \\in \\mathbb { R } ^ { d _ { x } }$ to an output $\\boldsymbol { y } _ { i } \\in \\mathbb { R } ^ { d _ { y } }$ . In particular, the NP defines a (infinite) family of conditional distributions, where one may condition on an arbitrary number of observed contexts $( \\pmb { x } _ { C } , \\pmb { y } _ { C } ) : = ( \\pmb { x } _ { i } , \\pmb { y } _ { i } ) _ { i \\in C }$ to model an arbitrary number of targets $( { \\pmb x } _ { T } , { \\pmb y } _ { T } ) : = ( { \\pmb x } _ { i } , { \\pmb y } _ { i } ) _ { i \\in T }$ in a way that is invariant to ordering of the contexts and ordering of the targets. The model is defined for arbitrary $C$ and $T$ but in practice we use $C \\subset T$ . The deterministic NP models these conditional distributions as: ",
+        "bbox": [
+            173,
+            547,
+            825,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41ac9b527308cbdf77b9069dd1e2a030a686526a81e1a91ff2d1498a5e5588db.jpg",
+        "text": "$$\np ( { \\pmb y } _ { T } | { \\pmb x } _ { T } , { \\pmb x } _ { C } , { \\pmb y } _ { C } ) : = p ( { \\pmb y } _ { T } | { \\pmb x } _ { T } , { \\pmb r } _ { C } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            637,
+            620,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "with $r _ { C } : = r ( \\pmb { x } _ { C } , \\pmb { y } _ { C } ) \\in \\mathbb { R } ^ { d }$ where $r$ is a deterministic function that aggregates $( \\pmb { x } _ { C } , \\pmb { y } _ { C } )$ into a finite dimensional representation with permutation invariance in $C$ . In practice, each context $( { \\pmb x } , { \\pmb y } )$ pair is passed through an MLP to form a representation of each pair, and these are aggregated by taking the mean to form $r _ { C }$ . The likelihood $p ( { \\pmb y } _ { T } | { \\pmb x } _ { T } , { \\pmb r } _ { C } )$ is modelled by a Gaussian factorised across the targets $( { \\pmb x } _ { i } , { \\pmb y } _ { i } ) _ { i \\in T }$ with mean and variance given by passing $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ and $\\mathbf { \\Delta } _ { \\mathbf { \\left. r _ { C } \\right. } }$ through an MLP. The unconditional distribution $p ( { \\pmb y } _ { T } | { \\pmb x } _ { T } )$ (when $C = \\varnothing$ ) is defined by letting $r _ { \\emptyset }$ be a fixed vector. ",
+        "bbox": [
+            174,
+            657,
+            823,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The latent variable version of the NP model includes a global latent $_ z$ to account for uncertainty in the predictions of $\\mathbf { \\pmb { y } } _ { T }$ for a given observed $( \\pmb { x } _ { C } , \\pmb { y } _ { C } )$ . It is incorporated into the model via a latent path that complements the deterministic path described above. Here $_ { z }$ is modelled by a factorised Gaussian parametrised by $\\pmb { s } _ { C } : = \\pmb { s } ( \\pmb { x } _ { C } , \\pmb { y } _ { C } )$ , with $s$ being a function of the same properties as $r$ ",
+        "bbox": [
+            173,
+            748,
+            825,
+            806
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/286b91c389f5a33b0091f754252170ef801ab0a516b31142c9a2611a7fb8febc.jpg",
+        "text": "$$\np ( \\pmb { y } _ { T } | \\pmb { x } _ { T } , \\pmb { x } _ { C } , \\pmb { y } _ { C } ) : = \\int p ( \\pmb { y } _ { T } | \\pmb { x } _ { T } , \\pmb { r } _ { C } , z ) q ( z | \\pmb { s } _ { C } ) d z\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            810,
+            676,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "with $q ( z | s _ { \\emptyset } ) : = p ( z )$ , the prior on $_ z$ . The likelihood is referred to as the decoder, and $q , r , s$ form the encoder. See Figure 2 for diagrams of these models. ",
+        "bbox": [
+            176,
+            845,
+            823,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The motivation for having a global latent is to model different realisations of the data generating stochastic process — each sample of $_ z$ would correspond to one realisation of the stochastic process. One can define the model using either just the deterministic path, just the latent path, or both. In this ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "work we investigate the case of using both paths, which gives the most expressive model and also gives a sensible setup for incorporating attention, as we will show later in Section 3. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The parameters of the encoder and decoder are learned by maximising the following ELBO ",
+        "bbox": [
+            184,
+            138,
+            774,
+            154
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f17f07358bf706bf8ad254efb050f33729f231297145a7b7dd75ab6fd0545887.jpg",
+        "text": "$$\n\\log p ( y _ { T } | x _ { T } , x _ { C } , y _ { C } ) \\geq \\mathbb { E } _ { q ( z | s _ { T } ) } [ \\log p ( y _ { T } | x _ { T } , r _ { C } , z ) ] - D _ { \\mathrm { K L } } ( q ( z | s _ { T } ) | | q ( z | s _ { C } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            157,
+            774,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for a random subset of contexts $C$ and targets $T$ via the reparametrisation trick (Kingma & Welling, 2014; Rezende et al., 2014). In other words, the NP learns to reconstruct targets, regularised by a KL term that encourages the summary of the contexts to be not too far from the summary of the targets. This is sensible since we are assuming that the contexts and targets come from the same realisation of the data-generating stochastic process, and especially so if targets contain contexts. At each training iteration, the number of contexts and targets are also chosen randomly (as well as being randomly sampled from the training data), so that the NP can learn a wide family of conditional distributions. ",
+        "bbox": [
+            173,
+            179,
+            825,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "NPs have many desirable properties, namely (i) Scalability: computation scales linearly at $O ( n { + } m )$ for $n$ contexts and $m$ targets at train and prediction time. (ii) Flexibility: defines a very wide family of distributions, where one can condition on an arbitrary number of contexts to predict an arbitrary number of targets. (iii) Permutation invariance: the predictions of the targets are order invariant in the contexts. However these advantages come at the cost of not satisfying consistency in the contexts. For example, if $\\mathbf { \\boldsymbol { \\mathsf { y } } } _ { 1 : m }$ is generated given some context set, then its distribution need not match the distribution you would obtain if $\\pmb { y } _ { 1 : n }$ is generated first, appended to the context set then ${ \\pmb y } _ { n + 1 : m }$ is generated. However maximum-likelihood learning can be interpreted as minimising the KL between the (consistent) conditional distributions of the data-generating stochastic process and the corresponding conditional distributions of the NP. Hence we could view the NP as approximating the conditionals of the consistent data-generating stochastic process. ",
+        "bbox": [
+            173,
+            284,
+            825,
+            436
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            297,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a set of key-value pairs $( k _ { i } , v _ { i } ) _ { i \\in \\mathbb { Z } }$ and a query $q$ , an attention mechanism computes weights of each key with respect to the query, and aggregates the values with these weights to form the value corresponding to the query. In other words, the query attends to the key-value pairs. The queried values are invariant to the ordering of the key-value pairs; this permutation invariance property of attention is key in its application to NPs. The idea of using a differentiable addressing mechanism that can be learned from the data has been applied successfully in various areas of Deep Learning, namely handwriting generation and recognition (Graves, 2012) and neural machine translation (Bahdanau et al., 2015). More recently, there has been work employing self-attention (where keys and queries are identical) to give expressive sequence-to-sequence mappings in natural language processing (Vaswani et al., 2017) and image modelling (Parmar et al., 2018). ",
+        "bbox": [
+            173,
+            483,
+            825,
+            623
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We give some examples of attention mechanisms which are used in the paper. Suppose we have $n$ key-value pairs arranged as matrices $K \\in \\mathbb { R } ^ { n \\times d _ { k } }$ , $V \\in \\mathbb { R } ^ { n \\times d _ { v } }$ , and $m$ queries $Q \\in \\mathbb { R } ^ { m \\times d _ { k } }$ . Simple forms of attention based on locality (weighting keys according to distance from query) are given by various stationary kernels. For example, the (normalised) Laplace kernel gives the queried values as ",
+        "bbox": [
+            174,
+            628,
+            825,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d42b62462968efdb84dc28c1eb161dc01a674a653fb414d266d4a651ecd41d2a.jpg",
+        "text": "$$\n\\mathbf { L a p l a c e } ( Q , K , V ) : = W V \\in \\mathbb { R } ^ { m \\times d _ { v } } , \\qquad W _ { i } : = \\mathrm { s o f t m a x } ( ( - | | Q _ { i } , - K _ { j } . | | _ { 1 } ) _ { j = 1 } ^ { n } ) \\in \\mathbb { R } ^ { n }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            204,
+            690,
+            790,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Similarly (scaled) dot-product attention uses the dot-product between the query and keys as a measure of similarity, and weights the keys according to the values ",
+        "bbox": [
+            174,
+            713,
+            821,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f23fd506220cdfd9641462ccaed6e589b32e51afdb9eaf7fce0a25b29f056a4c.jpg",
+        "text": "$$\n\\mathbf { D o t P r o d u c t } ( Q , K , V ) : = \\operatorname { s o f t m a x } ( Q K ^ { \\top } / \\sqrt { d _ { k } } ) V \\in \\mathbb { R } ^ { m \\times d _ { v } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            746,
+            699,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The use of dot-product attention allows the query values to be computed with two matrix multiplications and a softmax, allowing for use of highly optimised matrix multiplication code. ",
+        "bbox": [
+            174,
+            770,
+            821,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "multihead attention (Vaswani et al., 2017) is a parametrised extension where for each head, the keys, values and queries are linearly transformed, then dot-product attention is applied to give headspecific values. These values are concatenated and linearly transformed to produce the final values: ",
+        "bbox": [
+            174,
+            804,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b703b02654e03fcca903166ebb50e7aadc36ada69ac59528433930e05a721ae5.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { M u l t i H e a d } ( Q , K , V ) : = \\mathrm { c o n c a t } ( \\mathrm { h e a d } _ { 1 } , \\dots , \\mathrm { h e a d } _ { H } ) W \\in \\mathbb { R } ^ { m \\times d _ { v } } } \\\\ & { \\qquad \\mathrm { w h e r e ~ h e a d } _ { h } : = \\mathrm { D o t P r o d u c t } ( Q W _ { h } ^ { Q } , K W _ { h } ^ { K } , V W _ { h } ^ { V } ) \\in \\mathbb { R } ^ { m \\times d _ { v } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            852,
+            735,
+            893
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This multihead architecture allows the query to attend to different keys for each head and tends to give smoother query-values than dot-product attention (c.f. Section 4). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ATTENTIVE NEURAL PROCESSES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            480,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/be70b3d915e9d80198e52c93260a723933b03c9d3d58fc0220b12c7fcb48d6cf.jpg",
+        "image_caption": [
+            "Figure 2: Model architecture for the NP (left) and Attentive NP (right) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            138,
+            825,
+            292
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 describes how attention is incorporated into NP to give the Attentive NP (ANP). In summary, self-attention is applied to the context points to compute representations of each $( { \\pmb x } , { \\pmb y } )$ pair, and the target input attends to these context representations (cross-attention) to predict the target output. In detail, the representation of each context pair $( { \\pmb x } _ { i } , { \\pmb y } _ { i } ) _ { i \\in C }$ before the mean-aggregation step is computed by a self-attention mechanism, in both the deterministic and latent path. The intuition for the self-attention is to model interactions between the context points. For example, if many context points overlap, then the query need not attend to all of these points, but only give high weight to one or a few. The self-attention will help obtain richer representations of the context points that encode these types of relations between the context points. We model higher order interactions by simply stacking the self-attention, as is done in Vaswani et al. (2017). ",
+        "bbox": [
+            173,
+            325,
+            825,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the deterministic path, the mean-aggregation of the context representations that produces $\\mathbf { \\Delta } _ { \\mathbf { \\left. r _ { C } \\right. } }$ is replaced by a cross-attention mechanism, where each target query $^ { \\mathbf { x } } { } ^ { \\mathrm { ~ } }$ attends to the context $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { C } : =$ $( { \\bar { \\pmb { x } } } _ { i } ) _ { i \\in C }$ to produce a query-specific representation $\\pmb { r } _ { * } : = r ^ { * } ( \\pmb { x } _ { C } , \\pmb { y } _ { C } , \\pmb { x } _ { * } )$ . This is precisely where the model allows each query to attend more closely to the context points that it deems relevant for the prediction. The reason we do not have an analogous mechanism in the latent path is that we would like to preserve the global latent, that induces dependencies between the target predictions. The interpretation of the latent path is that $_ z$ gives rise to correlations in the marginal distribution of the target predictions $\\mathbf { \\pmb { y } } _ { T }$ , modelling the global structure of the stochastic process realisation, whereas the deterministic path models the fine-grained local structure. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The decoder remains the same, except we replace the shared context representation $\\mathbf { \\Delta } _ { \\mathbf { \\left. r _ { C } \\right. } }$ with the query-specific representation $\\mathbf { \\Delta } _ { \\mathbf { r } _ { * } }$ . Note that permutation invariance in the contexts is preserved with the attention mechanism. If we use uniform attention (all contexts given the same weight) throughout, we recover the NP. ANP is trained using the same loss (3) as the original NP, also using Gaussian likelihood $p ( \\pmb { y } _ { i } | \\pmb { x } _ { i } , r ^ { * } ( \\pmb { x } _ { C } , \\pmb { y } _ { C } , \\pmb { x } _ { i } ) , z )$ and diagonal Gaussian $q ( \\boldsymbol { z } | \\boldsymbol { s } _ { C } )$ . ",
+        "bbox": [
+            174,
+            603,
+            825,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The added expressivity and resulting accuracy of the NP with attention comes at a cost. The computational complexity is raised from $\\bar { O } ( n + m ) $ to $O ( n ( n + m ) )$ , since we apply self-attention across the contexts and for every target point we compute weights for all contexts. However most of the computation for the (self-)attention is done via matrix multiplication (c.f. Section 2.2), and so can be done in parallel across the contexts and across the targets. In practice, the training time for ANPs remains comparable to NPs, and in fact we show that ANPs learn significantly faster than NPs not only in terms of training iterations but also in wall-clock time, despite being slower at prediction time (c.f. Section 4). ",
+        "bbox": [
+            173,
+            679,
+            825,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            819,
+            418,
+            834
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the (A)NP learns a stochastic process, so should be trained on multiple functions that are realisations of the stochastic process. At each training iteration, we draw a batch of realisations from the data generating stochastic process, and select random points on these realisations to be the targets and a subset to be the contexts to optimise the loss in Equation (3). We use the same decoder architecture for all experiments, and 8 heads for multihead. See Appendix A for architectural details. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8805bccfaf2156eb10fc3567a04022b03d867dfe5ee24067f4304d47926b47fb.jpg",
+        "image_caption": [
+            "Figure 3: Qualitative and quantitative results of different attention mechanisms for 1D GP function regression with random kernel hyperparameters. Left: moving average of context reconstruction error (top) and target negative log likelihood (NLL) given contexts (bottom) plotted against training iterations (left) and wall clock time (right). $d$ denotes the bottleneck size i.e. hidden layer size of all MLPs and the dimensionality of $r$ and $z$ . Right: predictive mean and variance of different attention mechanisms given the same context. Best viewed in colour. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            92,
+            825,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1D Function regression on synthetic GP data We first explore the (A)NPs trained on data that is generated from a Gaussian Process with a squared-exponential kernel and small likelihood noise1. We emphasise that (A)NPs need not be trained on GP data or data generated from a known stochastic process, and this is just an illustrative example. We explore two settings: one where the hyperparameters of the kernel are fixed throughout training, and another where they vary randomly at each training iteration. The number of contexts $( n )$ and number of targets $( m )$ are chosen randomly at each iteration $( n \\sim U [ 3 , 1 0 0 ]$ , $m \\sim n + U [ 0 , 1 0 0 - n ] )$ . Each $x$ -value is drawn uniformly at random in $[ - 2 , 2 ]$ . For this simple 1D data, we do not use self-attention and just explore the use of cross-attention in the deterministic path (c.f. Figure 2). Thus we use the same encoder/decoder architecture for NP and ANP, except for the cross-attention. See Appendix B for experimental details. ",
+        "bbox": [
+            174,
+            373,
+            825,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 (left) shows context reconstruction error $\\begin{array} { r } { \\frac { 1 } { | C | } \\sum _ { i \\in C } \\mathbb { E } _ { q ( z | s _ { C } ) } [ \\log p ( \\pmb { y } _ { i } | \\pmb { x } _ { i } , r ^ { * } ( \\pmb { x } _ { C } , \\pmb { y } _ { C } , \\pmb { x } _ { i } ) , z ) ] } \\end{array}$ and NLL of targets given contexts $\\begin{array} { r } { \\frac { 1 } { | T | } \\sum _ { i \\in T } \\mathbb { E } _ { q ( z | s _ { C } ) } [ \\log p ( \\pmb { y } _ { i } | \\pmb { x } _ { i } , r ^ { * } ( \\pmb { x } _ { C } , \\pmb { y } _ { C } , \\pmb { x } _ { i } ) , z ) ] } \\end{array}$ for the different attention mechanisms, trained on a GP with random kernel hyperparameters. ANP shows a much more rapid decrease in reconstruction error and lower values at convergence compared to the NP, especially for dot product and multihead attention. This holds not only against training iteration but also against wall clock time, so learning is fast despite the added computational cost of attention. The right column plots show that the computation times of Laplace and dot-product ANP are similar to the NP for the same value of $d$ , and multihead ANP takes around twice the time. We also show how the size of the bottleneck $( d )$ in the deterministic and latent paths of the NP affects the underfitting behaviour of NPs. The figure shows that raising $d$ does help achieve better reconstructions, but there appears to be a limit in how much reconstructions can improve. Beyond a certain value of $d$ , the learning for the NP becomes too slow, and the value of reconstruction error at convergence is still higher than that achieved by multihead ANP with $10 \\%$ of the wall-clock time. Hence using ANPs has significant benefits over simply raising the bottleneck size in NPs. ",
+        "bbox": [
+            173,
+            518,
+            828,
+            720
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3 (right) we visualise the learned conditional distribution for a qualitative comparison of the attention mechanisms. The context is drawn from the GP with the hyperparameter values that give the most fluctuation. Note that the predictive mean of the NP underfits the context, and tries to explain the data by learning a large likelihood noise. Laplace shows similar behaviour, whereas dotproduct attention gives predictive means that accurately predict almost all context points. Note that Laplace attention is parameter-free (keys and queries are the x-coordinates) whereas for dot-product attention we have set the keys and queries to be parameterised representations of the x-values (output of learned MLP that takes $\\mathbf { X } ^ { \\prime }$ -coordinates as inputs). So the dot-product similarities are computed in a learned representation space, whereas for Laplace attention the similarities are computed based on L1 distance in the $\\mathbf { X }$ -coordinate domain, hence it is expected that dot-product attention outperforms Laplace attention. However dot-product attention displays non-smooth predictions, shown more (a) Reconstructions of full CelebA image from a varying number of random context points for NP (left) and Stacked Multihead ANP (right). ",
+        "bbox": [
+            173,
+            728,
+            825,
+            881
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9aae810eb2780d7beb0bdfb1b682c13682a2b3ac1fdd73d66b794ca0d962c69e.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            622,
+            93,
+            808,
+            272
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0c19bab9627523cd98792461e1b139dcfed710249f95b8d040dad5392fe199b.jpg",
+        "image_caption": [
+            "(b) Context NLL (top) and unseen target NLL given contexts (bottom). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            92,
+            602,
+            271
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            279,
+            604,
+            304
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a77a83787ef0d15fe250b575d0f3bb0a92ce7fef4ab4dcee671f0ecc1b8649e.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative and quantitative results on test set for 2D CelebA function regression. ",
+            "Figure 5: Reconstruction of full image from top half. The CelebA results use the same models (with the same parameter values) as Figure 4a. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            335,
+            799,
+            439
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "clearly in the predictive standard deviations (c.f. Appendix C for an explanation). The multiple heads in multihead attention appear to help smooth out the interpolations, giving good reconstruction of the contexts as well as prediction of the targets, while preserving increased predictive uncertainty away from the contexts as in a GP. The results for (A)NP trained on fixed GP kernel hyperparameters are similar (c.f. Appendix C), except that the NP underfits to a lesser degree because of the reduced variety of sample curves (functions) in the data. This difference in performance for the two kernel hyperparameter settings provides evidence of how the ANP is more expressive than the NP and can learn a wider range of functions. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Using the trained (A)NPs we tackle a toy Bayesian Optimisation (BO) problem, where the task is to find the minimum of test functions drawn from a GP prior. This is a proof-of-concept experiment showing the utility of being able to sample entire functions from the (A)NP and having accurate context reconstructions. See Appendix C for the details and an analysis of results. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2D Function regression on image data Image data can also be interpreted as being generated from a stochastic process (since there are dependencies between pixel values), and predicting the pixel values can be cast as a regression problem mapping a 2D pixel location $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ to its pixel intensity $\\mathbf { \\nabla } _ { \\mathbf { \\psi } _ { 3 } } \\mathbf { \\psi } _ { 2 } \\qquad \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\qquad \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\qquad \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 3 } \\qquad \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 3 } \\qquad \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 4 }$ $\\mathbf { \\Lambda } \\in \\mathbb { R } ^ { 1 }$ for greyscale, $\\in \\mathbb { R } ^ { 3 }$ for RGB). Each image corresponds to one realisation of the process sampled on a fixed 2 dimensional grid. We train the ANP on MNIST (LeCun et al., 1998) and $3 2 \\times 3 2$ CelebA (Liu et al., 2015) using the standard train/test split with up to 200 context/target points at training. For this application we explore the use of self-attentional layers in the encoder, stacking them as is done in Parmar et al. (2018). See Appendix D for experimental details. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On both datasets we show results of three different models: NP, ANP with multihead cross-attention in the deterministic path (Multihead ANP), and ANP with both multihead attention in the deterministic path and two layers of stacked self-attention in both the deterministic and latent paths (Stacked Multihead ANP). Figure 4a shows predictions of the full image (i.e. full target) with a varying number of random context pixels, from 10 to 1024 (full image) for a randomly selected image (see Appendix E for other images). For each we generate predictions that correspond to the mean of $p ( \\bar { \\pmb { y } } _ { T } | \\pmb { x } _ { T } , \\pmb { r } _ { C } , z )$ for three different samples of $\\bar { z } \\sim q ( z | s _ { C } )$ . The NP (left) gives reasonable predictions with a fair amount of diversity for fewer contexts, but the reconstructions of the whole image are not accurate, compared to Stacked Multihead ANP (right) where the reconstructions are indistinguishable from the original. The use of attention also helps achieve crisper inpaintings when the target pixels are filled in, enhancing the ANP’s ability to model less smooth 2D functions compared to the NP. The diversity in faces and digits obtained with different values of $_ { z }$ is apparent the different samples, providing evidence for the claim that $_ { z }$ can model global structure of the image, with one sample corresponding to one realisation of the data generating stochastic process. Similar conclusions hold for MNIST (see Appendix E) and for the full image prediction using the top half as context in Figure 5. In the latter task, note that the model has never been trained on more than 200 context points, yet it manages to generalise to when the context is of size 512 (half the image). ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/31f7034be116e24c1905201fe39547e6a1000932ab40174555f34fb1ac32309a.jpg",
+        "image_caption": [
+            "Figure 6: Mapping between different resolutions by the same model (with the same parameter values) as Stacked Multihead ANP in Figures 4a, 5b. The two rightmost columns show the results of baseline methods, namely linear and cubic interpolation to $2 5 6 \\times 2 5 6$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            820,
+            358
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            422,
+            825,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 4b verifies quantitatively that both Multihead and Stacked Multihead ANP give a much improved context reconstruction error compared to the NP. Similarly the NLL for the target points (that are not included in the context) is improved with multihead crossattention, showing small gains with stacked self-attention. However qualitatively, there are noticeable gains in crispness and global coherence when using stacked self-attention (see Appendix E). In Figure 7 we visualise each head of Multihead ANP for CelebA. We let the target pixel (cross) attend to all pixels, and see where each head of the attention focuses on. We colour-code the pixels with the top 20 weights per head, with intensity proportional to the attention weight. We can see that each head has different roles: the cyan head only looks at the target pixel and nothing else; the red head looks at a few pixels nearby; the green head looks at a larger region nearby; the yellow looks at the pixels on the column of the target; the orange looks at some band of the image; the purple head (interestingly) looks at the other side of the image, trying to exploit the symmetry of faces. We observe consistent behaviour in these heads for other target pixels (see Figure 16 of Appendix E). ",
+        "bbox": [
+            383,
+            529,
+            823,
+            792
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2fbb03c971104c2f9e6974bb1eb842001d5d27ad25d86c826990bc5fd9e119d5.jpg",
+        "image_caption": [
+            "Figure 7: Pixels attended to by each head of multihead attention in Multihead ANP given a target pixel. Each head is given a different colour and the target pixel is marked with a cross. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            551,
+            369,
+            703
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One other illustrative application of (A)NPs trained on images is that one can map images from one resolution to another, even if the model has only been trained on one resolution. Because the two dimensional $_ { \\textbf { \\em x } }$ (pixel locations) are modelled as real values that live in a continuous space, the model can predict the $\\textbf {  { y } }$ (pixel intensities) of any point in this space, and not just the grid of points that it was trained on. Hence using one grid as the context and a finer grid as the target, the model can map a given resolution to a higher resolution. This could, however, be problematic for NPs whose reconstructions can be inaccurate, so the prediction of the target resolution can look very different to the original image (see Figure 19 of Appendix E). The reconstructions of ANPs may be accurate enough to give reliable mappings between different resolutions. We show results for such mappings given by the same Stacked Multihead ANP (the same model used to produce Figures 4a, 5b) in Figure 6. On the left, we see that the ANP (trained on $3 2 \\times 3 2$ images) is capable of mapping low resolutions $4 \\times 4$ or $8 \\times 8$ ) to fairly realistic $3 2 \\times 3 2$ target outputs with some diversity for different values of $_ z$ (more diversity for the $4 \\times 4$ contexts as expected). Perhaps this performance is to be expected since the model has been trained on data that has $3 2 \\times 3 2$ resolution. The same model allows us to map to even higher resolutions, namely from the original $3 2 \\times 3 2$ images to $2 5 6 \\times 2 5 6$ , displayed on the right of the figure. We see that even though the model has never seen any images beyond the original resolution, the model learns a fairly realistic high resolution image with sharper edges compared to the baseline interpolation methods. Moreover, there is some evidence that it learns an internal representation of the appearance of faces, when for example it learns to fill in the eye even when the original image is too coarse to separate the iris (coloured part) from the sclera (white part) (e.g. top row image), a feature that is not possible with simple interpolation. See Figure 19 in Appendix E for larger versions of the images. ",
+        "bbox": [
+            383,
+            799,
+            823,
+            827
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            297
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For each of MNIST and CelebA, all qualitative plots in this section were given from the same model (with the same parameter values) for each attention mechanism, learned by optimising the loss in Equation (3) over random context pixels and random target pixels at each iteration. It is important to note that we do not claim the ANP to be a replacement of state of the art algorithms of image inpainting or super-resolution, and rather we show these image applications to highlight the flexibility of the ANP in modelling a wide family of conditional distributions. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            388
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            415,
+            344,
+            431
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The work related to NPs in the domain of Gaussian Processes, Meta-Learning, conditional latent variable models and Bayesian Learning have been discussed extensively in the original works of Garnelo et al. (2018a;b), hence we focus on works that are particularly relevant for ANPs. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            493
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Gaussian Processes (GPs) Returning to our motivation for using attention in NPs, there is a clear parallel between GP kernels and attention, in that they both give a measure of similarity between two points in the same domain. The use of attention in an embedding space that we explore is related to Deep Kernel Learning (Wilson et al., 2016) where a GP is applied to learned representations of data. Here, however, learning is still done in a GP framework by maximising the marginal likelihood. We reiterate that the training regimes of GPs and NPs are different, so a direct comparison between the methods is difficult. One possibility for comparison is to learn the GP via the training regime of NPs, namely updating the kernel hyperparameters at each iteration via one gradient step of the marginal likelihood on the mini-batch of data. However, this would still have a $\\mathsf { \\bar { O } } ( n ^ { 3 } )$ computational cost in the naive setting and may require kernel approximations. In general, the predictive uncertainties of GPs depend heavily on the choice of the kernel, whereas NPs learn predictive uncertainties directly from the data. Despite these drawbacks, GPs have the benefit of being consistent stochastic processes, and the covariance between the predictions at different $x$ -values and the marginal variance of each prediction can be expressed exactly in closed form, a feature that the current formulation of (A)NPs do not have. Variational Implicit Processes (VIP) (Ma et al., 2018) are also related to NPs, where VIP defines a stochastic process using the same decoder setup with a finite dimensional $_ { z }$ . Here, however, the process and its posterior given observed data are both approximated by a GP and learned via a generalisation of the Wake-Sleep algorithm (Hinton et al., 1995). ",
+        "bbox": [
+            174,
+            501,
+            825,
+            751
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Meta-Learning (A)NPs can be seen as models that do few-shot learning, although this is not the focus of our work. Given input-output pairs drawn from a new function at test time, one can reason about this function by looking at the predictive distribution conditioning on these input-output pairs. There is a plethora of works in few-shot classification, of which Vinyals et al. (2016); Snell et al. (2017); Santoro et al. (2016) use attention to locate the relevant observed image/prototype given a query image. Attention has also been used for tasks in Meta-RL such as continuous control and visual navigation (Mishra et al., 2018). Few-shot density estimation using attention has also been explored extensively in numerous works (Rezende et al., 2016; Reed et al., 2017; Bornschein et al., 2017; Bartunov & Vetrov, 2018). Especially relevant are the Neural Statistician (Edwards & Storkey, 2017) and the Variational Homoencoder (Hewitt et al., 2018) who have a similar permutation invariant encoder (that outputs summaries of a data set), but use local latents on top of a global latent. For ANPs, we look at the less-explored regression setting. The authors of Vfunc (Bachman et al., 2018) also explore regression on a toy 1D domain, using a similar setup to NPs but optimising an approximation to the entropy of the latent function, without any attention mechanisms. Multitask learning has also been tackled in the GP literature by various works (Teh et al., 2005; Bonilla et al., 2008; Alvarez et al., 2012; Dai et al., 2017). ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Generative Query Networks (Eslami et al., 2018; Kumar et al., 2018) are models for spatial prediction that render a frame of a scene given a viewpoint. Their model corresponds to a special case of NPs where the $_ { \\textbf { \\em x } }$ are viewpoints and the $\\textbf {  { y } }$ are frames of a scene. Rosenbaum et al. (2018) apply the GQN to the task of 3D localisation with an attention mechanism, but attention is applied to patches of context frames $( y )$ instead of a parametric representation of viewpoints $( { \\pmb x } )$ . Note that in our work the targets attend to the contexts via the $_ { \\textbf { \\em x } }$ . ",
+        "bbox": [
+            174,
+            166,
+            825,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            271,
+            468,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have proposed ANPs, which augment NPs with attention to resolve the fundamental problem of underfitting. We have shown that this greatly improves the accuracy of predictions in terms of context and target NLL, results in faster training, and expands the range of functions that can be modelled. There is a wide scope of future work for ANPs. Regarding model architecture, one way of incorporating cross-attention into the latent path and modelling the dependencies across the resulting local latents is to also have a global latent, much like the setup of the Neural Statistician but translated to the regression setting. An interesting further application would be to train ANPs on text data, enabling them to fill in the blanks in a stochastic manner. For the image application, the Image Transformer (ImT) (Parmar et al., 2018) has some interesting connections with ANPs: its local self-attention used to predict consecutive pixel blocks from previous blocks has parallels with how our model attends to context pixels to predict target pixels. Replacing the MLP in the decoder of the ANP with self-attention across the target pixels, we have a model that closely resembles an ImT defined on arbitrary orderings of pixels. This is in contrast to the original ImT, which presumes a fixed ordering and is trained autoregressively. We plan to equip ANPs with self-attention in the decoder, and see how far their expressiveness can be extended. In this setup, however, the targets will affect each other’s predictions, so the ordering and grouping of the targets will become important. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            541,
+            326,
+            554
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Ali Razavi for his advice on implementing multihead attention, and Michael Figurnov for helpful discussion. ",
+        "bbox": [
+            174,
+            565,
+            823,
+            593
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            285,
+            630
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mauricio A Alvarez, Lorenzo Rosasco, Neil D Lawrence, et al. Kernels for vector-valued functions: A review. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Machine Learning, 4(3):195–266, 2012. ",
+        "bbox": [
+            178,
+            638,
+            820,
+            667
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Philip Bachman, Riashat Islam, Alessandro Sordoni, and Zafarali Ahmed. Vfunc: a deep generative model for functions. arXiv preprint arXiv:1807.04106, 2018. ",
+        "bbox": [
+            173,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            714,
+            823,
+            744
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Bartunov and Dmitry P Vetrov. Fast adaptation in generative models with generative matching networks. In AISTATS, 2018. ",
+        "bbox": [
+            173,
+            753,
+            823,
+            782
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Edwin V Bonilla, Kian M Chai, and Christopher Williams. Multi-task gaussian process prediction. In NIPS, 2008. ",
+        "bbox": [
+            173,
+            791,
+            821,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jorg Bornschein, Andriy Mnih, Daniel Zoran, and Danilo Jimenez Rezende. Variational memory ¨ addressing in generative models. In NIPS, 2017. ",
+        "bbox": [
+            171,
+            830,
+            823,
+            859
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhenwen Dai, Mauricio A Alvarez, and Neil Lawrence. Efficient modeling of latent information in ´ supervised learning using gaussian processes. In NIPS, 2017. ",
+        "bbox": [
+            174,
+            869,
+            823,
+            898
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Harrison Edwards and Amos Storkey. Towards a neural statistician. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            909,
+            722,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "SM Ali Eslami, Danilo Jimenez Rezende, Frederic Besse, Fabio Viola, Ari S Morcos, Marta Garnelo, Avraham Ruderman, Andrei A Rusu, Ivo Danihelka, Karol Gregor, et al. Neural scene representation and rendering. Science, 360(6394):1204–1210, 2018. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marta Garnelo, Dan Rosenbaum, Christopher Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo Rezende, and SM Ali Eslami. Conditional neural processes. In ICML, 2018a. ",
+        "bbox": [
+            176,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marta Garnelo, Jonathan Schwarz, Dan Rosenbaum, Fabio Viola, Danilo J Rezende, SM Eslami, and Yee Whye Teh. Neural processes. In ICML Workshop on Theoretical Foundations and Applications of Deep Generative Models, 2018b. ",
+        "bbox": [
+            173,
+            205,
+            825,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Supervised sequence labelling with recurrent neural networks. Springer, 2012. ",
+        "bbox": [
+            169,
+            257,
+            779,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Luke B Hewitt, Maxwell I Nye, Andreea Gane, Tommi Jaakkola, and Joshua B Tenenbaum. The variational homoencoder: Learning to learn high capacity generative models from few examples. In UAI, 2018. ",
+        "bbox": [
+            174,
+            280,
+            823,
+            324
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Peter Dayan, Brendan J Frey, and Radford M Neal. The” wake-sleep” algorithm for unsupervised neural networks. Science, 268(5214):1158–1161, 1995. ",
+        "bbox": [
+            176,
+            332,
+            823,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In ICLR, 2015. ",
+        "bbox": [
+            176,
+            369,
+            738,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014. ",
+        "bbox": [
+            171,
+            393,
+            750,
+            409
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ananya Kumar, SM Eslami, Danilo J Rezende, Marta Garnelo, Fabio Viola, Edward Lockhart, and Murray Shanahan. Consistent generative query networks. arXiv preprint arXiv:1807.02033, 2018. ",
+        "bbox": [
+            176,
+            417,
+            825,
+            459
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            171,
+            468,
+            823,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Z. Liu, P. Luo, X. Wang, and X. Tang. Deep learning face attributes in the wild. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3730–3738, 2015. ",
+        "bbox": [
+            174,
+            506,
+            821,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chao Ma, Yingzhen Li, and Jose Miguel Hern ´ andez-Lobato. Variational implicit processes. ´ arXiv preprint arXiv:1806.02390, 2018. ",
+        "bbox": [
+            171,
+            544,
+            823,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. A simple neural attentive metalearner. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            580,
+            823,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Łukasz Kaiser, Noam Shazeer, and Alexander Ku. Image transformer. In ICML, 2018. ",
+        "bbox": [
+            169,
+            618,
+            821,
+            647
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed, Yutian Chen, Thomas Paine, Aaron van den Oord, SM Eslami, Danilo Rezende, Oriol ¨ Vinyals, and Nando de Freitas. Few-shot autoregressive density estimation: Towards learning to learn distributions. arXiv preprint arXiv:1710.10304, 2017. ",
+        "bbox": [
+            176,
+            656,
+            825,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In ICML, pp. 1278–1286, 2014. ",
+        "bbox": [
+            174,
+            707,
+            821,
+            737
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, Ivo Danihelka, Karol Gregor, and Daan Wierstra. Oneshot generalization in deep generative models. arXiv preprint arXiv:1603.05106, 2016. ",
+        "bbox": [
+            174,
+            744,
+            823,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Rosenbaum, Frederic Besse, Fabio Viola, Danilo J Rezende, and SM Eslami. Learning models for visual 3d localization with implicit mapping. arXiv preprint arXiv:1807.03149, 2018. ",
+        "bbox": [
+            176,
+            781,
+            823,
+            813
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Oneshot learning with memory-augmented neural networks. arXiv preprint arXiv:1605.06065, 2016. ",
+        "bbox": [
+            173,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In NIPS, 2017. ",
+        "bbox": [
+            174,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yee Whye Teh, Matthias Seeger, and Michael Jordan. Semiparametric latent factor models. In AISTATS, 2005. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "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 NIPS, 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Gordon Wilson, Zhiting Hu, Ruslan Salakhutdinov, and Eric P Xing. Deep kernel learning. In Artificial Intelligence and Statistics, pp. 370–378, 2016. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            234,
+            264,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A ARCHITECTURAL DETAILS FOR (A)NP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            268,
+            531,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We show the architectural details of the NP and the Multihead ANP models used for the 1D and 2D regression experiments below in Figure 8. All MLPs have relu non-linearities except the final layer, which has no non-linearity. The latent path outputs $\\mu _ { z } , \\omega _ { z } \\in \\mathbb { R } ^ { d }$ , which parameterises $q ( z | \\dot { s _ { C } } ) = N ( z | \\mu _ { z } , 0 . 1 + 0 . 9 \\sigma ( \\omega _ { z } ) )$ where $\\sigma$ is the sigmoid function. Similarly the decoder outputs $\\mu _ { y } , \\omega _ { y }$ , which parameterises $p ( \\check { \\pmb { y } } _ { i } | \\mathbf { z } , \\mathbf { x } _ { C } , \\pmb { y } _ { C } , \\pmb { x } _ { i } ) = \\mathcal { N } ( \\pmb { y } _ { i } | \\mu _ { y } , 0 . 1 + 0 . 9 f ( \\omega _ { y } ) )$ where $f$ is the softplus function. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            383
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The 1D regression experiments use the basic formulation of multihead cross-attention (denoted M ultihead1) in Figure 8, whereas the 2D regression experiments uses a form of multihead crossattention used in the Image Transformer (Parmar et al., 2018). The only difference is that we do not use dropout, to limit the stochasticity of the model to the latent $z$ . ",
+        "bbox": [
+            174,
+            390,
+            825,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Self-attention uses the same architecture as cross-attention but with $k _ { i } = v _ { i }$ , $q = k _ { j }$ for each $j \\in C$ , to output $| C |$ representations given $| C |$ input representations. Since the self-attention module has the same number of inputs and outputs, it can be stacked. We stack 2 layers of self-attention for Stacked Multihead ANP in the 2D Image regression experiments. Stacking more layers did not lead to noticeable gains qualitatively and quantitatively. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B EXPERIMENTAL DETAILS OF 1D FUNCTION REGRESSION EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            542,
+            789,
+            559
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For the squared exponential kernel of the data generating GP, we use a length scale $l = 0 . 6$ and kernel scale $\\sigma _ { f } ^ { 2 } = \\mathrm { \\bar { 1 } }$ for the fixed kernel hyperparameter experiments. For the random kernel hyperparameter case, we sample $l \\sim U [ 0 . 1 , 0 . 6 ]$ , $\\sigma _ { f } \\sim U [ 0 . 1 , 1 ]$ . For both, the likelihood noise is $\\sigma _ { n } = 0 . 0 2$ . We use a batch size of 16 — in the fixed hyperparameter setting, we draw 16 curves from a GP with these hyperparameters, and in the random hyperparameter setting, we sample 16 random values of hyperparameters and draw a curve from GPs with each of these hyperparameters. We use the Adam Optimiser (Kingma & Ba, 2015) with a fixed learning rate of 5e-5 and Tensorflow defaults for the other hyperparameters. We use one sample of $q ( z | \\mathbf { \\mathit { s } } _ { C } )$ to form a MC estimate of the loss in Equation (3) during training and evaluation. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For NP, $d$ is varied between $\\{ 1 2 8 , 2 5 6 , 5 1 2 , 1 0 2 4 \\}$ whereas for ANP we always use $d = 1 2 8$ . ",
+        "bbox": [
+            166,
+            708,
+            781,
+            723
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/8cf6eafd11824217a59e31319e0e8dec929cdfc6a5a2e934999ca93095b32568.jpg",
+        "image_caption": [
+            "Figure 8: The model architecture for NP and ANP for both 1D and 2D regression. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            60,
+            818,
+            888
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL FIGURES FOR 1D REGRESSION ON GP DATA ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            684,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/21a7bfa76c05b01245d704f5574832eab8a49f6f8d18829dba783e77e31bd953.jpg",
+        "image_caption": [
+            "Figure 9: Same as right of Figure 3 but also comparing against the oracle GP from which context was drawn. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            141,
+            825,
+            276
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Figure 9 we also compare the trained (A)NP models against the oracle GP from which the contexts were drawn. We see that the predictions Multihead ANP is notably closer to that of the oracle GP than the NP, but still underestimates the predictive variance. One possible explanation for this is that variational inference (used for learning the ANP) usually leads to underestimates of predictive variance. It would be interesting to investigate how this issue can be addressed. ",
+        "bbox": [
+            173,
+            335,
+            825,
+            406
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/e8424775eaa265e1b44fe1b2a4c1bf534e70de9b55d46acd462f9dd68107c120.jpg",
+        "image_caption": [
+            "Figure 10: Same as Figure 3 but for fixed kernel hyperparameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            422,
+            823,
+            608
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The right of Figure 10 shows the conditional distributions for fixed kernel hyperparameters (with contexts drawn from the GP with these kernel hyperparameters), with highly non-smooth behaviour for dot-product attention as with the random kernel hyperparameter case. This behaviour seems to arise when the dot-product attention collapses to the local minimum of learning to be a nearest neighbour predictor (with one entry of the softmax becoming saturated), hence giving good reconstructions but poor interpolations between context points. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            734
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/e1d944521282fff47edf9afec80b595c135a710e7bd7d3d10e1f694f45a4d603.jpg",
+        "image_caption": [
+            "Figure 11: KL term in NP loss throughout training for data generated from a GP with fixed (left) and random (right) kernel hyperparameters, using the same colour scheme as Figure 10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            750,
+            725,
+            881
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 11 shows how the KL term in the (A)NP loss differs between training on the fixed kernel hyperparameter GP data and on the random kernel hyperparameter GP data. In the fixed hyperparameter case, the KL for multihead ANP quickly goes to 0, indicating that the model deems the deterministic path sufficient to make accurate predictions. However in the random hyperparameter case, there is added variation in the data, hence the attention gives a non-zero KL and uses the latents to model the uncertainty in the realisation of the stochastic process given some context points. In other words, given a context set, the model believes that there are multiple realisations of the stochastic process that can explain these contexts well, hence uses the latents to model this variation. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            228
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/0ee4c67b8ede6dd2fa6e6dbdb2aeee44dfdeeb7504d69cfebe1f20e561cd29de.jpg",
+        "image_caption": [
+            "Figure 12: Simple and cumulative regret for BO. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            258,
+            385,
+            489
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Using the same (A)NPs trained on the 1D GP data, we tackle the BO problem of finding the minimum of test functions drawn from a GP prior. We compare ANPs trained with different attention mechanisms to an oracle GP for which we set the kernel hyperparameters to their true value. (A)NPs can be used for BO by considering all previous function evaluations as context points, thus obtaining an informed surrogate of the target function. While other choices are possible, we use Thompson sampling to drawing a simple function from the surrogate and acting according to its minimal predicted value. We show results averaged over 100 test functions in Figure 12. We can see that the simple regret (the difference between the predicted and true minimum) is consistently smallest for a NP with multihead attention, approaching the oracle GP. Among the NPs, the slope of the cumulative regret (simple regret summed up to given iteration) decreases most rapidly for multihead, indicating that previous function evaluations are being put to good use for subsequent predictions of the function minimum. The reason that the cumulative regret is initially lower than the oracle GP is a consequence of under-exploration, due to the uncertainties of ANP away from the context being smaller than that of the oracle GP. ",
+        "bbox": [
+            405,
+            234,
+            823,
+            526
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D EXPERIMENTAL DETAILS OF 2D IMAGE REGRESSION EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            559,
+            759,
+            575
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Analogous to the 1D experiments, we take random pixels of a given image at training as targets, and select a subset of this as contexts, again choosing the number of contexts and targets randomly $\\mathrm { \\Delta } n \\sim U [ 3 , 2 0 0 ]$ , $m \\sim n + U [ 0 , 2 0 0 - \\bar { n } ] )$ . The $_ { \\textbf { \\em x } }$ are rescaled to $[ - 1 , 1 ]$ and the $\\textbf {  { y } }$ are rescaled to $[ - 0 . 5 , 0 . 5 ]$ . We use a batch size of 16 for both MNIST and CelebA, i.e. use 16 randomly selected images for each batch. We use a learning rate of 5e-5 and 4e-5 respectively for MNIST and CelebA using the Adam optimiser with Tensorflow defaults for the other hyperparameters. The stacked self-attention architecture is the same as in the Image Transformer (Parmar et al., 2018), except that we do not use Dropout to restrict the stochasticity of the model to the global latent $_ z$ , and do not use positional embeddings of the pixels. We use the same architecture for both Mnist and CelebA, and highlight that little tuning has been done regarding the architectural hyperparameters. We again use one sample of $q ( \\boldsymbol { z } | \\boldsymbol { s } _ { C } )$ to form a MC estimate of the loss in Equation (3) during training and evaluation. ",
+        "bbox": [
+            174,
+            598,
+            825,
+            765
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E ADDITIONAL FIGURES FOR 2D IMAGE REGRESSION ON MNIST AND CELEBA ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            797,
+            776,
+            830
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We can see visually that the NP overestimates the predictive variance by looking at the plot of the standard deviation (bottom row) of Figure 13a. We see that the original NP shows noticeable uncertainty around the edges of the reconstruction for all context sets, whereas for the NP with attention, the uncertainty is reduced significantly as you increase the number of contexts until it almost disappears for the full context. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/949bac79d4cddf0a8c5099f1f1156af3cfcea2a1919ca9f872c00c6e9af89d59.jpg",
+        "image_caption": [
+            "(b) Same as Figure 4b but for MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            825,
+            319
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Same as Figure 4a but for MNIST. ",
+        "bbox": [
+            276,
+            315,
+            501,
+            329
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/28eab2cdc533d57564d926bf752144c5c69d007c242554d1a75deeeaa608b8af.jpg",
+        "image_caption": [
+            "Figure 13: Qualitative and quantitative results of different attention mechanisms on test set for 2D MNIST function regression. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            390,
+            828,
+            559
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/4e47e791cd12a926ebc2e0d7d9f86ef163f653dd9268b3723fecc066a504185c.jpg",
+        "image_caption": [
+            "Figure 14: More MNIST reconstruction of full image from top half.499th export - 5e6 iter, xid=1650728, num_contexts=200, lr=5e-4 ",
+            "Figure 15: More CelebA reconstruction of full image from top half. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            583,
+            828,
+            751
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "From Figures 14 and 15 we see that Stacked Multihead ANP improves results significantly over Multihead ANP, giving sharper images with better global coherence even in the case where the face isn’t axis-aligned (see Figure 15a). ",
+        "bbox": [
+            174,
+            796,
+            825,
+            838
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Note that in Figure 7, the contexts contain the target, relying on the cyan head would be enough to give an accurate prediction, but the different roles of these heads also hold in the case where the target is disjoint from the context. This is shown in Figure 16 where the context is disjoint from the target. Here all heads become useful for the target prediction. ",
+        "bbox": [
+            174,
+            845,
+            825,
+            901
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/c1ca98b476ba0edb8716ab6204cf13514d1468c0603f38bc6b88a6881cf98dd7.jpg",
+        "image_caption": [
+            "Figure 16: Visualisation of pixels attended by each head of multihead attention in the NP given a target pixel and a separate context of 100 random pixels. Each head is given a different colour (consistent with the colours in Figure 7 and the target pixel is marked by a cross. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            166,
+            727,
+            343
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f96913df6f84f7596017ea6090da7387f53f286daf6efa445a107920678ff8c.jpg",
+        "image_caption": [
+            "Figure 17: Same as Figure 4a but for a different image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            545,
+            821,
+            818
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/779adeb3f18e4efcc71266c32815e77ce550a7c399631f49dc312aabd8143e42.jpg",
+        "image_caption": [
+            "Figure 18: Same as Figure 4a but for a different image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            359,
+            823,
+            631
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/8df6ea84c309649d04e7d3c77526511cc065c016c2daa79ab93190f291dc161f.jpg",
+        "image_caption": [
+            "Figure 19: Mapping from $3 2 \\times 3 2$ to $2 5 6 \\times 2 5 6$ for different images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            138,
+            823,
+            871
+        ],
+        "page_idx": 17
+    }
+]

parse/train/SkeXehR9t7/SkeXehR9t7.md

@@ -0,0 +1,335 @@
+# GRAPH2SEQ: GRAPH TO SEQUENCE LEARNING WITH ATTENTION-BASED NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The celebrated Sequence to Sequence learning (Seq2Seq) technique and its numerous variants achieve excellent performance on many tasks. However, many machine learning tasks have inputs naturally represented as graphs; existing Seq2Seq models face a significant challenge in achieving accurate conversion from graph form to the appropriate sequence. To address this challenge, we introduce a general end-to-end graph-to-sequence neural encoder-decoder architecture that maps an input graph to a sequence of vectors and uses an attention-based LSTM method to decode the target sequence from these vectors. Our method first generates the node and graph embeddings using an improved graph-based neural network with a novel aggregation strategy to incorporate edge direction information in the node embeddings. We further introduce an attention mechanism that aligns node embeddings and the decoding sequence to better cope with large graphs. Experimental results on bAbI, Shortest Path, and Natural Language Generation tasks demonstrate that our model achieves state-of-the-art performance and significantly outperforms existing graph neural networks, Seq2Seq, and Tree2Seq models; using the proposed bi-directional node embedding aggregation strategy, the model can converge rapidly to the optimal performance.
+
+# 1 INTRODUCTION
+
+The celebrated Sequence to Sequence learning (Seq2Seq) technique and its numerous variants achieve excellent performance on many tasks such as Neural Machine Translation (Bahdanau et al., 2014; Gehring et al., 2017), Natural Language Generation (NLG) (Song et al., 2017) and Speech Recognition(Zhang et al., 2017). Most of the proposed Seq2Seq models can be viewed as a family of encoder-decoders (Sutskever et al., 2014; Cho et al., 2014; Bahdanau et al., 2014), where an encoder reads and encodes a source input in the form of sequences into a continuous vector representation of fixed dimension, and a decoder takes the encoded vectors and outputs a target sequence. Many other enhancements including Bidirectional Recurrent Neural Networks (Bi-RNN) (Schuster & Paliwal, 1997) or Bidirectional Long Short-Term Memory Networks (Bi-LSTM) (Graves & Schmidhuber, 2005) as encoder, and attention mechanism (Bahdanau et al., 2014; Luong et al., 2015), have been proposed to further improve its practical performance for general or domain-specific applications.
+
+Despite their flexibility and expressive power, a significant limitation with the Seq2Seq models is that they can only be applied to problems whose inputs are represented as sequences. However, the sequences are probably the simplest structured data, and many important problems are best expressed with a more complex structure such as graphs that have more capacity to encode complicated pair-wise relationships in the data. For example, one task in NLG applications is to translate a graph-structured semantic representation such as Abstract Meaning Representation to a text expressing its meaning (Banarescu et al., 2013). In addition, path planning for a mobile robot (Hu & Yang, 2004) and path finding for question answering in bAbI task (Li et al., 2015) can also be cast as graph-to-sequence problems.
+
+On the other hand, even if the raw inputs are originally expressed in a sequence form, it can still benefit from the enhanced inputs with additional information (to formulate graph inputs). For example, for semantic parsing tasks (text-to-AMR or text-to-SQL), they have been shown better performance by augmenting the original sentence sequences with other structural information such as dependency parsing trees (Pust et al., 2015). Intuitively, the ideal solution for graph-to-sequence tasks is to build a more powerful encoder which is able to learn the input representation regardless of its inherent structure.
+
+To cope with graph-to-sequence problems, a simple and straightforward approach is to directly convert more complex structured graph data into sequences (Iyer et al., 2016; Gomez-Bombarelli´ et al., 2016; Liu et al., 2017), and apply sequence models to the resulting sequences. However, the Seq2Seq model often fails to perform as well as hoped on these problems, in part because it inevitably suffers significant information loss due to the conversion of complex structured data into a sequence, especially when the input data is naturally represented as graphs. Recently, a line of research efforts have been devoted to incorporate additional information by extracting syntactic information such as the phrase structure of a source sentence (Tree2seq) (Eriguchi et al., 2016), by utilizing attention mechanisms for input sets (Set2seq)(Vinyals et al., 2015a), and by encoding sentences recursively as trees (Socher et al., 2010; Tai et al., 2015). Although these methods achieve promising results on certain classes of problems, most of the presented techniques largely depend on the underlying application and may not be able to generalize to a broad class of problems in a general way.
+
+To address this issue, we propose Graph2Seq, a novel attention-based neural network architecture for graph-to-sequence learning. The Graph2Seq model follows the conventional encoder-decoder approach with two main components, a graph encoder and a sequence decoder. The proposed graph encoder aims to learn expressive node embeddings and then to reassemble them into the corresponding graph embeddings. To this end, inspired by a recent graph representation learning method (Hamilton et al., 2017a), we propose an inductive graph-based neural network to learn node embeddings from node attributes through aggregation of neighborhood information for directed and undirected graphs, which explores two distinct aggregators on each node to yield two representations that are concatenated to form the final node embedding. In addition, we further design an attention-based RNN sequence decoder that takes the graph embedding as its initial hidden state and outputs a target prediction by learning to align and translate jointly based on the context vectors associated with the corresponding nodes and all previous predictions. Our code and data are available at https://github.com/anonymous/Graph2Seq.
+
+Graph2Seq is simple yet general and is highly extensible where its two building blocks, graph encoder and sequence decoder, can be replaced by other models such as Graph Convolutional (Attention) Networks (Kipf & Welling, 2016; Velickovic et al., 2017) or their extensions (Schlichtkrull et al., 2017), and LSTM (Hochreiter & Schmidhuber, 1997). We highlight three main contributions of this paper as follows:
+
+• We propose a new attention-based neural networks paradigm to elegantly address graphto-sequence learning problems that learns a mapping between graph-structured inputs to sequence outputs, which current Seq2Seq and Tree2Seq may be inadequate to handle. We propose a novel graph encoder to learn a bi-directional node embeddings for directed and undirected graphs with node attributes by employing various aggregation strategies, and to learn graph-level embedding by exploiting two different graph embedding techniques. Equally importantly, we present an attention mechanism to learn the alignments between nodes and sequence elements to better cope with large graphs. Experimental results show that our model achieves state-of-the-art performance on three recently introduced graph-to-sequence tasks and significantly outperforms existing graph neural networks, Seq2Seq, and Tree2Seq models.
+
+# 2 RELATED WORK
+
+Our model draws inspiration from the research fields of graph representation learning, neural networks on graphs, and neural encoder-decoder models.
+
+Graph Representation Learning. Graph representation learning has been proven extremely useful for a broad range of the graph-based analysis and prediction tasks (Hamilton et al., 2017b; Goyal & Ferrara, 2017). The main goal for graph representation learning is to learn a mapping that embeds nodes as points in a low-dimensional vector space. These representation learning approaches can be roughly categorized into two classes including matrix factorization-based algorithms and random-walk based methods. A line of research learn the embeddings of graph nodes through matrix factorization (Roweis & Saul, 2000; Belkin & Niyogi, 2002; Ahmed et al., 2013; Cao et al., 2015; Ou et al., 2016). These methods directly train embeddings for individual nodes of training and testing data jointly and thus inherently transductive. Another family of work is the use of random walk-based methods to learn low-dimensional embeddings of nodes by exploring neighborhood information for a single large-scale graph (Duran & Niepert, 2017; Hamilton et al., 2017a; Tang et al., 2015; Grover & Leskovec, 2016; Perozzi et al., 2014; Velickovic et al., 2017).
+
+GraphSAGE (Hamilton et al., 2017a) is such a technique that learns node embeddings through aggregation from a node local neighborhood using node attributes or degrees for inductive learning, which has better capability to generate node embeddings for previously unseen data. Our graph encoder is an extension to GraphSAGE with two major distinctions. First, we non-trivially generalize it to cope with both directed and undirected graphs by splitting original node into forward nodes (a node directs to) and backward nodes (direct to a node) according to edge direction and applying two distinct aggregation functions to these types of nodes. Second, we exploit two different schemes (pooling-based and supernode-based) to reassemble the learned node embeddings to generate graph embedding, which is not studied in GraphSAGE. We show the advantages of our graph encoder over GraphSAGE in our experiments.
+
+Neural Networks on Graphs. Over the past few years, there has been a surge of approaches that seek to learn the representations of graph nodes, or entire (sub)graphs, based on Graph Neural Networks (GNN) that extend well-known network architectures including RNN and CNN to graph data (Gori et al., 2005; Scarselli et al., 2009; Li et al., 2015; Bruna et al., 2013; Duvenaud et al., 2015; Niepert et al., 2016; Defferrard et al., 2016; Yang et al., 2016; Kipf & Welling, 2016; Chen et al., 2018). A line of research is the neural networks that operate on graphs as a form of RNN (Gori et al., 2005; Scarselli et al., 2009), and recently extended by Li et al. (Li et al., 2015) by introducing modern practices of RNN (using of GRU updates) in the original GNN framework. Another important stream of work that has recently drawn fast increasing interest is graph convolutional networks (GCN) built on spectral graph theory, introduced by Bruna et al. (2013) and then extended by Defferrard et al. (2016) with fast localized convolution. Most of these approaches cannot scale to large graphs, which is improved by using a localized first-order approximation of spectral graph convolution (Kipf & Welling, 2016) and further equipping with important sampling for deriving a fast GCN (Chen et al., 2018).
+
+The closely relevant work to our graph encoder is GCN (Kipf & Welling, 2016), which is designed for semi-supervised learning in transductive setting that requires full graph Laplacian to be given during training and is typically applicable to a single large undirected graph. An extension of GCN can be shown to be mathematically related to one variant of our graph encoder on undirected graphs. We compare the difference between our graph encoder and GCN in our experiments. Another relevant work is gated graph sequence neural networks (GGS-NNs) (Li et al., 2015). Although it is also designed for outputting a sequence, it is essentially a prediction model that learns to predict a sequence embedded in graph while our approach is a generative model that learns a mapping between graph inputs and sequence outputs. A good analogy that can be drawn between our proposed Graph2Seq and GGS-NNs is the relationship between convolutional Seq2Seq and RNN.
+
+Neural Encoder-Decoder Models. One of the most successful encoder-decoder architectures is the sequence to sequence learning (Sutskever et al., 2014; Cho et al., 2014; Bahdanau et al., 2014; Luong et al., 2015; Gehring et al., 2017), which are originally proposed for machine translation. Recently, the classical Seq2Seq model and its variants have been applied to several applications in which these models can perform mappings from objects to sequences, including mapping from an image to a sentence (Vinyals et al., 2015c), models for computation map from problem statements of a python program to their solutions (the answers to the program) (Zaremba & Sutskever, 2014), the traveling salesman problem for the set of points (Vinyals et al., 2015b) and deep generative model for molecules generation from existing known molecules in drug discovery. It is easy to see that the objects that are mapped to sequences in the listed examples are often naturally represented in graphs rather than sequences.
+
+Recently, many research efforts and the key contributions have been made to address the limitations of Seq2Seq when dealing with more complex data, that leverage external information using specialized neural models attached to underlying targeted applications, including Tree2Seq (Eriguchi et al., 2016), Set2Seq (Vinyals et al., 2015a), Recursive Neural Networks (Socher et al., 2010), and Tree
+
+![](images/ebaaeb200039f192b3d48bb9edba8682351d9f9f7c8d4576d5af3eab617c0a45.jpg)  
+Figure 1: The framework of Graph2Seq model.
+
+Structured LSTM (Tai et al., 2015). Due to more recent advances in graph representations and graph convolutional networks, a number of research has investigated to utilize various GNN to improve the performance over the Seq2Seq models in the domains of machine translation and graph generation (Bastings et al., 2017; Simonovsky & Komodakis, 2018; Li et al., 2018). There are several distinctions between these work and ours. First, our model is the first general-purpose encoderdecoder architecture for graph-to-sequence learning that is applicable to different applications while the aforementioned research has to utilize domain-specific information. Second, we design our own graph embedding techniques for our graph decoder while most of other work directly apply existing GNN to their problems.
+
+# 3 GRAPH-TO-SEQUENCE MODEL
+
+As shown in Figure 1, our graph-to-sequence model includes a graph encoder, a sequence decoder, and a node attention mechanism. Following the conventional encoder-decoder architecture, the graph encoder first generates node embeddings, and then constructs graph embeddings based on the learned node embeddings. Finally, the sequence decoder takes both the graph embeddings and node embeddings as input and employs attention over the node embeddings whilst generating sequences. In this section, we first introduce the node-embedding generation algorithm which derives the bi-directional node embeddings by aggregating information from both forward and backward neighborhoods of a node in a graph. Upon these node embeddings, we propose two methods for generating graph embeddings capturing the whole-graph information.
+
+# 3.1 NODE EMBEDDING GENERATION
+
+Inspired by Hamilton et al. (2017a), we design a new inductive node embedding algorithm that generates bi-directional node embeddings by aggregating information from a node local forward and backward neighborhood within $K$ hops for both directed and undirected graphs. In order to make it more clear, we take the embedding generation process for node $v \in \mathcal V$ as an example to explain our node embedding generation algorithm:1
+
+1) We first transform node $v$ ’s text attribute to a feature vector, $\mathbf { a } _ { v }$ , by looking up the embedding matrix $\mathbf { W } _ { e }$ . Note that for some tasks where $v$ ’s text attribute may be a word sequence, one neural network layer, such as an LSTM layer, could be additionally used to generate $\mathbf { a } _ { v }$ .   
+2) We categorize the neighbors of $v$ into forward neighbors, $\mathcal { N } _ { \vdash } ( v )$ , and backward neighbors, $\mathcal { N } _ { - 1 } ( v )$ , according to the edge direction. In particular, $\mathcal { N } _ { \vdash } ( v )$ returns the nodes that $v$ directs to and $\mathcal { N } _ { \mathbb { - } } ( v )$ returns the nodes that direct to $v$ ;   
+3) We aggregate the forward representations of $v$ ’s forward neighbors $\{ \mathbf { h } _ { u \vdash } ^ { k - 1 } , \forall u \in \mathcal { N } _ { \vdash } ( v ) \}$ into a single vector, $\mathbf { h } _ { \mathcal { N } _ { \mathrm { i } } ( v ) } ^ { k }$ , where $k { \in } \{ 1 , . . . , K \}$ is the iteration index. In our experiments, we find that the aggregator choice, AGGREGAT $\mathbb { E } _ { k } ^ { \vdash }$ , may heavily affect the overall performance and we will discuss it later. Notice that at iteration $k$ , this aggregator only uses the representations generated
+
+at $k - 1$ . The initial forward representation of each node is its feature vector calculated in step (1);
+
+4) We concatenate $v$ ’s current forward representation, hk−1v\` , with the newly generated neighborhood vector, $\mathbf { h } _ { \mathcal { N } _ { \mathrm { i } } ( v ) } ^ { k }$ . This concatenated vector is fed into a fully connected layer with nonlinear activation function $\sigma$ , which updates the forward representation of $v$ , $\mathbf { h } _ { v \vdash } ^ { k }$ , to be used at the next iteration;   
+5) We update the backward representation of $v$ , $\mathbf { h } _ { v - 1 } ^ { k }$ , using the similar procedure as introduced in step (3) and (4) except that operating on the backward representations instead of the forward representations;   
+6) We repeat steps $( 3 ) { \sim } ( 5 )$ $K$ times, and the concatenation of the final forward and backward representation is used as the final bi-directional representation of $v$ . Since the neighbor information from different hops may have different impact on the node embedding, we learn a distinct aggregator at each iteration.
+
+Aggregator Architectures. Since a node neighbors have no natural ordering, the aggregator function should be invariant to permutations of its inputs, ensuring that our neural network model can be trained and applied to arbitrarily ordered node-neighborhood feature sets. In practice, we examined the following three aggregator functions:
+
+Mean aggregator: This aggregator function takes the element-wise mean of the vectors in $\{ \mathbf { h } _ { u \vdash } ^ { k - 1 }$ $\forall u \in \mathcal { N } _ { \vdash } ( v ) \}$ and $\{ \mathbf h _ { u \dash } ^ { k - 1 } , \forall u \in \mathcal { N } _ { \sf \tilde { \sf { M } } } ( v ) \}$ .
+
+LSTM aggregator: Similar to (Hamilton et al., 2017a), we also examined a more complex aggregator based on an Long Short Term Memory (LSTM) architecture. Note that LSTMs are not inherently symmetric since they process their inputs sequentially. We use LSTMs to operate on unordered sets by simply applying them to a single random permutation of the node neighbors.
+
+Pooling aggregator: In this aggregator, each neighbor’s vector is fed through a fully-connected neural network, and an element-wise max-pooling operation is applied:
+
+$$
+\mathtt { A G G R E G A T E } _ { k } ^ { \vdash } = \operatorname* { m a x } ( \{ \sigma ( \mathbf { W } _ { p o o l } \mathbf { h } _ { u \vdash } ^ { k } + \mathbf { b } ) , u \in \mathcal { N } _ { \vdash } ( v ) \} )
+$$
+
+$$
+\mathtt { A G G R E G A T E } _ { k } ^ { - 1 } = \operatorname* { m a x } ( \{ \sigma ( \mathbf { W } _ { p o o l } \mathbf { h } _ { u  } ^ { k } + \mathbf { b } ) , u \in \mathcal { N } _ { + } ( v ) \} )
+$$
+
+where max denotes the element-wise max operator, and $\sigma$ is a nonlinear activation function. By applying max-pooling, the model can capture different information across the neighborhood set.
+
+# 3.2 GRAPH EMBEDDING GENERATION
+
+Most existing works of graph convolution neural networks focus more on node embeddings rather than graph embeddings since their focus is on the node-wise classification task. However, graph embeddings that convey the entire graph information are essential to the downstream decoder. In this work, we introduce two approaches (i.e., Pooling-based and Node-based) to generate these graph embeddings from the node embeddings.
+
+Pooling-based Graph Embedding. In this approach, we investigated three pooling techniques: max-pooling, min-pooling and average-pooling. In our experiments, we fed the node embeddings to a fully-connected neural network and applied each pooling method element-wise. We found no significant performance difference across the three different pooling approaches; we thus adopt the max-pooling method as our default pooling approach.
+
+Node-based Graph Embedding. In this approach, we add one super node, $v _ { s }$ , into the input graph, and all other nodes in the graph direct to $v _ { s }$ . We use the aforementioned node embedding generation algorithm to generate the embedding of $v _ { s }$ by aggregating the embeddings of the neighbor nodes. The embedding of $v _ { s }$ that captures the information of all nodes is regarded as the graph embedding.
+
+# 3.3 ATTENTION BASED DECODER
+
+The sequence decoder is a Recurrent Neural Network (RNN) that predicts the next token $y _ { i }$ , given all the previous words $y _ { < i } = y _ { 1 } , . . . , y _ { i - 1 }$ , the RNN hidden state $s _ { i }$ for time $i$ , and a context vector $c _ { i }$ that directs attention to the encoder side. In particular, the context vector $c _ { i }$ depends on a set of node representations $( \mathbf { z } _ { 1 } , . . . , \mathbf { z } _ { \mathcal { V } } )$ which the graph encoder maps the input graph to. Each node representation $\mathbf { z } _ { i }$ contains information about the whole graph with a strong focus on the parts surrounding the $i$ -th node of the input graph. The context vector $c _ { i }$ is computed as a weighted sum of these node representations and the weight $\alpha _ { i j }$ of each node representation is computed by:
+
+$$
+c _ { i } = \sum _ { j = 1 } ^ { \nu } \alpha _ { i j } h _ { j } , w h e r e \alpha _ { i j } = \frac { \exp ( e _ { i j } ) } { \sum _ { k = 1 } ^ { \nu } \exp ( e _ { i k } ) } , e _ { i j } = a ( s _ { i - 1 } , h _ { j } )
+$$
+
+where $a$ is an alignment model which scores how well the input node around position $j$ and the output at position $i$ match. The score is based on the RNN hidden state $s _ { i - 1 }$ and the $j$ -th node representation of the input graph. We parameterize the alignment model $a$ as a feed-forward neural network which is jointly trained with other components of the proposed system. Our model is jointly trained to maximize the conditional log-probability of the correct description given a source graph. In the inference phase, we use the beam search to generate a sequence with the beam size $= 5$ .
+
+# 4 EXPERIMENTS
+
+We conduct experiments to demonstrate the effectiveness and efficiency of the proposed method. Following the experimental settings in (Li et al., 2015), we firstly compare its performance with classical LSTM, GGS-NN, and GCN based methods on two selected tasks including bAbI Task 19 and the Shortest Path Task. We then compare Graph2Seq against other Seq2Seq based methods on a real-world application - Natural Language Generation Task. Note that the parameters of all baselines are set based on performance on the development set.
+
+Experimental Settings. Our proposed model is trained using the Adam optimizer (Kingma & Ba, 2014), with mini-batch size 30. The learning rate is set to 0.001. We apply the dropout strategy (Srivastava et al., 2014) with a ratio of 0.5 at the decoder layer to avoid overfitting. Gradients are clipped when their norm is bigger than 20. For the graph encoder, the default hop size $K$ is set to 6, the size of node initial feature vector is set to 40, the non-linearity function $\sigma$ is ReLU (Glorot et al., 2011), the parameters of aggregators are randomly initialized. The decoder has 1 layer and hidden state size is 80. Since Graph2Seq with mean aggregator and pooling-based graph embeddings generally performs better than other configurations (we defer this discussion to Sec. 4.4), we use this setting as our default model in the following sections.
+
+# 4.1 BABI TASK 19
+
+Setup. The bAbI artificial intelligence (AI) tasks (Weston et al., 2015) are designed to test reasoning capabilities that an AI system possesses. Among these tasks, Task 19 (Path Finding) is arguably the most challenging task (see, e.g., (Sukhbaatar et al., 2015) which reports an accuracy of less than $20 \%$ for all methods that do not use strong supervision). We apply the transformation procedure introduced in (Li et al., 2015) to transform the description as a graph as shown in Figure 2. The left part shows an instance of bAbI task 19: given a set of sentences describing the relative geographical positions for a pair of objects $o _ { 1 }$ and $O _ { 2 }$ , we aim to find the geographical path between $o _ { 1 }$ and $O _ { 2 }$ . The question is then treated as finding the shortest path between two nodes, $N _ { o _ { 1 } }$ and $N _ { o _ { 2 } }$ , which represent $o _ { 1 }$ and $o _ { 2 }$ in the graph. To tackle this problem with Graph2Seq, we annotate $N _ { o 1 }$ with text attribute START and $N _ { o _ { 2 } }$ with text attribute END. For other nodes, we assign their IDs in the graph as their text attributes. It is worth noting that, in our model, the START and END tokens are node features whose vector representations are first randomly initialized and then learned by the model later. In contrast, in GGS-NN, the vector representations of staring and end nodes are set as one-hot vectors, which is specially designed for the shortest path task.
+
+To aggregate the edge information into the node embedding, for each edge, we additionally add a node representing this edge into the graph and assign the edge’s text as its text attribute. We generate 1000 training examples, 1000 development examples and 1000 test examples where each example is a graph-path pair. We use a standard LSTM model (Hochreiter & Schmidhuber, 1997) and GGSNN (Li et al., 2015) as our baselines. Since GCN (Kipf & Welling, 2016) itself cannot output a sequence, we also create a baseline that combines GCN with our sequence decoder.
+
+Results. From Table 1, we can see that the LSTM model fails on this task while our model makes perfect predictions, which underlines the importance of the use of graph encoder to directly encode a graph instead of using sequence model on the converted inputs from a graph. Comparing to GGSNN that uses carefully designed initial embeddings for different types of nodes such as START and END, our model uses a purely end-to-end approach which generates the initial node feature vectors based on random initialization of the embeddings for words in text attributes. However, we still significantly outperform GGS-NN, demonstrating the expressive power of our graph encoder that considers information flows in both forward and backward directions. We observe similar results when comparing our whole Graph2Seq model to GCN with our decoder, which mainly because the current form of GCN (Kipf & Welling, 2016) is designed for undirected graph and thus may have information loss when converting directed graph to undirected one as suggested in (Kipf & Welling, 2016).
+
+![](images/1370f2f841b9d50938c5699f1849be49ed5aeed0b7aad098d1e077d942319ec7.jpg)  
+Figure 2: Path Finding Example.
+
+Table 1: Results of our model and baselines on bAbI and Shortest Directed Path tasks.   
+
+<table><tr><td colspan="2">bAbIT19</td><td>SP-S</td><td>SP-L</td></tr><tr><td>LSTM</td><td>25.2%</td><td>8.1%</td><td>2.2%</td></tr><tr><td>GGS-NN</td><td>98.1%</td><td>100.0%</td><td>95.2%</td></tr><tr><td>GCN</td><td>97.4%</td><td>100.0%</td><td>96.5%</td></tr><tr><td>Graph2Seq</td><td>99.9%</td><td>100.0%</td><td>99.3%</td></tr></table>
+
+# 4.2 SHORTEST PATH TASK
+
+Setup. We further evaluate our model on the Shortest Path (SP) Task whose goal is to find the shortest directed path between two nodes in a graph, introduced in (Li et al., 2015). For this task, we created datasets by generating random graphs, and choosing pairs random nodes A and B which are connected by a unique shortest directed path. Since we can control the size of generated graphs, we can easily test the performance changes of each model when increasing the size of graphs as well. Two such datasets, SP-S and SP-L, were created, containing Small (node size ${ : = } 5$ ) and Large graphs (node size $= 1 0 0$ ), respectively. We restricted the length of the generated shortest paths for SP-S to be at least 2 and at least 4 for SP-L. For each dataset, we used 1000 training examples and 1000 development examples for parameter tuning, and evaluated on 1000 test examples. We choose the same baselines as introduced in the previous section.
+
+Results. Table 1 shows that the LSTM model still fails on both of these two datasets. Our Graph2Seq model achieves comparable performance with GGS-NN that both models could achieve $100 \%$ accuracy on the SP-S dataset while achieves much better on larger graphs on the SP-L dataset. This is because our graph encoder is more expressive in learning the graph structural information with our dual-direction aggregators, which is the key to maintaining good performance when the graph size grows larger, while the performance of GGS-NN significantly degrades due to hardness of capturing the long-range dependence in a graph with large size. Compared to GCN, it achieves better performance than GGS-NN but still much lower than our Graph2Seq, in part because of both the poor effectiveness of graph encoder and incapability of handling with directed graph.
+
+# 4.3 NATURAL LANGUAGE GENERATION TASK
+
+Setup. We finally evaluate our model on a real-world application - Natural Language Generation (NLG) task where we translate a structured semantic representation—in this case a structured query language (SQL) query—to a natural language description expressing its meaning. As indicated in (Spiliopoulou & Hatzopoulos, 1992), the structure of SQL query is essentially a graph. Thus we naturally cast this task as an application of the graph-to-sequence model which takes a graph representing the semantic structure as input and outputs a sequence. Figure 3 illustrates the process of translation of an SQL query to a corresponding natural language description via our Graph2Seq model.2
+
+We use the BLEU-4 score to evaluate our model on the WikiSQL dataset (Zhong et al., 2017), a corpus of 87,726 hand-annotated instances of natural language questions, SQL queries, and SQL tables. WikiSQL was created as the benchmark dataset for the table-based question answering task (for which the state-of-the-art performance is $8 2 . 6 \%$ execution accuracy (Yu et al., 2018)); here we reverse the use of the dataset, treating the SQL query as the input and having the goal of generating the correct English question. These WikiSQL SQL queries are split into training, development and test sets, which contain 61297 queries, 9145 queries and 17284 queries, respectively.
+
+![](images/e1b982306e2189b2ef8604f085cdfdf87df55cd954e87b67cf907e7e1ad3180b.jpg)  
+Figure 3: A running example of the NLG task.
+
+Table 2: Results on WikiSQL.   
+
+<table><tr><td></td><td>BLEU-4</td></tr><tr><td>Seq2Seq</td><td>20.91</td></tr><tr><td>Seq2Seq + Copy</td><td>24.12</td></tr><tr><td>Tree2Seq</td><td>26.67</td></tr><tr><td>Graph2Seq-NGE</td><td>34.28</td></tr><tr><td>Graph2Seq-PGE</td><td>38.97</td></tr></table>
+
+Since the SQL-to-Text task can be cast as ”machine translation” type of problems, we implemented several baselines to address this task. The first one is an attention-based sequence-to-sequence (Seq2Seq) model proposed by (Bahdanau et al., 2014); the second one additionally introduces the copy mechanism in the decoder side (Gu et al., 2016); the third one is a tree-to-sequence (Tree2Seq) model proposed by (Eriguchi et al., 2016) as our baseline. To apply these baselines, we convert an SQL query to a sequence or a tree using some templates which we discuss in detail in the Appendix.
+
+Results. From Table 2, we can see that our Graph2Seq model performs significantly better than the Seq2Seq and Tree2Seq baselines. This result is expected since the structure of SQL query is essentially a graph despite its expressions in sequence and a graph encoder is able to capture much more information directly in graph. Tree2Seq achieves better performance compared to Seq2Seq since its tree-based encoder explicitly takes the syntactic structure of a SQL query into consideration. Two variants of the Graph2Seq models can substantially outperform Tree2Seq, which demonstrates that a general graph to sequence model that is independent of different structural information in complex data is very useful. Interestingly, we also observe that Graph2Seq-PGE (pooling-based graph embedding) performs better than Graph2Seq-NGE (node-based graph embedding). One potential reason is that the node-based graph embedding method artificially added a super node in graph which changes the original graph topology and brings unnecessary noise into the graph.
+
+4.4 IMPACTS OF AGGREGATOR, HOP SIZE AND ATTENTION MECHANISM ON GARPH2SEQ MODEL
+
+Setup. We now investigate the impact of the aggregator and the hop size on the Graph2Seq model. Following the previous SP task, we further create three synthetic dataset $\mathbf { \eta } ^ { 3 } : \mathbf { i } )$ $\mathbf { S D P } _ { D A G }$ whose graphs are directed acyclic graphs (DAGs); ii) $\mathbf { S D P } _ { D C G }$ whose graphs are directed cyclic graphs (DCGs) that always contain cycles; iii) $\mathbf { S D P } _ { S E Q }$ whose graphs are essentially sequential lines. For each dataset, we randomly generated 10000 graphs with the graph size 100 and split them as 8000/1000/1000 for the training/development/test set. For each graph, we generated an SDP query by choosing two random nodes with the constraints that there should be a unique shortest path connecting these two nodes, and that its length should be at least 4.
+
+We create six variants of the Graph2Seq model coupling with different aggregation strategies in the node embedding generation. The first three (Graph2Seq-MA, -LA, -PA) use the Mean Aggregator, LSTM Aggregator and Pooling Aggregator to aggregate node neighbor information, respectively. Unlike these three models that aggregate the information of both forward and backward nodes, the other two models (Graph2Seq-MA-F, -MA-B) only consider one-way information aggregating the information from the forward nodes or the information from the backward nodes with the mean aggregator, respectively. We use the path accuracy to evaluate these models. The hop size is set to 10.
+
+Impacts of the Aggregator. Table 3 shows that on the $\mathrm { S D P } _ { S E Q }$ dataset, both Graph2Seq-MA and Graph2Seq-PA achieve the best performance. On more complicated structured data, such as $\mathrm { S D P } _ { D A G }$ and $\operatorname { S D P } _ { D C G }$ , Graph2Seq-MA (our default model) also performs better than other variants. We can also see that Graph2Seq-MA performs better than Graph2Seq-MA-F and Graph2SeqMA-B on $\mathrm { S D P } _ { D A G }$ and $\mathrm { S D P } _ { S E Q }$ since it captures more information from both directions to learn better node embeddings. However, Graph2Seq-MA-F and Graph2Seq-MA-B achieve comparable performance to Graph2Seq-MA on $\operatorname { S D P } _ { D C G }$ . This is because in almost $9 5 \%$ of the graphs, $90 \%$ of the nodes could reach each other by traversing the graph for a given hop size, which dramatically restores its information loss.
+
+Table 3: Shortest path accuracy on three synthetic SDP datasets.   
+
+<table><tr><td>Method</td><td>SDPDAG</td><td>SDPDCG</td><td>SDPsEQ</td></tr><tr><td>G2S-MA</td><td>99.8%</td><td>99.2%</td><td>100%</td></tr><tr><td>G2S-LA</td><td>91.7%</td><td>90.9%</td><td>99.9%</td></tr><tr><td>G2S-PA</td><td>96.7%</td><td>98.4%</td><td>100%</td></tr><tr><td>G2S-MA-F</td><td>78.8%</td><td>98.7%</td><td>70.2%</td></tr><tr><td>G2S-MA-B</td><td>80.1%</td><td>99.1%</td><td>68.6%</td></tr></table>
+
+![](images/1817fe4bc4b840990b8107e2387bb08026cbe14dc5508663d86d7a3ee41be37e.jpg)  
+Figure 4: Test Results on $\mathrm { S D P _ { 1 0 0 0 } }$
+
+Impact of Hop Size. To study the impact of the hop size, we create a $\operatorname { S D P } _ { D C G }$ dataset, $\mathrm { S D P _ { 1 0 0 0 } }$ and results are shown in Figure 4. We see that the performance of all variants of Graph2Seq converges to its optimal performance when increasing the number of hop size. Specifically, Graph2Seq-MA achieves significantly better performance than its counterparts considering only one direction propagation, especially when the hop size is small. As the hop size increases, the performance differences diminish. This is the desired property since Graph2Seq-MA can use much smaller hop size (about the half) to achieve the same performance of Graph2Seq-MA-F or Graph2Seq-MA-B with a larger size. This is particularly useful for large graphs where increasing hop size may need considerable computing resources and long run-time. We also compare Graph2Seq with GCN, where the hop size means the number of layers in the settings of GCN. Surprisingly, even Graph2Seq-MA-F or Graph2Seq-MA-B can significantly outperform GCN with the same hope size despite its rough equivalence between these two architectures. It again illustrates the importance of the methods that could take into account both directed and undirected graphs. For additional experimental results on the impact of hop size for graphs of different sizes, please refer to the Table 4 in Appendix C.
+
+Impact of Attention Mechanism. To investigate the impact of attention mechanism to the Graph2Seq model, we still evaluate our model on $\mathrm { S D P } _ { D A G }$ , $\operatorname { S D P } _ { D C G }$ and $\mathrm { S D P } _ { S E Q }$ datasets but without considering the attention strategy. As shown in Table 4, we find that the attention strategy significantly improves the performance of all variants of Graph2Seq by at least $1 4 . 9 \%$ . This result is expected since for larger graphs it is more difficult for the encoder to compress all necessary information into a fixed-length vector; as intended, applying the attention mechanism in decoding enabled our proposed Graph2Seq model to successfully handle large graphs.
+
+# 5 CONCLUSION
+
+In this paper, we study the graph-to-sequence problem, introducing a new general and flexible Graph2Seq model that follows the encoder-decoder architecture. We showed that, using our proposed bi-directional node embedding aggregation strategy, the graph encoder could successfully learn representations for three representative classes of directed graph, i.e., directed acyclic graphs, directed cyclic graphs and sequence-styled graphs. Experimental results on three tasks demonstrate that our model significantly outperforms existing graph neural networks, Seq2Seq, and Tree2Seq baselines on both synthetic and real application datasets. We also showed that introducing an attention mechanism over node representation into the decoding substantially enhances the ability of our model to produce correct target sequences from large graphs. Since much symbolic data is represented as graphs and many tasks express their desired outputs as sequences, we expect Graph2Seq to be broadly applicable to unify symbolic AI and beyond.
+
+# REFERENCES
+
+Amr Ahmed, Nino Shervashidze, Shravan Narayanamurthy, Vanja Josifovski, and Alexander J Smola. Distributed large-scale natural graph factorization. In Proceedings of the 22nd international conference on World Wide Web, pp. 37–48. ACM, 2013.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
+
+Laura Banarescu, Claire Bonial, Shu Cai, Madalina Georgescu, Kira Griffitt, Ulf Hermjakob, Kevin Knight, Philipp Koehn, Martha Palmer, and Nathan Schneider. Abstract meaning representation for sembanking. In Proceedings of the 7th Linguistic Annotation Workshop and Interoperability with Discourse, pp. 178–186, 2013.
+
+Joost Bastings, Ivan Titov, Wilker Aziz, Diego Marcheggiani, and Khalil Sima’an. Graph convolutional encoders for syntax-aware neural machine translation. arXiv preprint arXiv:1704.04675, 2017.
+
+Mikhail Belkin and Partha Niyogi. Laplacian eigenmaps and spectral techniques for embedding and clustering. In Advances in neural information processing systems, pp. 585–591, 2002.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013.
+
+Shaosheng Cao, Wei Lu, and Qiongkai Xu. Grarep: Learning graph representations with global structural information. In Proceedings of the 24th ACM International on Conference on Information and Knowledge Management, pp. 891–900. ACM, 2015.
+
+Jie Chen, Tengfei Ma, and Cao Xiao. Fastgcn: Fast learning with graph convolutional networks via importance sampling. arXiv preprint arXiv:1801.10247, 2018.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks¨ on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3844–3852, 2016.
+
+Alberto G Duran and Mathias Niepert. Learning graph representations with embedding propagation. arXiv preprint arXiv:1710.03059, 2017.
+
+David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan´ Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015.
+
+Akiko Eriguchi, Kazuma Hashimoto, and Yoshimasa Tsuruoka. Tree-to-sequence attentional neural machine translation. arXiv preprint arXiv:1603.06075, 2016.
+
+Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N Dauphin. Convolutional sequence to sequence learning. arXiv preprint arXiv:1705.03122, 2017.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, AISTATS 2011, Fort Lauderdale, USA, April 11-13, 2011, pp. 315–323, 2011.
+
+Rafael Gomez-Bombarelli, Jennifer N Wei, David Duvenaud, Jos ´ e Miguel Hern ´ andez-Lobato, ´ Benjam´ın Sanchez-Lengeling, Dennis Sheberla, Jorge Aguilera-Iparraguirre, Timothy D Hirzel, ´ Ryan P Adams, and Alan Aspuru-Guzik. Automatic chemical design using a data-driven contin- ´ uous representation of molecules. ACS Central Science, 2016.
+
+Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In Neural Networks, 2005. IJCNN’05. Proceedings. 2005 IEEE International Joint Conference on, volume 2, pp. 729–734. IEEE, 2005.
+
+Palash Goyal and Emilio Ferrara. Graph embedding techniques, applications, and performance: A survey. arXiv preprint arXiv:1705.02801, 2017.
+
+Alex Graves and Jurgen Schmidhuber. Framewise phoneme classification with bidirectional lstm ¨ and other neural network architectures. Neural Networks, 18(5-6):602–610, 2005.
+
+Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 855–864. ACM, 2016.
+
+Jiatao Gu, Zhengdong Lu, Hang Li, and Victor OK Li. Incorporating copying mechanism in sequence-to-sequence learning. arXiv preprint arXiv:1603.06393, 2016.
+
+William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. arXiv preprint arXiv:1706.02216, 2017a.
+
+William L Hamilton, Rex Ying, and Jure Leskovec. Representation learning on graphs: Methods and applications. arXiv preprint arXiv:1709.05584, 2017b.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Yanrong Hu and Simon X Yang. A knowledge based genetic algorithm for path planning of a mobile robot. In Robotics and Automation, 2004. Proceedings. ICRA’04. 2004 IEEE International Conference on, volume 5, pp. 4350–4355. IEEE, 2004.
+
+Srinivasan Iyer, Ioannis Konstas, Alvin Cheung, and Luke Zettlemoyer. Summarizing source code using a neural attention model. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 2073–2083, 2016.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.
+
+Yujia Li, Oriol Vinyals, Chris Dyer, Razvan Pascanu, and Peter Battaglia. Learning deep generative models of graphs. arXiv preprint arXiv:1803.03324, 2018.
+
+Bowen Liu, Bharath Ramsundar, Prasad Kawthekar, Jade Shi, Joseph Gomes, Quang Luu Nguyen, Stephen Ho, Jack Sloane, Paul Wender, and Vijay Pande. Retrosynthetic reaction prediction using neural sequence-to-sequence models. ACS central science, 3(10):1103–1113, 2017.
+
+Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Effective approaches to attentionbased neural machine translation. arXiv preprint arXiv:1508.04025, 2015.
+
+Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural networks for graphs. In International Conference on Machine Learning, pp. 2014–2023, 2016.
+
+Mingdong Ou, Peng Cui, Jian Pei, Ziwei Zhang, and Wenwu Zhu. Asymmetric transitivity preserving graph embedding. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 1105–1114. ACM, 2016.
+
+Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014.
+
+Michael Pust, Ulf Hermjakob, Kevin Knight, Daniel Marcu, and Jonathan May. Parsing english into abstract meaning representation using syntax-based machine translation. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1143–1154, 2015.
+
+Sam T Roweis and Lawrence K Saul. Nonlinear dimensionality reduction by locally linear embedding. science, 290(5500):2323–2326, 2000.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2009.
+
+Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne van den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional networks. arXiv preprint arXiv:1703.06103, 2017.
+
+Mike Schuster and Kuldip K Paliwal. Bidirectional recurrent neural networks. IEEE Transactions on Signal Processing, 45(11):2673–2681, 1997.
+
+Martin Simonovsky and Nikos Komodakis. Graphvae: Towards generation of small graphs using variational autoencoders. arXiv preprint arXiv:1802.03480, 2018.
+
+Richard Socher, Christopher D Manning, and Andrew Y Ng. Learning continuous phrase representations and syntactic parsing with recursive neural networks. In Proceedings of the NIPS-2010 Deep Learning and Unsupervised Feature Learning Workshop, volume 2010, pp. 1–9, 2010.
+
+Linfeng Song, Xiaochang Peng, Yue Zhang, Zhiguo Wang, and Daniel Gildea. Amr-to-text generation with synchronous node replacement grammar. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 2: Short Papers, pp. 7–13, 2017.
+
+Myra Spiliopoulou and Michael Hatzopoulos. Translation of SQL queries into a graph structure: query transformations and pre-optimization issues in a pipeline multiprocessor environment. Inf. Syst., 17(2):161–170, 1992. doi: 10.1016/0306-4379(92)90010-K. URL https://doi.org/ 10.1016/0306-4379(92)90010-K.
+
+Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 2440–2448, 2015.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, pp. 3104–3112, 2014.
+
+Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. arXiv preprint arXiv:1503.00075, 2015.
+
+Jian Tang, Meng Qu, Mingzhe Wang, Ming Zhang, Jun Yan, and Qiaozhu Mei. Line: Largescale information network embedding. In Proceedings of the 24th International Conference on World Wide Web, pp. 1067–1077. International World Wide Web Conferences Steering Committee, 2015.
+
+Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 1(2), 2017.
+
+Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: Sequence to sequence for sets. arXiv preprint arXiv:1511.06391, 2015a.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015b.
+
+Oriol Vinyals, Alexander Toshev, Samy Bengio, and Dumitru Erhan. Show and tell: A neural image caption generator. In Computer Vision and Pattern Recognition (CVPR), 2015 IEEE Conference on, pp. 3156–3164. IEEE, 2015c.
+
+Jason Weston, Antoine Bordes, Sumit Chopra, and Tomas Mikolov. Towards ai-complete question answering: A set of prerequisite toy tasks. CoRR, abs/1502.05698, 2015. URL http: //arxiv.org/abs/1502.05698.
+
+Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Revisiting semi-supervised learning with graph embeddings. arXiv preprint arXiv:1603.08861, 2016.
+
+Tao Yu, Zifan Li, Zilin Zhang, Rui Zhang, and Dragomir Radev. Typesql: Knowledge-based typeaware neural text-to-sql generation. arXiv preprint arXiv:1804.09769, 2018.
+
+Wojciech Zaremba and Ilya Sutskever. Learning to execute. arXiv preprint arXiv:1410.4615, 2014.
+
+Yu Zhang, William Chan, and Navdeep Jaitly. Very deep convolutional networks for end-to-end speech recognition. In Acoustics, Speech and Signal Processing (ICASSP), 2017 IEEE International Conference on, pp. 4845–4849. IEEE, 2017.
+
+Victor Zhong, Caiming Xiong, and Richard Socher. Seq2sql: Generating structured queries from natural language using reinforcement learning. CoRR, abs/1709.00103, 2017.
+
+# A PSEUDO-CODE OF THE GRAPH-TO-SEQUENCE ALGORITHM
+
+# Algorithm 1 Node embedding generation algorithm
+
+Input: Graph $\mathcal G ( \nu , \mathcal { E } )$ ; node initial feature vector $\mathbf { a } _ { v }$ , $\forall v \in \mathcal { V }$ ; hops $K$ ; weight matrices $\mathbf { W } ^ { k }$ , $\forall k \in$ $\{ 1 , . . . , K \}$ ; non-linearity $\sigma$ ; aggregator functions AGGREGAT $\boldsymbol { \mathrm { E } } _ { k } ^ { \vdash }$ , AGGREGATE $\mathbf { \Pi } _ { k } ^ { - 1 }$ , $\forall k \in \{ 1 , . . . , K \}$ ; neighborhood functions $\mathcal { N } _ { \vdash }$ , $\mathcal { N } _ { + }$ Output: Vector representations $\mathbf { Z } _ { v }$ for all $v \in \mathcal V$ 1: $\mathbf { h } _ { v \vdash } ^ { 0 }  \mathbf { a } _ { v }$ , $\forall v \in \mathcal { V }$ 2: $\mathbf { h } _ { v - 1 } ^ { 0 }  \mathbf { a } _ { v }$ , $\forall v \in \mathcal { V }$ 3: for all $k = 1 . . . K$ do 4: for all $v \in \mathcal V$ do 5: $\mathbf { h } _ { \mathcal { N } _ { \mathrm { i } } ( v ) } ^ { k }  \mathrm { A G G R E G A T E } _ { k } ^ {  } ( \{ \mathbf { h } _ { u  } ^ { k - 1 } , \forall u \in \mathcal { N } _ { \mathrm { i } } ( v ) \} )$ 6: hkv $\mathbf { \Sigma } _ { \vdash }  \sigma ( \mathbf { W } ^ { k } \cdot \mathsf { C O N C A T } ( \mathbf { h } _ { v \vdash } ^ { k - 1 } , \mathbf { h } _ { \mathcal { N } _ { \vdash } ( v ) } ^ { k } ) )$ 7: $\begin{array} { r } { \mathbf { h } _ { \mathcal { N } _ { \mathrm { - } } ( v ) } ^ { k }  \mathtt { A G G R E G A T E } _ { k } ^ { \mathtt { - } } ( \{ \mathbf { h } _ { u \mathrm { - } } ^ { k - 1 } , \forall u \in \mathcal { N } _ { \mathrm { + } } ( v ) \} ) } \end{array}$ 8: $\mathbf { h } _ { v - 1 } ^ { k }  \sigma$ ( Wk· CONCAT(hk−1va , hkNa(v))) 9: end for 10: end for 11: $\mathbf { z } _ { v } \gets \mathrm { C O N C A T } ( \mathbf { h } _ { v \mid - } ^ { K } , \mathbf { h } _ { v  } ^ { K } ) , \forall v \in \mathcal { V }$
+
+Algorithm 1 describes the embedding generation process where the entire graph $\mathcal { G } = ( \nu , \mathcal { E } )$ and initial feature vectors for all nodes $\mathbf { a } _ { v }$ , $\forall v \in \mathcal { V }$ , are provided as input. Here $k$ denotes the current hop in the outer loop. The $\mathbf { h } _ { v \vdash } ^ { k }$ denotes node $v$ ’s forward representation which aggregates the information of nodes in $\mathcal { N } _ { \vdash } ( v )$ . Similarly, the $\mathbf { h } _ { v - 1 } ^ { k }$ denotes node $v$ ’s backward representation which is generated by aggregating the information of nodes in $\mathcal { N } _ { + } ( v )$ . Each step in the outer loop of Algorithm 1 proceeds as follows. First, each node $v \in \mathcal V$ in a graph aggregates the forward representations of the nodes in its immediate neighborhood, $\{ \mathbf { h } _ { u \vdash } ^ { k - 1 } , \forall u \in \mathcal { N } _ { \vdash } ( v ) \}$ , into a single vector, $\mathbf { h } _ { \mathcal { N } _ { \mathrm { i } } ( v ) } ^ { k }$ (line 5). Note that this aggregation step depends on the representations generated at the previous iteration of the outer loop, $k - 1$ , and the $k = 0$ forward representations are defined as the input node feature vector. After arepresentation, $\mathbf { h } _ { v \vdash } ^ { k - 1 }$ ting the neighboring feature vectors, we con, with the aggregated neighborhood vector, $\mathbf { h } _ { \mathcal { N } _ { \mathrm { i } } ( v ) } ^ { k }$ e the node current forward. Then this concatenated vector is fed through a fully connected layer with nonlinear activation function $\sigma$ , which updates the forward representation of the current node to be used at the next step of the algorithm (line 6). We apply similar process to generate the backward representations of the nodes (line 7, 8). Finally, the representation of each node $\mathbf { z } _ { v }$ is the concatenation of the forward representation (i.e., $\mathbf { h } _ { v \vdash } ^ { K }$ ) and the backward representation (i.e., $\mathbf { h } _ { v - 1 } ^ { K } )$ ) at the last iteration $K$ .
+
+# B STRUCTURED REPRESENTATION OF THE SQL QUERY
+
+To apply Graph2Seq, Seq2Seq and Tree2Seq models on the natural language generation task, we need to convert the SQL query to a graph, sequence and tree, respectively. In this section, we describe these representations of the SQL query.
+
+# B.1 SEQUENCE REPRESENTATION
+
+We apply a simple template to construct the SQL query sequence: “SELECT $^ +$ <aggregation function $> + <$ Split Symbol> $^ +$ <selected column $> +$ WHERE $^ +$ <condition0> + <Split Symbol> $+ < c o n d i t i o n _ { 1 } > + \ldots ^ { , }$ .
+
+# B.2 TREE REPRESENTATION
+
+We apply the SQL Parser tool4 to convert an SQL query to a tree which is illustrated in Figure 5. Specifically, the root of this tree has two child nodes, namely SELECT LIST and WHERE CLAUSE. The child nodes of SELECT LIST node are the selected columns in the SQL query. The WHERE CLAUSE node has all occurred logical operators in the SQL query as its children. The children of a logical operator node are the columns on which this operator works.
+
+![](images/eb8d2b13f2328e3820937294be1002f5a4119c02166be8b388932b414836e1da.jpg)
+
+![](images/0029468fc6ebd6581a56a75657d1bd9af1818c0efd325d0be6abc310b7c0e97f.jpg)  
+Figure 5: Tree representation of the SQL query. SQL query   
+Figure 6: Graph representation of the SQL query.
+
+# B.3 GRAPH REPRESENTATION
+
+We use the following method to transform the SQL query to a graph:
+
+SELECT Clause. For the SELECT clause such as “SELECT company”, we first create a node assigned with text attribute select. This SELECT node connects with column nodes whose text attributes are the selected column names such as company. For the SQL queries that contain aggregation functions such as count or max, we add one aggregation node which is connected with the column node—their text attributes are the aggregation function names.
+
+WHERE Clause. The WHERE clause usually contains more than one condition. For each condition, we use the same process as for the SELECT clause to create nodes. For example, in Figure 6, we create node assets and ${ > } v a l _ { 0 }$ for the first condition, the node sales and ${ > } v a l _ { 0 }$ for the second condition. We then integrate the constraint nodes that have the same text attribute (e.g., ${ > } v a l _ { 0 }$ in Figure 6). For a logical operator such as AND, OR and NOT, we create a node that connects with all column nodes that the operator works on (e.g., AND in Figure 6). These logical operator nodes then connect with SELECT node.
+
+# C MORE RESULTS ON THE IMPACT OF HOP SIZE
+
+In Algorithm 1, we can see that there are three key factors in the node embedding generation. The first factor is the aggregator choice which determines how information from neighborhood nodes is combined. The other two are the hop size $( K )$ and the neighborhood function $( \mathcal { N } _ { \vdash } ( v ) , \mathcal { N } _ { \dashv } ( v ) )$ , which together determine which neighbor nodes should be aggregated to generate each node embedding. To study the impact of the hop size in our model, we create two $\operatorname { S D P } _ { D C G }$ datasets, $\mathrm { S D P _ { 1 0 0 } }$ and $\mathrm { S D P _ { 1 0 0 0 } }$ , where each graph has 100 nodes or 1000 nodes, respectively. Both of these two datasets contain 8000 training examples, 1000 dev examples and 1000 test examples. We evaluated three models, Graph2Seq-MA-F, Graph2Seq-MA-B and Graph2Seq-MA, on these two datasets; results are listed in Table 4.
+
+Table 4: Test Results on $\mathrm { { S D P } _ { 1 0 0 } }$ and $\mathrm { S D P _ { 1 0 0 0 } }$   
+
+<table><tr><td colspan="5">SDP100</td></tr><tr><td>Hop Size</td><td>Graph2Seq-MA-F</td><td>Graph2Seq-MA-B</td><td>Graph2Seq-MA</td><td>GCN(Kipf &amp;Welling,2016)+ our decoder</td></tr><tr><td>1</td><td>50.1%</td><td>52.0%</td><td>76.3%</td><td>70.2%</td></tr><tr><td>3</td><td>73.2%</td><td>76.7%</td><td>95.4%</td><td>90.1%</td></tr><tr><td>4</td><td>84.7%</td><td>85.2%</td><td>99.2%</td><td>94.7%</td></tr><tr><td>5</td><td>93.2%</td><td>94.5%</td><td>99.4%</td><td>94.9%</td></tr><tr><td>7</td><td>98.9%</td><td>99.1%</td><td>99.4%</td><td>94.3%</td></tr><tr><td>10</td><td>98.9%</td><td>99.1%</td><td>99.4%</td><td>94.3%</td></tr><tr><td rowspan="3">10</td><td>w/o attention</td><td>w/o attention</td><td>w/oattention</td><td>w/o attention</td></tr><tr><td>85.8%</td><td>86.3%</td><td>89.6%</td><td>83.1%</td></tr><tr><td></td><td></td><td>SDP1000</td><td></td></tr><tr><td>Hop Size</td><td>Graph2Seq-MA-F</td><td>Graph2Seq-MA-B</td><td>Graph2Seq-MA</td><td>GCN(Kipf&amp;Welling,2016)+our decoder</td></tr><tr><td>10</td><td>34.7%</td><td>33.2%</td><td>50.4%</td><td>45.7%</td></tr><tr><td>35</td><td>68.2%</td><td>70.6%</td><td>82.5%</td><td>66.3%</td></tr><tr><td>45</td><td>79.0%</td><td>82.1%</td><td>96.5%</td><td>89.0%</td></tr><tr><td>75</td><td>88.3%</td><td>89.9%</td><td>96.4%</td><td>89.2%</td></tr><tr><td>85</td><td>95.9%</td><td>96.0%</td><td>96.5%</td><td>88.8%</td></tr><tr><td>100</td><td>95.8%</td><td>96.0%</td><td>96.5%</td><td>88.6%</td></tr><tr><td>100</td><td>w/o attention 78.3%</td><td>w/o attention 78.2%</td><td>w/o attention 81.6%</td><td>w/o attention 72.4%</td></tr></table>
+
+We see that Graph2Seq-MA-F and Graph2Seq-MA-B could show significant performance improvements with increasing the hop size. Specifically, on the $\mathrm { S D P _ { 1 0 0 } }$ dataset, Graph2Seq-MA-F and Graph2Seq-MA-B achieve their best performance when the hop size reaches 7; further increases do not improve the overall performance. A similar situation is also observed on the $\mathrm { S D P _ { 1 0 0 0 } }$ dataset; performance converges at the hop size of 85. Interestingly, the average diameters of the graphs in the two datasets are 6.8 and 80.2, respectively, suggesting that the ideal hop size for best Graph2SeqMA-F performance should be the graph diameter. This should not be surprising; if the hop size equals the graph diameter, each node is guaranteed to aggregate the information of all reachable nodes on the graph within its embedding. Note that in the experiments on $\mathrm { S D P _ { 1 0 0 0 } }$ , in the $X$ $( X \ ; 1 0 )$ hop, we always use the aggregator in the $I O$ -th hop, because introducing too many aggregators (i.e., parameters) may make the model over-fitting.
+
+Like Graph2Seq-MA-F, Graph2Seq-MA also benefited from increasing the hop size. However, on both datasets, Graph2Seq-MA could reach peak performance at a smaller hop size than Graph2SeqMA-F. For example, on the $\mathrm { S D P _ { 1 0 0 } }$ dataset, Graph2Seq-MA achieves $9 9 . 2 \%$ accuracy once the hop size is greater than 4 while Graph2Seq-MA-F requires a hop size greater than 7 to achieve comparable accuracy; similar observations hold for the $\mathrm { S D P _ { 1 0 0 0 } }$ dataset. Moreover, we can see that the minimum required hop size that Graph2Seq-MA could achieve its best performance is approximately the average radii (c.f. diameter) of the graphs, which are 3.4 and 40.1, respectively. Recall that the main difference between Graph2Seq-MA and Graph2Seq-MA-F (or Graph2Seq-MA-B) lies in whether the system aggregates information propagated from backward nodes; the performance difference indicates that by incorporating forward and backward nodes’ information, it is possible for the model to achieve the best performance by traversing less of the graph. This is useful in practice, especially for large graphs where increasing hop size may consume considerable computing resources and run-time.
+
+Table 4 also makes clear the utility of the attention strategy; the performance of both Graph2SeqMA-F and Graph2Seq-MA decreases by at least $9 . 8 \%$ on $\mathrm { S D P _ { 1 0 0 } }$ and $1 4 . 9 \%$ on $\mathrm { S D P _ { 1 0 0 0 } }$ . This result is expected, since for larger graphs it is more difficult for the encoder to compress all necessary information into a fixed-length vector; as intended, applying the attention mechanism in decoding enabled our proposed Graph2Seq model to handle large graphs successfully.
+
+As shown in Algorithm 1, the neighborhood function takes a given node as input and returns its directly connected neighbor nodes, which are then fed to the node embedding generator. Intuitively, to obtain a better representation of a node, this function should return all its neighbor nodes in the graph. However, this may result in high training times on large graphs. To address this, (Hamilton et al., 2017a) proposes a sampling method which randomly selects a fixed number of neighbor nodes from which to aggregate information at each hop. We use this sampling method to manage the neighbor node size at each aggregation step.

parse/train/iAX0l6Cz8ub/iAX0l6Cz8ub.md

@@ -0,0 +1,590 @@
+# GEOMETRY-AWARE INSTANCE-REWEIGHTED ADVER-SARIAL TRAINING
+
+Jingfeng Zhang1,2 Jianing Zhu3 Gang Niu1 Bo Han3,1   
+Masashi Sugiyama1,4 Mohan Kankanhalli2   
+1RIKEN Center for Advanced Intelligence Project, Tokyo, Japan   
+2National University of Singapore, Singapore   
+3Hong Kong Baptist University, Hong Kong SAR, China   
+4The University of Tokyo, Tokyo, Japan
+
+jingfeng.zhang@riken.jp, csjnzhu@comp.hkbu.edu.hk gang.niu@riken.jp, bhanml@comp.hkbu.edu.hk sugi@k.u-tokyo.ac.jp, mohan@comp.nus.edu.sg
+
+# ABSTRACT
+
+In adversarial machine learning, there was a common belief that robustness and accuracy hurt each other. The belief was challenged by recent studies where we can maintain the robustness and improve the accuracy. However, the other direction, we can keep the accuracy and improve the robustness, is conceptually and practically more interesting, since robust accuracy should be lower than standard accuracy for any model. In this paper, we show this direction is also promising. Firstly, we find even over-parameterized deep networks may still have insufficient model capacity, because adversarial training has an overwhelming smoothing effect. Secondly, given limited model capacity, we argue adversarial data should have unequal importance: geometrically speaking, a natural data point closer to/farther from the class boundary is less/more robust, and the corresponding adversarial data point should be assigned with larger/smaller weight. Finally, to implement the idea, we propose geometry-aware instance-reweighted adversarial training, where the weights are based on how difficult it is to attack a natural data point. Experiments show that our proposal boosts the robustness of standard adversarial training; combining two directions, we improve both robustness and accuracy of standard adversarial training.
+
+# 1 INTRODUCTION
+
+Crafted adversarial data can easily fool the standard-trained deep models by adding humanimperceptible noise to the natural data, which leads to the security issue in applications such as medicine, finance, and autonomous driving (Szegedy et al., 2014; Nguyen et al., 2015). To mitigate this issue, many adversarial training methods employ the most adversarial data maximizing the loss for updating the current model such as standard adversarial training (AT) (Madry et al., 2018), TRADES (Zhang et al., 2019), robust self-training (RST) (Carmon et al., 2019), and MART (Wang et al., 2020b). The adversarial training methods seek to train an adversarially robust deep model whose predictions are locally invariant to a small neighborhood of its inputs (Papernot et al., 2016). By leveraging adversarial data to smooth the small neighborhood, the adversarial training methods acquire adversarial robustness against adversarial data but often lead to the undesirable degradation of standard accuracy on natural data (Madry et al., 2018; Zhang et al., 2019).
+
+Thus, there have been debates on whether there exists a trade-off between robustness and accuracy. For example, some argued an inevitable trade-off: Tsipras et al. (2019) showed fundamentally different representations learned by a standard-trained model and an adversarial-trained model; Zhang et al. (2019) and Wang et al. (2020a) proposed adversarial training methods that can trade off standard accuracy for adversarial robustness. On the other hand, some argued that there is no such the trade-off: Raghunathan et al. (2020) showed infinite data could eliminate this trade-off; Yang et al. (2020) showed benchmark image datasets are class-separated.
+
+![](images/a243a447c40e0492c7a4c20451b1f7a4eca6fb5c7ed937b4fc861042d49d998b.jpg)  
+Figure 1: The illustration of GAIRAT. GAIRAT explicitly gives larger weights on the losses of adversarial data (larger red), whose natural counterparts are closer to the decision boundary (lighter blue). GAIRAT explicitly gives smaller weights on the losses of adversarial data (smaller red), whose natural counterparts are farther away from the decision boundary (darker blue). The examples of two toy datasets and the CIFAR-10 dataset refer to Figure 3.
+
+Recently, emerging adversarial training methods have empirically challenged this trade-off. For example, Zhang et al. (2020b) proposed the friendly adversarial training method (FAT), employing friendly adversarial data minimizing the loss given that some wrongly-predicted adversarial data have been found. Yang et al. (2020) introduced dropout (Srivastava et al., 2014) into existing AT, RST, and TRADES methods. Both methods can improve the accuracy while maintaining the robustness. However, the other direction—whether we can improve the robustness while keeping the accuracy—remains unsolved and is more interesting.
+
+In this paper, we show this direction is also achievable. Firstly, we show over-parameterized deep networks may still have insufficient model capacity, because adversarial training has an overwhelming smoothing effect. Fitting adversarial data is demanding for a tremendous model capacity: It requires a large number of trainable parameters or long-enough training epochs to reach near-zero error on the adversarial training data (see Figure 2). The over-parameterized models that fit natural data entirely in the standard training (Zhang et al., 2017) are still far from enough for fitting adversarial data. Compared with standard training fitting the natural data points, adversarial training smooths the neighborhoods of natural data, so that adversarial data consume significantly more model capacity than natural data. Thus, adversarial training methods should carefully utilize the limited model capacity to fit the neighborhoods of the important data that aid to fine-tune the decision boundary. Therefore, it may be unwise to give equal weights to all adversarial data.
+
+Secondly, data along with their adversarial variants are not equally important. Some data are geometrically far away from the class boundary. They are relatively guarded. Their adversarial variants are hard to be misclassified. On the other hand, some data are close to the class boundary. They are relatively attackable. Their adversarial variants are easily misclassified (see Figure 3). As the adversarial training progresses, the adversarially robust model engenders an increasing number of guarded training data and a decreasing number of attackable training data. Given limited model capacity, treating all data equally may cause the vast number of adversarial variants of the guarded data to overwhelm the model, leading to the undesirable robust overfitting (Rice et al., 2020). Thus, it may be pessimistic to treat all data equally in adversarial training.
+
+To ameliorate this pessimism, we propose a heuristic method, i.e., geometry-aware instancereweighted adversarial training (GAIRAT). As shown in Figure 1, GAIRAT treats data differently. Specifically, for updating the current model, GAIRAT gives larger/smaller weight to the loss of an adversarial variant of attackable/guarded data point which is more/less important in fine-tuning the decision boundary. An attackable/guarded data point has a small/large geometric distance, i.e., its distance from the decision boundary. We approximate its geometric distance by the least number of iterations $\kappa$ that projected gradient descent method (Madry et al., 2018) requires to generate a misclassified adversarial variant (see the details in Section 3.3). GAIRAT explicitly assigns instancedependent weight to the loss of its adversarial variant based on the least iteration number $\kappa$ .
+
+Our contributions are as follows. (a) In adversarial training, we identify the pessimism in treating all data equally, which is due to the insufficient model capacity and the unequal nature of different data (in Section 3.1). (b) We propose a new adversarial training method, i.e., GAIRAT (its learning objective in Section 3.2 and its realization in Section 3.3). GAIRAT is a general method: Besides standard AT (Madry et al., 2018), the existing adversarial training methods such as FAT (Zhang et al., 2020b) and TRADES (Zhang et al., 2019) can be modified to GAIR-FAT and GAIR-TRADES (in Appendices B.1 and B.2, respectively). (c) Empirically, our GAIRAT can relieve the issue of robust overfitting (Rice et al., 2020), meanwhile leading to the improved robustness with zero or little degradation of accuracy (in Section 4.1 and Appendix C.1). Besides, we use Wide ResNets (Zagoruyko & Komodakis, 2016) to corroborate the efficacy of our geometry-aware instance-reweighted methods: Our GAIRAT significantly boosts the robustness of standard AT; combined with FAT, our GAIRFAT improves both the robustness and accuracy of standard AT (in Section 4.2). Consequently, we conjecture no inevitable trade-off between robustness and accuracy.
+
+![](images/a192d76cc019de17374fff10e8afd6aaf41f873f9cfe956ab015fb6274a8d197.jpg)  
+Figure 2: We plot standard training error (Natural) and adversarial training error (PGD-10) over the training epochs of the standard AT on CIFAR-10 dataset. Left panel: AT on different sizes of network. The red line represents standard test accuracy by standard training (ST). Right panel: AT on ResNet-18 under different perturbation bounds $\epsilon _ { \mathrm { t r a i n } }$ .
+
+# 2 ADVERSARIAL TRAINING
+
+In this section, we review adversarial training methods (Madry et al., 2018; Zhang et al., 2020b).
+
+# 2.1 LEARNING OBJECTIVE
+
+Let $( \mathcal { X } , d _ { \infty } )$ denote the input feature space $\mathcal { X }$ with the infinity distance metric $d _ { \operatorname* { i n f } } ( x , x ^ { \prime } ) = \| x -$ $x ^ { \prime } \| _ { \infty }$ , and $\dot { B } _ { \epsilon } [ x ] = \{ x ^ { \prime } \in \bar { \mathcal { X } } \mid d _ { \operatorname* { i n f } } ( x , \bar { x ^ { \prime } } ) \leq \epsilon \}$ be the closed ball of radius $\epsilon > 0$ centered at $x$ in $\mathcal { X }$ . Dataset $S = \{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n }$ , where $x _ { i } \in \mathcal X$ and $y _ { i } \in \mathcal { Y } = \{ 0 , 1 , . . . , C - 1 \}$ .
+
+The objective function of standard adversarial training (AT) (Madry et al., 2018) is
+
+$$
+\operatorname* { m i n } _ { f _ { \theta } \in \mathcal { F } } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \ell ( f _ { \theta } ( \tilde { x } _ { i } ) , y _ { i } ) ,
+$$
+
+where
+
+$$
+\begin{array} { r } { \tilde { x } _ { i } = \arg \operatorname* { m a x } _ { \tilde { x } \in \mathcal { B } _ { \epsilon } [ x _ { i } ] } \ell ( f _ { \theta } ( \tilde { x } ) , y _ { i } ) , } \end{array}
+$$
+
+where $\tilde { x }$ is the most adversarial data within the $\epsilon$ -ball centered at $x$ , $f _ { \theta } ( \cdot ) : \mathcal { X }  \mathbb { R } ^ { C }$ is a score function, and the loss function $\ell : \mathbb { R } ^ { C } \times \mathcal { V }  \mathbb { R }$ is a composition of a base loss $\ell _ { \mathbf { B } } : \Delta ^ { C - 1 } \times \mathcal { Y }  \mathbb { R }$ (e.g., the cross-entropy loss) and an inverse link function $\ell _ { \mathrm { L } } : \mathbb { R } ^ { C } \to \Delta ^ { C - 1 }$ (e.g., the soft-max activation), in which $\sum C - 1$ is the corresponding probability simplex—in other words, $\ell ( f _ { \theta } ( \cdot ) , y ) =$ $\ell _ { \mathrm { B } } ( \ell _ { \mathrm { L } } ( f _ { \theta } ( \cdot ) ) , y )$ . AT employs the most adversarial data generated according to Eq. (2) for updating the current model.
+
+The objective function of friendly adversarial training (FAT) (Zhang et al., 2020b) is
+
+$$
+\tilde { x } _ { i } = \underset { \tilde { x } \in \mathcal { B } _ { \epsilon } [ x _ { i } ] } { \arg \operatorname* { m i n } } \ell ( f _ { \theta } ( \tilde { x } ) , y _ { i } ) \mathrm { ~ s . t . ~ } \ell ( f _ { \theta } ( \tilde { x } ) , y _ { i } ) - \operatorname* { m i n } _ { y \in \mathcal { Y } } \ell ( f _ { \theta } ( \tilde { x } ) , y ) \geq \rho .
+$$
+
+Note that the outer minimization remains the same as Eq. (1), and the operator arg max is replaced by arg min. $\rho$ is a margin of loss values (i.e., the misclassification confidence). The constraint of Eq. (3) firstly ensures $\tilde { x }$ is misclassified, and secondly ensures for $\tilde { x }$ the wrong prediction is better than the desired prediction $y _ { i }$ by at least $\rho$ in terms of the loss value. Among all such $\tilde { x }$ satisfying the constraint, Eq. (3) selects the one minimizing $\ell ( f _ { \theta } ( \tilde { x } ) , y _ { i } )$ by a violation of the value $\rho$ . There are no constraints on ${ \tilde { x } } _ { i }$ if $\tilde { x } _ { i }$ is correctly classified. FAT employs the friendly adversarial data generated according to Eq. (3) for updating the current model.
+
+![](images/3810bd9401f9ce396447a8f469962649a02c6d132d8ad62848f5e49ef15ed1de.jpg)  
+Figure 3: More attackable data (lighter red and blue) are closer to the class boundary; more guarded data (darker red and blue) are farther away from the class boundary. Left panel: Two toy examples. Right panel: The model’s output distribution of two randomly selected classes from the CIFAR-10 dataset. The degree of robustness (denoted by the color gradient) of a data point is calculated based on the least number of iterations $\kappa$ that PGD needs to find its misclassified adversarial variant.
+
+# 2.2 REALIZATIONS
+
+AT and FAT’s objective functions imply the optimization of adversarially robust networks, with one step generating adversarial data and one step minimizing loss on the generated adversarial data w.r.t. the model parameters $\theta$ .
+
+The projected gradient descent method (PGD) (Madry et al., 2018) is the most common approximation method for searching adversarial data. Given a starting point $x ^ { ( 0 ) } \in \mathcal { X }$ and step size $\alpha > 0$ , PGD works as follows:
+
+$$
+\begin{array} { r } { \boldsymbol { x } ^ { ( t + 1 ) } = \Pi _ { \mathcal { B } [ \boldsymbol { x } ^ { ( 0 ) } ] } \big ( \boldsymbol { x } ^ { ( t ) } + \alpha \mathrm { s i g n } ( \nabla _ { \boldsymbol { x } ^ { ( t ) } } \ell \big ( f _ { \theta } ( \boldsymbol { x } ^ { ( t ) } ) , \boldsymbol { y } ) ) \big ) , t \in \mathbb { N } } \end{array}
+$$
+
+until a certain stopping criterion is satisfied. $\ell$ is the loss function; $x ^ { ( 0 ) }$ refers to natural data or natural data perturbed by a small Gaussian or uniformly random noise; $y$ is the corresponding label for natural data; $x ^ { ( t ) }$ is adversarial data at step $t$ ; and $\Pi _ { B _ { \epsilon } [ x _ { 0 } ] } ( \cdot )$ is the projection function that projects the adversarial data back into the $\epsilon$ -ball centered at $x ^ { ( 0 ) }$ if necessary.
+
+There are different stopping criteria between AT and FAT. AT employs a fixed number of iterations $K$ , namely, the PGD- $K$ algorithm (Madry et al., 2018), which is commonly used in many adversarial training methods such as CAT (Cai et al., 2018), DAT (Wang et al., 2019), TRADES (Zhang et al., 2019), and MART (Wang et al., 2020b). On the other hand, FAT employs the misclassification-aware criterion. For example, Zhang et al. (2020b) proposed the early-stopped PGD- $K \tau$ algorithm $\tau \leq$ $K$ ; $K$ is the fixed and maximally allowed iteration number): Once the PGD- $K \tau$ finds the current model misclassifying the adversarial data, it stops the iterations immediately $\mathit { \Omega } ^ { ' \tau } = 0 \mathit { \Omega } _ { . }$ ) or slides a few more steps $( \tau > 0 )$ ). This misclassification-aware criterion is used in the emerging adversarial training methods such as MMA (Ding et al., 2020), FAT (Zhang et al., 2020b), ATES (Sitawarin et al., 2020), and Customized AT (Cheng et al., 2020).
+
+AT can enhance the robustness against adversarial data but, unfortunately, degrades the standard accuracy on the natural data significantly (Madry et al., 2018). On the other hand, FAT has better standard accuracy with near-zero or little degradation of robustness (Zhang et al., 2020b).
+
+Nevertheless, both AT and FAT treat the generated adversarial data equally for updating the model parameters, which is not necessary and sometimes even pessimistic. In the next sections, we introduce our method GAIRAT, which is compatible with existing methods such as AT, FAT, and TRADES. Consequently, GAIRAT can significantly enhance robustness with little or even zero degradation of standard accuracy.
+
+# 3 GEOMETRY-AWARE INSTANCE-REWEIGHTED ADVERSARIAL TRAINING
+
+In this section, we propose geometry-aware instance-reweighted adversarial training (GAIRAT) and its learning objective as well as its algorithmic realization.
+
+# 3.1 MOTIVATIONS OF GAIRAT
+
+Model capacity is often insufficient in adversarial training. In the standard training, the overparameterized networks, e.g., ResNet-18 and even larger ResNet-50, have more than enough model capacity, which can easily fit the natural training data entirely (Zhang et al., 2017). However, the left panel of Figure 2 shows that the model capacity of those over-parameterized networks is not enough for fitting the adversarial data. Under the computational budget of 100 epochs, the networks hardly reach zero error on the adversarial training data. Besides, adversarial training error only decreases by a small constant factor with the significant increase of the model’s parameters. Even worse, a slightly larger perturbation bound $\epsilon _ { \mathrm { t r a i n } }$ significantly uncovers this insufficiency of the model capacity (right panel): Adversarial training error significantly increases with slightly larger $\epsilon _ { \mathrm { t r a i n } }$ . Surprisingly, the standard training error on natural data hardly reaches zero with $\epsilon _ { \mathrm { t r a i n } } = 1 6 / 2 5 5$ .
+
+Adversarial training methods employ the adversarial data to reduce the sensitivity of the model’s output w.r.t. small changes of the natural data (Papernot et al., 2016). During the training process, adversarial data are generated on the fly and are adaptively changed based on the current model to smooth the natural data’s local neighborhoods. The volume of this surrounding is exponentially $( | 1 + \epsilon _ { \mathrm { t r a i n } } | ^ { | \mathcal { X } | } )$ large w.r.t. the input dimension $| \mathcal { X } |$ , even if $\epsilon _ { \mathrm { t r a i n } }$ is small. Thus, this smoothness consumes significant model capacity. In adversarial training, we should carefully leverage the limited model capacity by fitting the important data and by ignoring the unimportant data.
+
+More attackable/guarded data are closer to/farther away from the class boundary. We can measure the importance of the data by their robustness against adversarial attacks. Figure 3 shows that the robustness (more attackable or more guarded) of the data is closely related to their geometric distance from the decision boundary. From the geometry perspective, more attackable data are closer to the class boundary whose adversarial variants are more important to fine-tune the decision boundary for enhancing robustness.
+
+Appendix A contains experimental details of Figures 2 and 3 and more motivation figures.
+
+# 3.2 LEARNING OBJECTIVE OF GAIRAT
+
+Let $\omega ( x , y )$ be the geometry-aware weight assignment function on the loss of adversarial variant $\tilde { x }$ . The inner optimization for generating $\tilde { x }$ still follows Eq. (2) or Eq. (3). The outer minimization is
+
+$$
+\operatorname* { m i n } _ { f _ { \theta } \in \mathcal { F } } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \omega ( x _ { i } , y _ { i } ) \ell ( f _ { \theta } ( \tilde { x } _ { i } ) , y _ { i } ) .
+$$
+
+The constraint firstly ensures that $y _ { i } = \arg \operatorname* { m a x } _ { i } f _ { \theta } ( x _ { i } )$ and secondly ensures that $\omega ( x _ { i } , y _ { i } )$ is a non-increasing function w.r.t. the geometric distance, i.e., the distance from data $x _ { i }$ to the decision boundary, in which $\omega ( x _ { i } , y _ { i } ) \ge 0$ and $\begin{array} { r } { \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \omega ( x _ { i } , y _ { i } ) = 1 } \end{array}$ .
+
+There are no constraints when $y _ { i } \neq \arg \operatorname* { m a x } _ { i } f _ { \theta } ( x _ { i } ) :$ for those $x$ significantly far away from the decision boundary, we may discard them (outliers); for those $x$ close to the decision boundary, we may assign them large weights. In this paper, we do not consider outliers, and therefore we assign large weight to the losses of adversarial data, whose natural counterparts are misclassified. Figure 1 provides an illustrative schematic of the learning objective of GAIRAT.
+
+A burn-in period may be introduced, i.e., during the initial period of the training epochs, $\omega ( x _ { i } , y _ { i } ) =$ 1 regardless of the geometric distance of input $( x _ { i } , y _ { i } )$ , because the geometric distance is less informative initially, when the classifier is not properly learned.
+
+# 3.3 REALIZATION OF GAIRAT
+
+The learning objective Eq. (5) implies the optimization of an adversarially robust network, with one step generating adversarial data and then reweighting loss on them according to the geometric distance of their natural counterparts, and one step minimizing the reweighted loss w.r.t. the model parameters $\theta$ .
+
+We approximate the geometric distance of a data point $( x , y )$ by the least iteration numbers $\kappa ( x , y )$ that the PGD method needs to generate a adversarial variant $\tilde { x }$ to fool the current network, given the
+
+Input: data $x \in \mathcal { X }$ , label $y \in \mathcal { V }$ , model $f$ , loss function $\ell$ , maximum PGD step $K$ , perturbation   
+bound $\epsilon$ , step size $\alpha$   
+Output: adversarial data $\tilde { x }$ and geometry value $\kappa ( x , y )$   
+$\tilde { x } \gets x$ ; $\kappa ( x , y ) \gets 0$   
+while $K > 0$ do if arg maxi $f ( \tilde { x } ) = y$ then $\kappa ( x , y ) \gets \kappa ( x , y ) + 1$ end if $\begin{array} { r l } & { \tilde { x } \gets \Pi _ { \mathcal { B } [ x , \epsilon ] } \big ( \alpha \mathrm { s i g n } ( \nabla _ { \tilde { x } } \ell ( f ( \tilde { x } ) , y ) ) + \tilde { x } \big ) } \\ & { K \gets K - 1 } \end{array}$   
+end while
+
+# Algorithm 2 Geometry-aware instance-dependent adversarial training (GAIRAT)
+
+Input: network $f _ { \theta }$ , training dataset $S = \{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n }$ , learning rate $\eta$ , number of epochs $T$ ,   
+batch size $m$ , number of batches $M$   
+Output: adversarially robust network $f _ { \theta }$   
+for epoch $= 1$ , . . . , $T$ do for mini-batch $\mathbf { \Psi } = 1 , \dots , M$ do Sample a mini-batch $\{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { m }$ from $S$ for $i = 1 , \ldots , m$ (in parallel) do Obtain adversarial data ${ \tilde { x } } _ { i }$ of $x _ { i }$ and geometry value $\kappa ( x _ { i } , y _ { i } )$ by Algorithm 1 Calculate $\omega ( x _ { i } , y _ { i } )$ according to geometry value $\kappa ( x _ { i } , y _ { i } )$ by Eq. 6 end for $\begin{array} { r l } & { \theta  \theta - \eta \nabla _ { \theta } \bigg \{ \sum _ { i = 1 } ^ { m } \frac { \omega ( x _ { i } , y _ { i } ) } { \sum _ { j = 1 } ^ { m } \omega ( x _ { j } , y _ { j } ) } \ell \big ( f _ { \theta } ( \tilde { x } _ { i } ) , y _ { i } \big ) \bigg \} } \end{array}$ end for   
+end for
+
+maximally allowed iteration number $K$ and step size $\alpha$ . Thus, the geometric distance is approximated by $\kappa$ (precisely by $\kappa \times \alpha ,$ ). Thus, the value of the weight function $\omega$ should be non-increasing w.r.t. $\kappa$ . We name $\kappa ( x , y )$ the geometry value of data $( x , y )$ .
+
+How to calculate the optimal $\omega$ is still an open question; therefore, we heuristically design different non-increasing functions $\omega$ . We give one example here and discuss more examples in Appendix C.3 and Section 4.1.
+
+$$
+w ( x , y ) = \frac { ( 1 + \operatorname { t a n h } ( \lambda + 5 \times ( 1 - 2 \times \kappa ( x , y ) / K ) ) ) } { 2 } ,
+$$
+
+where $\kappa / K \in [ 0 , 1 ]$ , $K \in \mathbb { N } ^ { + }$ , and $\lambda \in \mathbb { R }$ . If $\lambda = + \infty$ , GAIRAT recovers the standard AT (Madry et al., 2018), assigning equal weights to the losses of adversarial data.
+
+Algorithm 1 is a geometry-aware PGD method (GA-PGD), which returns both the most adversarial data and the geometry value of its natural counterpart. Algorithm 2 is geometry-aware instancedependent adversarial training (GAIRAT). GAIRAT leverages Algorithms 1 for obtaining the adversarial data and the geometry value. For each mini-batch, GAIRAT reweighs the loss of adversarial data $( \tilde { x } _ { i } , y _ { i } )$ according to the geometry value of their natural counterparts $( x _ { i } , y _ { i } )$ , and then updates the model parameters by minimizing the sum of the reweighted loss.
+
+GAIRAT is a general method. Indeed, FAT (Zhang et al., 2020b) and TRADES (Zhang et al., 2019) can be modified to GAIR-FAT and GAIR-TRADES (see Appendices B.1 and B.2, respectively).
+
+Comparisons with SVM. The abstract concept of GAIRAT has appeared previously. For example, in the support vector machine (SVM), support vectors near the decision boundary are particularly useful in influencing the decision boundary (Hearst et al., 1998). For learning models, the magnitude of the loss function (e.g., the hinge loss and the logistic loss) can naturally capture different data’s geometric distance from the decision boundary. For updating the model, the loss function treats data differently by incurring large losses on important attackable (close to the decision boundary) or misclassified data and incurring zero or very small losses on unimportant guarded (far away from the decision boundary) data.
+
+However, in adversarial training, it is critical to explicitly assign different weights on top of losses on different adversarial data due to the blocking effect: The model trained on the adversarial data that maximize the loss learns to prevent generating large-loss adversarial data. This blocking effect makes the magnitude of the loss less capable of distinguishing important adversarial data from unimportant ones for updating the model parameters, compared with the role of loss on measuring the natural data’s importance in standard training. Our GAIRAT breaks this blocking effect by explicitly extracting data’s geometric information to distinguish the different importance.
+
+Comparisons with AdaBoost and focal loss. The idea of instance-dependent weighting has been studied in the literature. Besides robust estimator (e.g., M-estimator (Boos & Stefanski, 2013)) for learning under outliers (e.g., label-noised data), hard data mining is another branch where our GAIRAT belongs. Boosting algorithms such as AdaBoost (Freund & Schapire, 1997) select harder examples to train subsequent classifiers. Focal loss (Lin et al., 2017) is specially designed loss function for mining hard data and misclassified data. However, the previous hard data mining methods leverage the data’s losses for measuring the hardness; by comparison, our GAIRAT measures the hardness by how difficulty the natural data are attacked (i.e., geometry value $\kappa$ ). This new measurement $\kappa$ sheds new lights on measuring the data’s hardness (Zhu et al., 2021).
+
+Comparisons with related adversarial training methods. Some existing adversarial training methods also “treat adversarial data differently”, but in different ways to our GAIRAT. For example, CAT (Cai et al., 2018), MMA (Ding et al., 2020), and DAT (Wang et al., 2019) methods generate the differently adversarial data for updating model over the training process. CAT utilized the adversarial data with different PGD iterations $K$ . DAT utilized the adversarial data with different convergence qualities. MMA leveraged adversarial data with instance-dependent perturbation bounds $\epsilon$ . Different from those existing methods, our GAIRAT treat adversarial data differently by explicitly assigning different weights on their losses, which can break the blocking effect.
+
+Note that the learning objective of MART (Wang et al., 2020b) also explicitly assigns weights, not directly on the adversarial loss but KL divergence loss (see details in Section C.7). The KL divergence loss helps to strengthen the smoothness within the norm ball of natural data, which is also used in VAT (Miyato et al., 2016) and TRADES (Zhang et al., 2019). Differently from MART, our GAIRAT explicitly assigns weights on the adversarial loss. Therefore, we can easily modify MART to GAIR-MART (see experimental comparisons in Section C.7). Besides, MART assigns weights based on the model’s prediction confidence on the natural data; GAIRAT assigns weights based on how easy the natural data can be attacked (geometry value $\kappa$ ).
+
+Comparisons with the geometric studies of DNN. Researchers in adversarial robustness employed the first-order or second-order derivatives w.r.t. input data to explore the DNN’s geometric properties (Fawzi et al., 2017; Kanbak et al., 2018; Fawzi et al., 2018; Qin et al., 2019; MoosaviDezfooli et al., 2019). Instead, we have a complementary but different argument: Data points themselves are geometrically different regardless of DNN. The geometry value $\kappa$ in adversarial training (AT) is an approximated measurement of data’s geometric properties due to the AT’s smoothing effect (Zhu et al., 2021).
+
+# 4 EXPERIMENTS
+
+In this section, we empirically justify the efficacy of GAIRAT. Section 4.1 shows that GAIRAT can relieve the undesirable robust overfitting (Rice et al., 2020) of the minimax-based adversarial training (Madry et al., 2018). Note that some concurrent studies (Chen et al., 2021a;b) provided various adversarial training strategies, which can also mitigate the issue of robust overfitting. In Section 4.2, we benchmark our GAIRAT and GAIR-FAT using Wide ResNets and compare them with AT and FAT.
+
+In our experiments, we consider $| | \tilde { x } - x | | _ { \infty } \leq \epsilon$ with the same $\epsilon$ in both training and evaluations. All images of CIFAR-10 (Krizhevsky, 2009) and SVHN (Netzer et al., 2011) are normalized into [0, 1].
+
+![](images/11c91c9199ddeb0a8a8709de8dff08b5faf51a169575993e55eb5ebaccb2aec2.jpg)  
+Figure 4: Comparisons of AT $\omega _ { 1 }$ , red lines) and GAIRAT $\omega _ { 2 }$ , blue lines and $\omega _ { 3 }$ , yellow lines) using ResNet-18 on the CIFAR-10 dataset. Upper-left panel shows different weight assignment functions $\omega$ w.r.t. the geometry value $\kappa$ . Bottom-left panel reports the training statistic of the standard AT and calculates the median (dark red circle) and mean (light red cross) of geometry values of all training data at each epoch. Upper-middle and upper-right panels report standard training/test errors and robust training/test errors, respectively. Bottom-middle and bottom-right panels report the loss flatness w.r.t. friendly adversarial test data and most adversarial test data, respectively.
+
+# 4.1 GAIRAT RELIEVES ROBUST OVERFITTING
+
+In Figure 4, we conduct the standard AT (all red lines) using ResNet-18 (He et al., 2016) on CIFAR10 dataset. For generating the most adversarial data for updating the model, the perturbation bound $\epsilon = 8 / 2 5 5$ ; the PGD steps number $K = 1 0$ with step size $\alpha = 2 / 2 5 5$ , which keeps the same as Rice et al. (2020). We train ResNet-18 using SGD with 0.9 momentum for 100 epochs with the initial learning rate of 0.1 divided by 10 at Epoch 30 and 60, respectively. At each training epoch, we collect the training statistics, i.e., the geometry value $\kappa ( x , y )$ of each training data, standard/robust training and test error, the flatness of loss w.r.t. adversarial test data. The detailed descriptions of those statistics and the evaluations are in the Appendix C.1.
+
+Bottom-left panel of Figure 4 shows geometry value $\kappa$ of training data of standard AT. Over the training progression, there is an increasing number of guarded training data with a sudden leap when the learning rate decays to 0.01 at Epoch 30. After Epoch 30, the model steadily engenders a increasing number of guarded data whose adversarial variants are correctly classified. Learning from those correctly classified adversarial data (large portion) will reinforce the existing knowledge and spare little focus on wrongly predicted adversarial data (small portion), thus leading to the robust overfitting. The robust overfitting is manifested by red (dashed and solid) lines in upper-middle and upper-right and bottom-middle and bottom-right panels.
+
+To avoid the large portion of guarded data overwhelming the learning from the rare attackable data, our GAIRAT explicitly give small weights to the losses of adversarial variants of the guarded data. Blue $\left( \omega _ { 2 } \right)$ and yellow $\left( \omega _ { 3 } \right)$ lines in upper-left panel give two types of weight assignment functions that assign instance-dependent weight on the loss based on the geometry value $\kappa$ . In GAIRAT, the model is forced to give enough focus on those rare attackable data.
+
+In GAIRAT, the initial 30 epochs is burn-in period, and we introduce the instance-dependent weight assignment $\omega$ from Epoch 31 onward (both blue and yellow lines in Figure 4). The rest of hyperparameters keeps the same as AT (red lines). From the upper-right panel, GAIRAT (both yellow and blue lines) achieves smaller error on adversarial test data and larger error on training adversarial data, compared with standard AT (red lines). Therefore, our GAIRAT can relieve the issue of the robust overfitting.
+
+Besides, Appendix C contains more experiments such as different learning rate schedules, different choices of weight assignment functions $\omega$ , different lengths of burn-in period, a different dataset (SVHN) and different networks (Small CNN and VGG), which all justify the efficacy of our GAIRAT. Notably, in Appendix C.6, we show the effects of GAIR-FAT on improving FAT.
+
+# 4.2 PERFORMANCE EVALUATION ON WIDE RESNETS
+
+Table 1: Test accuracy of WRN-32-10 on CIFAR-10 dataset   
+
+<table><tr><td rowspan="2">Defense</td><td colspan="6">Best checkpoint</td><td colspan="6">Last checkpoint</td></tr><tr><td>Natural</td><td>Diff.</td><td>PGD-20</td><td>Diff.</td><td>PGD+</td><td>Diff.</td><td>Natural</td><td>Diff.</td><td>PGD-20</td><td>Diff.</td><td>PGD+</td><td>Diff. </td></tr><tr><td>AT</td><td>86.92±0.24</td><td>-</td><td>51.96±0.21</td><td>-</td><td>51.28 ±0.23</td><td>-</td><td>86.62 ±0.22</td><td>-</td><td>46.73±0.08</td><td>-</td><td>46.08±0.07</td><td>-</td></tr><tr><td>FAT</td><td>89.16 ± 0.15</td><td>+2.24</td><td>51.24±0.14</td><td>-0.72</td><td>46.14± 0.19</td><td>-5.14</td><td>88.18±0.19</td><td>+1.56</td><td>46.79±0.34</td><td>+0.06</td><td>45.80±0.16</td><td>-0.28</td></tr><tr><td> GAIRAT</td><td>85.75±0.23</td><td>-1.17</td><td>57.81±0.54</td><td>+5.85</td><td>55.61±0.61</td><td>+4.33</td><td>85.49±0.25</td><td>-1.13</td><td>53.76±0.49</td><td>+7.03</td><td>50.32±0.48</td><td>+4.24</td></tr><tr><td>GAIR-FAT</td><td>88.59±0.12</td><td>+1.67</td><td>56.21±0.52</td><td>+4.25</td><td>53.50±0.60</td><td>+2.22</td><td>88.44±0.10</td><td>+1.82</td><td>50.64±0.56</td><td>+3.91</td><td>47.51 ± 0.51</td><td>+1.43</td></tr></table>
+
+We employ the large-capacity network, i.e., Wide ResNet (Zagoruyko & Komodakis, 2016), on the CIFAR-10 dataset. In Table 1, we compare the performance of the standard AT (Madry et al., 2018), FAT (Zhang et al., 2020b), GAIRAT and GAIR-FAT. We use WRN-32-10 that keeps the same as Madry et al. (2018). We compare different methods on the best checkpoint model (suggested by Rice et al. (2020)) and the last checkpoint model (used by Madry et al. (2018)), respectively. Note that results in Zhang et al. (2020b) only compare the last checkpoint between AT and FAT; instead, we also include the best checkpoint comparisons. We evaluate the robust models based on the three evaluation metrics, i.e., standard test accuracy on natural data (Natural), robust test accuracy on adversarial data generated by PGD-20 and $\mathrm { P G D + }$ . $\mathrm { P G D + }$ is PGD with five random starts, and each start has 40 steps with step size 0.01, which keeps the same as Carmon et al. (2019) $( \mathrm { P G D + }$ has $4 0 \times 5 = 2 0 0$ iterations for each test data). We run AT, FAT, GAIRAT, and GAIR-FAT five repeated trials with different random seeds. Table 1 reports the medians and standard deviations of the results. Besides, we treat the results of AT as the baseline and report the difference (Diff.) of the test accuracies. The detailed training settings and evaluations are in Appendix C.8. Besides, we also compare TRADES and GAIR-TRADES using WRN-34-10, which is in the Appendix C.9.
+
+Compared with standard AT, our GAIRAT significantly boosts adversarial robustness with little degradation of accuracy, which challenges the inherent trade-off. Besides, FAT also challenges the inherent trade-off instead by improving accuracy with little degradation of robustness. Combining two directions, i.e., GAIR-FAT, we can improve both robustness and accuracy of standard AT. Therefore, Table 1 affirmatively confirms the efficacy of our geometry-aware instance-reweighted methods in significantly improving adversarial training.
+
+# 5 CONCLUSION AND FUTURE WORK
+
+This paper has proposed a novel adversarial training method, i.e., geometry-aware instancereweighted adversarial training (GAIRAT). GAIRAT gives more (less) weights to loss of the adversarial data whose natural counterparts are closer to (farther away from) the decision boundary. Under the limited model capacity and the inherent inequality of the data, GAIRAT sheds new lights on improving the adversarial training.
+
+GAIRAT training under the PGD attacks can defend PGD attacks very well, but indeed, it cannot perform equally well on all existing attacks (Chen et al., 2021a). From the philosophical perspective, we cannot expect defenses under one specific attack can defend all existing attacks, which echoes the previous finding that “it is essential to include adversarial data produced by all known attacks, as the defensive training is non-adaptive (Papernot et al., 2016).” Incorporating all attacks in GAIRAT yet preserving the efficiency is an interesting future direction. Besides, it still an open question to design the optimal weight assignment function $\omega$ in Eq. 5 or to design a proper network structure suitable to adversarial training. Furthermore, there is still a large room to apply adversarial training techniques into other domains such as pre-training (Hendrycks et al., 2019; Chen et al., 2020; Jiang et al., 2020; Salman et al., 2020), noisy labels (Zhu et al., 2021) and so on.
+
+# ACKNOWLEDGMENT
+
+JZ, GN, and MS were supported by JST AIP Acceleration Research Grant Number JPMJCR20U3, Japan. MS was also supported by the Institute for AI and Beyond, UTokyo. JNZ and BH were supported by the HKBU CSD Departmental Incentive Scheme. BH was supported by the RGC Early Career Scheme No. 22200720 and NSFC Young Scientists Fund No. 62006202. MK was supported by the National Research Foundation, Singapore under its Strategic Capability Research Centres Funding Initiative.
+
+# REFERENCES
+
+Mislav Balunovic and Martin Vechev. Adversarial training and provable defenses: Bridging the gap. In ICLR, 2020.
+
+Denni D. Boos and L. A. Stefanski. M-Estimation (Estimating Equations), pp. 297–337. Springer New York, New York, NY, 2013.
+
+Qi-Zhi Cai, Chang Liu, and Dawn Song. Curriculum adversarial training. In IJCAI, 2018.
+
+Nicholas Carlini and David A. Wagner. Towards evaluating the robustness of neural networks. In Symposium on Security and Privacy (SP), 2017.
+
+Yair Carmon, Aditi Raghunathan, Ludwig Schmidt, Percy Liang, and John C. Duchi. Unlabeled data improves adversarial robustness. In NeurIPS, 2019.
+
+Chen Chen, Jingfeng Zhang, Xilie Xu, Tianlei Hu, Gang Niu, Gang Chen, and Masashi Sugiyama. Guided interpolation for adversarial training. arXiv:2102.07327, 2021a.
+
+Tianlong Chen, Sijia Liu, Shiyu Chang, Yu Cheng, Lisa Amini, and Zhangyang Wang. Adversarial robustness: From self-supervised pre-training to fine-tuning. In CVPR, 2020.
+
+Tianlong Chen, Zhenyu Zhang, Sijia Liu, Shiyu Chang, and Zhangyang Wang. Robust overfitting may be mitigated by properly learned smoothening. In ICLR, 2021b.
+
+Minhao Cheng, Qi Lei, Pin-Yu Chen, Inderjit Dhillon, and Cho-Jui Hsieh. Cat: Customized adversarial training for improved robustness. arXiv:2002.06789, 2020.
+
+Jeremy M. Cohen, Elan Rosenfeld, and J. Zico Kolter. Certified adversarial robustness via randomized smoothing. In ICML, 2019.
+
+Francesco Croce and Matthias Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In ICML, 2020.
+
+Gavin Weiguang Ding, Yash Sharma, Kry Yik Chau Lui, and Ruitong Huang. Mma training: Direct input space margin maximization through adversarial training. In ICLR, 2020.
+
+Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. The robustness of deep networks: A geometrical perspective. IEEE Signal Processing Magazine, 34(6):50–62, 2017.
+
+Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, Pascal Frossard, and Stefano Soatto. Empirical study of the topology and geometry of deep networks. In CVPR, 2018.
+
+Yoav Freund and Robert E Schapire. A decision-theoretic generalization of on-line learning and an application to boosting. Journal of computer and system sciences, 55(1):119–139, 1997.
+
+Sven Gowal, Chongli Qin, Jonathan Uesato, Timothy Mann, and Pushmeet Kohli. Uncovering the limits of adversarial training against norm-bounded adversarial examples. arXiv:2010.03593, 2020.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Marti A. Hearst, Susan T Dumais, Edgar Osuna, John Platt, and Bernhard Scholkopf. Support vector machines. IEEE Intelligent Systems and their applications, 13(4):18–28, 1998.
+
+Dan Hendrycks, Kimin Lee, and Mantas Mazeika. Using pre-training can improve model robustness and uncertainty. In ICML, 2019.
+
+Ziyu Jiang, Tianlong Chen, Ting Chen, and Zhangyang Wang. Robust pre-training by adversarial contrastive learning. In NeurIPS, 2020.
+
+Can Kanbak, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Geometric robustness of deep networks: analysis and improvement. In CVPR, 2018.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In ICCV, 2017.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional smoothing by virtual adversarial examples. In ICLR, 2016.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Jonathan Uesato, and Pascal Frossard. Robustness via curvature regularization, and vice versa. In CVPR, 2019.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. In NeurIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2011.
+
+Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In CVPR, 2015.
+
+Nicolas Papernot, Patrick McDaniel, Arunesh Sinha, and Michael Wellman. Towards the science of security and privacy in machine learning. arXiv:1611.03814, 2016.
+
+Chongli Qin, James Martens, Sven Gowal, Dilip Krishnan, Krishnamurthy Dvijotham, Alhussein Fawzi, Soham De, Robert Stanforth, and Pushmeet Kohli. Adversarial robustness through local linearization. In NeurIPS, 2019.
+
+Aditi Raghunathan, Sang Michael Xie, Fanny Yang, John Duchi, and Percy Liang. Understanding and mitigating the tradeoff between robustness and accuracy. In ICML, 2020.
+
+Leslie Rice, Eric Wong, and J Zico Kolter. Overfitting in adversarially robust deep learning. In ICML, 2020.
+
+Hadi Salman, Andrew Ilyas, Logan Engstrom, Ashish Kapoor, and Aleksander Madry. Do adversarially robust imagenet models transfer better? In NeurIPS, 2020.
+
+Vikash Sehwag, Shiqi Wang, Prateek Mittal, and Suman Jana. Hydra: Pruning adversarially robust neural networks. NeurIPS, 2020.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+
+Chawin Sitawarin, Supriyo Chakraborty, and David Wagner. Improving adversarial robustness through progressive hardening. arXiv:2003.09347, 2020.
+
+Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15(1): 1929–1958, 2014.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.
+
+Antonio Torralba, Rob Fergus, and William T Freeman. 80 million tiny images: A large data set for nonparametric object and scene recognition. IEEE transactions on pattern analysis and machine intelligence, 30(11):1958–1970, 2008.
+
+Dimitris Tsipras, Shibani Santurkar, Logan Engstrom, Alexander Turner, and Aleksander Madry. Robustness may be at odds with accuracy. In ICLR, 2019.
+
+Yusuke Tsuzuku, Issei Sato, and Masashi Sugiyama. Lipschitz-Margin training: Scalable certification of perturbation invariance for deep neural networks. In NeurIPS, 2018.
+
+Haotao Wang, Tianlong Chen, Shupeng Gui, Ting-Kuei Hu, Ji Liu, and Zhangyang Wang. Oncefor-all adversarial training: In-situ tradeoff between robustness and accuracy for free. In NeurIPS 2020, 2020a.
+
+Yisen Wang, Xingjun Ma, James Bailey, Jinfeng Yi, Bowen Zhou, and Quanquan Gu. On the convergence and robustness of adversarial training. In ICML, 2019.
+
+Yisen Wang, Difan Zou, Jinfeng Yi, James Bailey, Xingjun Ma, and Quanquan Gu. Improving adversarial robustness requires revisiting misclassified examples. In ICLR, 2020b.
+
+Eric Wong and J. Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In ICML, 2018.
+
+Dongxian Wu, Shu-Tao Xia, and Yisen Wang. Adversarial weight perturbation helps robust generalization. NeurIPS, 33, 2020.
+
+Yao-Yuan Yang, Cyrus Rashtchian, Hongyang Zhang, Russ R. Salakhutdinov, and Kamalika Chaudhuri. A closer look at accuracy vs. robustness. In NeurIPS, 2020.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv:1605.07146, 2016.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In ICLR, 2017.
+
+Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P. Xing, Laurent El Ghaoui, and Michael I. Jordan. Theoretically principled trade-off between robustness and accuracy. In ICML, 2019.
+
+Huan Zhang, Hongge Chen, Chaowei Xiao, Sven Gowal, Robert Stanforth, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks. In ICLR, 2020a.
+
+Jingfeng Zhang, Xilie Xu, Bo Han, Gang Niu, Lizhen Cui, Masashi Sugiyama, and Mohan Kankanhalli. Attacks which do not kill training make adversarial learning stronger. In ICML, 2020b.
+
+Jianing Zhu, Jingfeng Zhang, Bo Han, Tongliang Liu, Gang Niu, Hongxia Yang, Mohan Kankanhalli, and Masashi Sugiyama. Understanding the interaction of adversarial training with noisy labels. arXiv:2102.03482, 2021.
+
+![](images/10abe6c06b11558243d668a36527194623749422deddfd65a43a1993699ad0c4.jpg)  
+Figure 5: We plot standard training error (the left two panels) and adversarial training error (the right two panels) over the training epochs of the standard AT on CIFAR-10 dataset. Top two panels: standard AT on different sizes of network. Bottom two panels: standard AT on ResNet-18 under different perturbation bound $\epsilon _ { \mathrm { t r a i n } }$ .
+
+# A MOTIVATIONS OF GAIRAT
+
+We show that model capacity is often insufficient in adversarial training, especially when $\epsilon _ { \mathrm { t r a i n } }$ is large; therefore, the model capacity should be carefully preserved for fitting important data.
+
+In this section, we give experimental details of Figure 2 and provide complementary experiments in Figures 5 and 6. In the left panel of Figure 2 and top two panels of Figure 5, we use standard AT to train different sizes of network under the perturbation bound $\epsilon _ { \mathrm { t r a i n } } ~ = ~ 8 / 2 5 5$ on CIFAR10 dataset. In the right panel of Figure 2 and two bottom panels of Figure 5, we fix the size of network and use ResNet-18; we conduct standard AT under different values of perturbation bound $\epsilon _ { \mathrm { t r a i n } } \in [ 1 / 2 5 5 , 1 6 / 2 5 5 ]$ . The solid lines show the standard training error on natural data and the dash lines show the robust training error on adversarial training data.
+
+Training details We train all the different networks for 100 epochs using SGD with 0.9 momentum. The initial learning rate is 0.1, reduced to 0.01, 0.001 at Epoch 30, and 60, respectively. The weight decay is 0.0005. For generating the most adversarial data for updating the model, we use the PGD-10 attack. The PGD steps number $K = 1 0$ and the step size $\alpha = \epsilon / 4$ . There is a random start, i.e., uniformly random perturbations $( [ - \epsilon _ { \mathrm { t r a i n } } , + \epsilon _ { \mathrm { t r a i n } } ] )$ added to natural data before PGD perturbations for generating PGD-10 training data. We report the standard training error on the natural training data and the robust training error on the adversarial training data that are generated by the PGD-10 attack.
+
+We also conduct the experiments on the SVHN dataset in Figure 6. The training setting keeps the same as that of CIFAR-10 experiments except using 0.01 as the initial learning rate, reduced to 0.001, 0.0001 at Epoch 30, and 60, respectively. We find standard AT always fails when the perturbation bound is larger than $\epsilon = 1 6 / 2 5 5$ for the SVHN dataset due to the severe cross-over mixture issue (Zhang et al., 2020b); therefore, we do not report its results.
+
+![](images/f3b9e76b0ba8c32a51b098c87f479526d23c06297ebf1483e251b723d9f2afbe.jpg)  
+Figure 6: We plot standard training error (the left two panels) and adversarial training error (the right two panels) over the training epochs of the standard AT on SVHN dataset. Top two panels: AT on different sizes of network. Bottom two panels: AT on ResNet-18 under different perturbation bound $\epsilon _ { \mathrm { t r a i n } }$ .
+
+Next, we show that more attackable (more important) data are closer to the decision boundary; more guarded (less important) data are farther away from the decision boundary.
+
+In Figures 7 and 8, we plot 2-d visualizations of the output distributions of a robust ResNet-18 on CIFAR-10 dataset. We take the robust ResNet-18 at the checkpoint of Epoch 30 (red line in Figure 9) as our base model here. For each class in the CIFAR-10 dataset, we randomly sample 1000 training datapoints for visualization. For each data point, we compute its the least number of iterations $\kappa$ that PGD requires to find its misclassified adversarial variant. For PGD, we set the perturbation bound $\epsilon = 0 . 0 3 1$ , the step size $\alpha = 0 . 3 1 / 4$ , and the maximum PGD steps $K = 1 0$ . Then, each data point has its unique robustness attribution, i.e., value $\kappa$ . We take those data as the input of the robust ResNet and output 10-dimensional logits, and then, we use principal components analysis (PCA) to project 10-dimensional logits into 2-dimension for visualization. The color gradient denotes the degree of the robustness of each data point. The more attackable data have lighter colors (red or blue), and the more guarded data has darker colors (red or blue).
+
+From Figures 7 and 8, we find that the attackable data in general are geometrically close to the decision boundary while the guarded data in general are geometrically far away from the decision boundary. It is also very interesting to observe that not all classes are well separated. For example, Cat-Dog is less separable than Cat-Ship in second row of Figure 8.
+
+![](images/36fa10f3c54b30969f18d3d450cec1f80f5c8d6b7607bb466d0c93d3df1ec9d1.jpg)  
+Figure 7: Part A 2-d visualizations of the model’s output distribution of natural training data from two separated classes from CIFAR-10 dataset. The degree of the robustness (denoted by the color gradient) of a datum is calculated based on the least number of iterations $\kappa$ that PGD requires to find its misclassified adversarial variant. The light blue and light red points represent attackable data which are close to the class boundary; the dark blue and dark red points represent the guarded data which are far away from the decision boundary. (Top colorbars corresponds to the value $\kappa$ )
+
+![](images/7dc57567c4c687ff3118e640cecb2b322fa8d826115e58f48816487c47e33f2c.jpg)  
+Figure 8: Part B - 2-d visualizations of the model’s output distribution on CIFAR-10 dataset.
+
+# B ALGORITHMS
+
+B.1 GEOMETRY-AWARE INSTANCE-REWEIGHTED FRIENDLY ADVERSARIAL TRAINING(GAIR-FAT)
+
+Algorithm 3 Geometry-aware early stopped PGD- $K \tau$
+
+Input: data $x \in \mathcal { X }$ , label $y \in \mathcal { V }$ , model $f$ , loss function $\ell$ , maximum PGD step $K$ , step $\tau$ ,   
+perturbation bound $\epsilon$ , step size $\alpha$   
+Output: friendly adversarial data $\tilde { x }$ and geometry value $\kappa ( x , y )$   
+$\tilde { x } \gets x$ ; $\kappa ( x , y ) \dot {  } 0$   
+while $K > 0$ do if arg maxi $f ( \tilde { x } ) \neq y$ and $\tau = 0$ then break else if arg maxi $f ( \tilde { x } ) \neq y$ then $\tau  \tau - 1$ else $\kappa ( x , y ) \gets \kappa ( x , y ) + 1$ end if $\begin{array} { r l } & { \tilde { x } \gets \Pi _ { \mathcal { B } [ x , \epsilon ] } \big ( \alpha \mathrm { s i g n } ( \nabla _ { \tilde { x } } \ell ( f ( \tilde { x } ) , y ) ) + \tilde { x } \big ) } \\ & { K \gets K - 1 } \end{array}$   
+end while
+
+GAIRAT is a general method, and the friendly adversarial training (Zhang et al., 2020b) can be easily modified to a geometry-aware instance-reweighted version, i.e. GAIR-FAT.
+
+GAIR-FAT utilizes Algorithm 3 to generate friendly adversarial data $( \tilde { x } , y )$ and the corresponding geometry value $\kappa ( x , y )$ , and then utilizes Algorithm 2 to update the model parameters.
+
+# B.2 GEOMETRY-AWARE INSTANCE-REWEIGHTED TRADES (GAIR-TRADES)
+
+# Algorithm 4 Geometry-aware PGD for TRADES
+
+Input: data $x \in \mathcal { X }$ , label $y \in \mathcal { V }$ , model $f$ , loss function $\ell _ { K L }$ , maximum PGD step $K$ , perturbation   
+bound $\epsilon$ , step size $\alpha$   
+Output: adversarial data $\tilde { x }$ and geometry value $\kappa ( x , y )$   
+$\tilde { x } \gets \bar { x } + \xi \mathcal { N } ( \mathbf { 0 } , \mathbf { I } )$ ; $\kappa ( x , y ) \gets \bar { 0 }$   
+while $K > 0$ do if arg maxi $f ( \tilde { x } ) = y$ then $\kappa ( x , y ) \gets \kappa ( x , y ) + 1$ end if $\begin{array} { r l } & { \tilde { x }  \Pi _ { B [ x , \epsilon ] } \big ( \alpha \mathrm { s i g n } ( \nabla _ { \tilde { x } } \ell _ { K L } ( f ( \tilde { x } ) , f ( x ) ) + \tilde { x } \big ) } \\ & { K  K - 1 } \end{array}$   
+end while
+
+# Algorithm 5 Geometry-aware instance-reweighted TRADES (GAIR-TRADES)
+
+Input: network $f _ { \theta }$ , training dataset $S = \{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n }$ , learning rate $\eta$ , number of epochs $T$ batch size $m$ , number of batches $M$
+
+Output: adversarially robust network $f _ { \theta }$   
+for epoch $= 1$ , . . . , $T$ do for mini-batch $\mathbf { \Psi } = 1 , \dots , M$ do Sample a mini-batch $\{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { m }$ from $S$ for $i = 1 , \ldots , m$ (in parallel) do Obtain adversarial data $\tilde { x _ { i } }$ of $x _ { i }$ and geometry value $\kappa ( x _ { i } , y _ { i } )$ by Algorithm 4 Calculate $\omega ( x _ { i } , y _ { i } )$ according to geometry value $\kappa ( x _ { i } , y _ { i } )$ by Eq. (6) end for Calculate the normalized ωi = $\begin{array} { r } { \omega _ { i } = \frac { \omega \left( x _ { i } , y _ { i } \right) } { \sum _ { j = 1 } ^ { m } \omega \left( x _ { j } , y _ { j } \right) } } \end{array}$ for each data $\begin{array} { r } { \theta  \theta - \eta \nabla _ { \theta } \sum _ { i = 1 } ^ { m } \{ \omega _ { i } \ell _ { C E } \big ( f _ { \theta } ( x _ { i } ) , y _ { i } \big ) + \beta \ell _ { K L } \big ( f _ { \theta } ( \tilde { x } _ { i } ) , f _ { \theta } ( x _ { i } ) \big ) \} } \end{array}$ end for   
+end for
+
+We modify TRADES (Zhang et al., 2019) to a GAIRAT version, i.e. GAIR-TRADES (Algorithms 4 and 5). Different from GAIRAT and GAIR-FAT, GAIR-TRADES employs Algorithm 4 to generate adversarial data $( \tilde { x } , y )$ and the corresponding geometry value $\kappa ( x , y )$ , and then utilizes both natural data and their adversarial variants to update the model parameters (Algorithm 5). Note that TRADES utilizes virtual adversarial data (Miyato et al., 2016) for updating the current model. The generated virtual adversarial data do not require any label information; therefore, their supervision signals heavily rely on their natural counterparts. Thus, in GAIR-TRADES, the instance-reweighting function $\omega$ applies to the loss of their natural data.
+
+In Algorithm 4, $\mathcal { N } ( \mathbf { 0 } , \mathbf { I } )$ generates a random unit vector. $\xi$ is a small constant. $\ell _ { K L }$ is KullbackLeibler loss. In Algorithm 5, $\beta > 0$ is a regularization parameter for TRADES. $\ell _ { C E }$ is cross-entropy loss. $\ell _ { K L }$ is Kullback-Leibler loss, which keeps the same as Zhang et al. (2019).
+
+![](images/863905d8514e1524e710e78b80a9c9d9af2b4931d7a3da12d7c7f67cf260bea4.jpg)  
+Figure 9: Illustration of the reasons for the issue of robust overfitting.
+
+# C EXTENSIVE EXPERIMENTS
+
+# C.1 GAIRAT RELIEVES ROBUST OVERFITTING
+
+In this section, we give the detailed descriptions of Figure 4 and provide more analysis and complementary experiments using the SVHN dataset in Figure 10.
+
+In Figure 4, red lines (solid and dashed lines) refer to standard adversarial training (AT) (Madry et al., 2018). Blue and yellow lines (solid and dashed) refer to our geometry-aware instance-reweighted adversarial training (GAIRAT). Blue lines represent that GAIRAT utilizes the decreasing $\omega$ for assigning instance-dependent weights (corresponding to the blue line in the bottom-left panel); yellow lines represent that GAIRAT utilizes the non-increasing piece-wise $\omega$ for assigning instancedependent weights (corresponding to the yellow line in the bottom-left panel). In the upper-left panel of Figure 4, we calculate the mean and median of geometry values $\kappa ( x , y )$ of all 50K training data at each epoch. Geometry value $\kappa ( x , y )$ of data $( x , y )$ refers to the least number of PGD steps that PGD methods need to generate a misclassified adversarial variant. Note that when the natural data is misclassified without any adversarial perturbations, the geometry value $\kappa ( x , y ) = 0$ . The bottom-left panel calculates the instance-dependent weight $\omega$ for the loss of adversarial data based on the geometry value $\kappa$ .
+
+In the upper-middle panel of Figure 4, the solid lines represent the standard training error on the natural training data; the dashed lines represent the standard test error on the natural test data.
+
+In the upper-right panel of Figure 4, the solid lines represent the robust training error on the adversarial training data; the dashed lines represent the robust test error on the adversarial test data. The adversarial training/test data are generated by PGD-20 attack with random start. Random start refers to the uniformly random perturbation of $[ - \epsilon , \epsilon ]$ added to the natural data before PGD perturbations. The step size $\dot { \alpha } = 2 / 2 5 5$ , which is the same as Wang et al. (2019).
+
+In the bottom-middle and bottom-right panels of Figure 4, we calculate the flatness of the adversarial loss $\ell ( f _ { \theta } ( \tilde { x } ) , \tilde { x } ) )$ w.r.t. the adversarial data $\tilde { x }$ . In the bottom-middle panel, adversarial data refer to the friendly adversarial test data that are generated by early-stopped PGD-20-0 (Zhang et al., 2020b). The maximum PGD step number is 20; $\tau = 0$ means the immediate stop once the wrongly predicted adversarial test data are found. We use friendly adversarial test data to approximate the points on decision boundary of the robust model $f _ { \theta }$ . The flatness of the decision boundary is approximated by average of $| | \nabla _ { \widetilde { \widetilde { x } } } \ell | |$ across all 10K adversarial test data. We give the flatness value at each training epoch (higher flatness value refers to higher curved decision boundary, see Figure 9).
+
+![](images/7cc825930a80fdf2c0971ed7b36edb66a4a03262811e48d48d03665d46d39cb5.jpg)  
+Figure 10: Comparisons of AT ( $\omega _ { 1 }$ , red lines) and GAIRAT ${ \bf \Pi } _ { \omega _ { 2 } }$ , blue lines and $\omega _ { 3 }$ , yellow lines) using ResNet-18 on SVHN dataset. Upper-left panel shows different instance-dependent weight assignment functions $\omega$ w.r.t. the geometry value $\kappa$ . Bottom-left panel reports the standard AT training statistic and calculates the median (dark red circle) and mean (light red cross) of geometry values of all training data at each epoch. Upper-middle and upper-right panels report natural training/test errors and robust training/test errors, respectively. Bottom-middle and bottom-right panels report the loss flatness w.r.t. friendly adversarial test data and most adversarial test data, respectively.
+
+For completeness, the bottom-right panel uses the most adversarial test data that are generated by PGD-20 (Madry et al., 2018).
+
+The magnitude of the norm of gradients, i.e., $| | \nabla _ { \tilde { x } } \ell | |$ , is a reasonable metric for measuring the magnitude of curvatures of the decision boundary. Moosavi-Dezfooli et al. (2019) show the magnitude of the norm of gradients upper bound the largest eigenvalues of the hessian matrix of loss w.r.t. input $x$ , thus measuring the curvature of the decision boundary. Besides, Moosavi-Dezfooli et al. (2019) even show that the low curvatures can lead to the enhanced robustness, which echoes our results in Figure 4.
+
+The flatness values (red lines) increases abruptly at smaller learning rates (0.01, 0.001) at Epoch 30 and Epoch 60. It shows that when we begin to use adversarial data to fine-tune the decision boundary of the robust model, the decision boundary becomes more tortuous around the adversarial data (see Figure 9). This leads to the severe overfitting issue.
+
+Similar to Figure 4, we compare GAIRAT and AT using the SVHN dataset, which can be found in Figure 10. Experiments on the SVHN dataset corroborate the reasons for issue of the robust overfitting and justify the efficacy of our GAIRAT. The training and evaluation settings keep the same as Figure 4 except the initial rate of 0.01 divided by 10 at Epoch 30 and 60 respectively.
+
+# C.2 DIFFERENT LEARNING RATE SCHEDULES
+
+In Figure 11, we compare our GAIRAT and AT using different learning rate schedules. Under the different learning rate schedules, our GAIRAT can relieve the undesirable issue of the robust overfitting, thus enhancing the adversarial robustness. To make the fair comparisons with Rice et al. (2020), we use the pre-activation ResNet-18 (He et al., 2016). We conduct standard adversarial training (AT) using SGD with 0.9 momentum for 200 epochs on CIFAR-10 dataset. The different learning rate schedules are in the top panel in Figure 11. The perturbation bound $\epsilon = 8 / 2 5 5$ , the
+
+![](images/3d299bb68987582d7229301758e347dcaf08d4b570cccd1eccf642b0d6945a40.jpg)  
+Figure 11: The training results of standard AT and GAIRAT using pre-activation ResNet-18 under different learning rate schedules on CIFAR-10 dataset. The top panel reports the different learning rate schedules. The four middle panels report the robust test error on adversarial data generated by PGD-20. The four bottom panels report the standard test error on natural data. The red lines represent AT’s results under different learning rate schedules. The brown, green, blue and orange lines represent GAIRAT’s results of different learning rate schedules.
+
+PGD steps number $K = 1 0$ and the step size $\alpha = 2 / 2 5 5$ . The training setting keeps the same as Rice et al. $( 2 0 2 0 ) ^ { 1 }$ .
+
+GAIRAT has the same training configurations (including all hyperparamter settings) including the 100 epochs burn-in period, after which, GAIRAT begins to introduce geometry-aware instancereweighted loss. We use the weight assignment function $\omega$ from Eq. (6) with $\lambda = - 1$ .
+
+At each training epoch, we evaluate each checkpoint using CIFAR-10 test data. In the middle panels of Figure 11, we report robust test error on the adversarial test data. The adversarial test data are generated by PGD-20 attack with the perturbation bound $\epsilon = 8 / 2 5 5$ and step size $\alpha = 2 / 2 5 5$ . The PGD attack has a random start, i.e, the uniformly random perturbations of $[ - \epsilon , \epsilon ]$ are added to the natural data before PGD iterations, which keeps the same as Wang et al. (2019); Zhang et al. (2020b). Note that different from Rice et al. (2020) using PGD-10, we use PGD-20 because under the computational budget, PGD-20 is a more informative metric for the robustness evaluation. In the bottom panels of Figure 11, we report the standard test error on the natural data.
+
+Figure 11 shows that under different learning rate schedules, our GAIRAT can relieve the issue of robust overfitting, thus enhancing the adversarial robustness with little degradation of accuracy.
+
+# C.3 DIFFERENT WEIGHT ASSIGNMENT FUNCTIONS $\omega$
+
+The weight assignment functions $\omega$ should be non-increasing w.r.t. the geometry value $\kappa$ . In Figure 12, besides tanh-type Eq. (6) (blue line), we compare different types of weight assignment functions. The purple lines represent a linearly decreasing function, i.e.,
+
+$$
+w ( x , y ) = 1 - \frac { \kappa ( x , y ) } { K + 1 } .
+$$
+
+![](images/50f83f401b492792de3e867601fa5eabbd659f5873789c4ea0377ac5c3cdd668.jpg)  
+Figure 12: Comparisons of GAIRAT with different weight assignment functions on CIFAR-10 dataset. When GAIRAT takes constant $\omega = 1$ over the training epochs, GAIRAT recovers the standard adversarial training (AT) (red lines).
+
+The green lines represent a sigmoid-type decreasing function, i.e.,
+
+$$
+w ( x , y ) = \sigma ( \lambda + 5 \times ( 1 - 2 \times \kappa ( x , y ) / K ) ) ,
+$$
+
+where $\begin{array} { r } { \sigma ( x ) = \frac { 1 } { 1 + e ^ { - x } } } \end{array}$ .
+
+Figure 12 shows that compared with AT, GAIRAT with different weight assignment functions have similar degradation of standard test accuracy on natural data, but GAIRAT with the tanh-type decreasing function (Eq. (6)) has the better robustness accuracy. Thus, we further explore the Eq. (6) with different $\lambda$ in Figure 13.
+
+![](images/07485c7f6ec6d8c660352febc3cc4fc7fadd3d400272b777973fe400bea0380b.jpg)  
+Figure 13: Comparisons of GARAT using the tanh-type weight assignment function (Eq. (6)) with different $\lambda$ on CIFAR-10 dataset.
+
+In Figure 13, when $\lambda = + \infty$ , GAIRAT recovers the standard AT, assigning equal weights to the losses of the adversarial data. Smaller $\lambda$ corresponds to the weight assignment function $\omega$ , assigning relatively smaller weight to the loss of the adversarial data of the guarded data and assigning relatively larger weight to the loss of the adversarial data of the attackable data, which enhance the robustness more. With the same logic, larger $\lambda$ corresponds to the weight assignment function $\omega$ , assigning relatively larger weight to the loss of the adversarial data of the guarded data and assigning relatively smaller weight to the loss of the adversarial data of the attackable data, which enhances the robustness less. The guarded data need more PGD steps $\kappa$ to fool the current model; the attackable data need less PGD steps $\kappa$ to fool the current model.
+
+The results in Figure 13 justify the above logic. GAIRAT with smaller $\lambda$ (lighter blue lines) has better adversarial robustness with bigger degradation of standard test accuracy. On the other hand GAIRAT with larger $\lambda$ (darker blue lines) has relatively worse adversarial robustness with minor degradation of standard test accuracy. Nevertheless, our GAIRAT (light and dark lines) has better robustness than AT (red lines).
+
+Training and evaluation details We training ResNet-18 using SGD with 0.9 momentum for 100 epochs. The initial learning rate is 0.1 divided by 10 at Epoch 30 and 60 respectively. The weight decay $= 0 . 0 0 0 5$ . The perturbation bound $\epsilon = 0 . 0 3 1$ ; the PGD step size $\alpha = 0 . 0 0 7$ , and PGD step numbers $K = 1 0$ . For evaluations, we obtain standard test accuracy for natural test data and robust test accuracy for adversarial test data. The adversarial test data are generated by PGD-20 attack with the same perturbation bound $\epsilon = 0 . 0 3 1$ and the step size $\alpha = 0 . 0 3 1 / 4$ , which keeps the same as Wang et al. (2019). All PGD generation have a random start, i.e, the uniformly random perturbation of $[ - \epsilon , \epsilon ]$ added to the natural data before PGD iterations.
+
+Note that the robustness reflected by PGD-20 test data is quite high. However, when we use other attacks such as $\mathbf { C } \& \mathbf { W }$ attack (Carlini & Wagner, 2017) for evaluation, both blue and red lines will degrade the robustness to around $4 0 \%$ . We believe this degradation is due to the mismatch between PGD-adversarial training and C&W attacks, which is the common deflect of the empirical defense (Tsuzuku et al., 2018; Wong & Kolter, 2018; Cohen et al., 2019; Balunovic & Vechev, 2020; Zhang et al., 2020a). We leave this for future work.
+
+![](images/cf2c104bcf57f1fccd8a386d650266c305a9bc48fbd39595c8fe60abbe608511.jpg)  
+Figure 14: Comparisons of GARAT using the tanh-type weight assignment function (Eq. (6)) with different $\lambda$ on SVHN dataset.
+
+In Figure 14, we also conduct experiments of GAIRAT using Eq. (6) with different $\lambda$ and AT using ResNet-18 on SVHN dataset. The training and evaluation settings keep the same as Figure 13 except the initial rate of 0.01 divided by 10 at Epoch 30 and 60 respectively.
+
+Interestingly, AT (red lines) on SVHN dataset has not only the issue of robust overfitting, but also the issue of natural overfitting: The standard test accuracy has slight degradation over the training epochs. By contrast, our GAIRAT (blue lines) can relieve the undesirable robust overfitting, thus enhancing both robustness and accuracy.
+
+# C.4 DIFFERENT LENGTHS OF BURN-IN PERIOD
+
+![](images/b33f95bf3331631adfb22291b4acf1ab3b6b076f0b08378af960908fedbc3f2e.jpg)  
+Figure 15: Comparisons of GAIRAT (blue lines) with different lengths of the burn-in period on CIFAR-10 dataset. The longer GAIRAT has the burn-in period, the more alike GAIRAT becomes standard AT (red lines). AT can be seen as GAIRAT with 100 epochs burn-in period. Darker blue lines represent shorter lengths of burn-in period; lighter blue lines represent longer lengths of burn-in period.
+
+In Figure 15, we conduct experiments of GAIRAT under different lengths of the burn-in period using ResNet-18 on CIFAR-10 dataset. The training and evaluations details are the same as Appendix C.3 except the different lengths of burn-in period in the training.
+
+Figure 15 shows that compared with AT (red lines), GAIRAT with a shorter length of burn-in period (darker blue lines) can significantly enhance robustness but suffers a little degradation of accuracy. On the other hand, GAIRAT with a longer length of burn-in period (lighter blue lines) slightly enhance robustness with zero degradation of accuracy.
+
+![](images/0414f0d2c7a9c3e6c7978e6b01eee374ac9097c13a34afeebe1156dd29ea2ee6.jpg)  
+Figure 16: Comparisons of different networks (VGG-13, Small CNN and ResNet-18) which GAIRAT and AT use on CIFAR-10 dataset.
+
+In Figure 16, besides ResNet-18, we apply our GAIRAT to Small CNN (6 convolutional layers and 2 fully-connected layers) on CIFAR-10 dataset. Training and evaluation settings keeps the same as the Appendix C.3; we use 30 epochs burn-in period and Eq. (6) as the weight assignment function.
+
+Figure 16 shows that larger network ResNet-18 has better performance than Small CNN in terms of both robustness and accuracy. Interestingly, Small CNN has less severe issue of the robust overfitting. Nevertheless, our GAIRAT are still quite effective in relieving the robust overfitting and thus enhancing robustness in the smaller network.
+
+In Figure 16, we also compare our GAIRAT with AT using VGG-13 (Simonyan & Zisserman, 2015) on CIFAR-10 dataset. Under the same training and evaluation settings as Small CNN, results of VGG-13 once again demonstrate the efficacy of our GAIRAT.
+
+# C.6 GEOMETRY-AWARE INSTANCE DEPENDENT FAT (GAIR-FAT)
+
+In this section, we show that GAIR-FAT can enhance friendly adversarial training (FAT). Our geometry-aware instance-reweighted method is a general method. Besides AT, we can easily modify friendly adversarial training (FAT) (Zhang et al., 2020b) to GAIR-FAT (See Algorithm 3 in the Appendix B.1).
+
+In Figure 17, we compare FAT and GAIR-FAT using ResNet-18 on CIFAR-10 dataset. The training and evaluation settings keeps the same as Appendix C.3 except that GAIR-FAT and FAT has an extra hyperparameter $\tau$ . In Figures 17, the $\tau$ begins from 0 and increases by 3 at Epoch 40 and 70 respectively. The burn-in period is 70 epochs. In Figure 17, we use Eq. (6) with different $\lambda$ as GAIR-FAT’s weight assignment function.
+
+Different from AT, FAT has slower progress in enhancing the adversarial robustness over the training epochs, so FAT can naturally resist undesirable robust overfitting. However, once the robust test accuracy reaches plateau, FAT still suffers a slight robust overfitting issue (red line in the right panel). By contrast, when we introduce our instance dependent loss from Epoch 70, GAIR-FAT (light and dark blue lines) can get further enhanced robustness with near-zero degradation of accuracy.
+
+![](images/515d2d8738d643d6f27a683cdb7d1d8089b5b582632a624409bfa3b43208ed58.jpg)  
+Figure 17: We compare FAT and GAIR-FAT using ResNet-18 on CIFAR-10 dataset using tanh-type weight assignment function with different $\lambda$ .
+
+![](images/66deb3e9496e551aa4748871ffb79f7df24971264e204611dd05d6d6bb55bb9d.jpg)  
+Figure 18: Comparisons of GAIR-FAT and FAT under different schedules of dynamical $\tau$ using ResNet-18 on CIFAR-10 dataset. $( \tau { : } 0 \ – 1 \ – 2 )$ refers to $\tau$ starting from 0 and increasing by 1 at Epoch 40 and 70, respectively. $( \tau ; ~ 0 { - } 2 – 4 )$ refers to $\tau$ starting from 0 and increasing by 2 at Epoch 40 and 70, respectively. $\tau$ : 0-3-6) refers to $\tau$ starting from 0 and increasing by 3 at Epoch 40 and 70, respectively.
+
+Note that different from the FAT used by Zhang et al. (2020b) increasing $\tau$ from 0 to 2 over the training epochs, we increase the $\tau$ from 0 to 6. As shown in Figure 18, we find out FAT with smaller $\tau$ (e.g., 1-3) does not suffer the issue of the robust overfitting, since the FAT with smaller $\tau$ has the slower progress in increasing the robustness over the training epochs. This slow progress leads to the slow increase of the portion of guarded data, which is less likely to overwhelm the learning from the attackable data. Thus, our geometry-aware instance dependent loss applied on FAT with smaller $\tau$ does not offer extra benefits, and it does not have damage as well.
+
+![](images/4a37f3ce12a98d513c81b3bba21ae3b26521a1334dd73e70c351b9ab7dc00dd5.jpg)  
+Figure 19: We compare MMA, MART and GAIR-MART with different weight assginment functions using ResNet-18 on CIFAR-10.
+
+In this section, we compare our method with MMA (Ding et al., 2020) and MART (Wang et al., 2020b). To be specific, we easily modify MART to a GAIRAT version, i.e., GAIR-MART. The learning objective of MART is Eq. (9); the learning objective of our GAIR-MART is Eq. (10).
+
+The learning objective of MART is
+
+$$
+\ell _ { m a r g i n } ( p ( \tilde { x } , \theta ) , y ) + \beta \ell _ { K L } ( p ( \tilde { x } , \theta ) , p ( x , \theta ) ) \cdot ( 1 - p _ { y } ( x , \theta ) ) ;
+$$
+
+our learning objective of of GAIR-MART is
+
+$$
+\ell _ { G A I R _ { m a r g i n } } ( p ( \tilde { x } , \theta ) , y ) + \beta \ell _ { K L } ( p ( \tilde { x } , \theta ) , p ( x , \theta ) ) \cdot ( 1 - p _ { y } ( x , \theta ) ) ,
+$$
+
+where $\ell _ { m a r g i n } = - \log ( p _ { y } ( \tilde { x } , \theta ) ) - \log ( 1 - \operatorname* { m a x } _ { k \neq y } p _ { k } ( \tilde { x } , \theta ) )$ and $p _ { k } ( x , \theta )$ is probability (softmax on logits) of $x$ belonging to class $k$ . To be specific, the first term $- \log ( p _ { y } ( \tilde { x } , \theta ) )$ is commonly used CE loss and the second term $- \log ( 1 - \operatorname* { m a x } _ { k \neq y } p _ { k } ( \tilde { x } , \theta ) )$ is a margin term used to improve the decision margin of the classifier. More detailed analysis about the learning objective can be found in (Wang et al., 2020b). In Eq. (9) and Eq. (10), $x$ is natural training data, $\tilde { x }$ is adversarial training data generated by CE loss, and $\beta > 0$ is a regularization parameter for MART. In Eq. (10), $\ell _ { G A I R _ { m a r g i n } } = - \log ( p _ { y } ( \tilde { x } , \theta ) ) \cdot \omega - \log ( 1 - \operatorname* { m a x } _ { k \neq y } p _ { k } ( \tilde { x } , \theta ) )$ and $\omega$ refers to our weight assignment function.
+
+For MMA and MART, the training settings keep the same as the 2 and 3. For fair comparisons, GAIR-MART keeps the same training configurations as MART except that we use the weight assignment function $\omega$ (Eq.(6)) to introduce geometry-aware instance-reweighted loss from Epoch 75 onward. We train ResNet-18 on CIFAR-10 dataset for 120 epochs. For MMA, the learning rate is 0.3 from Iteration 0 to 20000, 0.09 from Iteration 20000 to 30000, 0.03 from Iteration 30000 to 40000, and 0.009 after Iteration 40000, where the Iteration refers to training with one mini-batch of data; For MART and GAIR-MART, the learning rate is 0.01 divided by 10 at Epoch 75, 90, and 100 respectively. For evaluations, we obtain standard test accuracy for natural test data and robust test accuracy for PGD-20 adversarial test data with the same settings as Appendix C.3.
+
+Figure 19 shows GAIR-MART performs better than MART and MMA. The results demonstrate the efficacy of our GAIRAT method on improving robustness without the degradation of standard accuracy.
+
+Reweighing KL loss The learning objective of MART explicitly assigns weights, not directly on the adversarial loss but KL divergence loss. We ask what if you replace their reweighting scheme $( 1 - p _ { y } ( x , \theta ) )$ with our $\omega$ . The learning objective is
+
+$$
+\ell _ { m a r g i n } ( p ( \tilde { x } , \theta ) , y ) + \beta \ell _ { K L } ( p ( \tilde { x } , \theta ) , p ( x , \theta ) ) \cdot \omega .
+$$
+
+Figure 20 reports the results: It does not have much effect on adding the geometry-aware instancedependent weight to the regularization part, i.e., KL divergence loss .
+
+![](images/4f5fe36f676be850362c6401458eebd535af9307643ca69a76294a04978a9736.jpg)  
+Figure 20: Comparison of MART and GAIR-MART training ResNet-18 with Eq. (11) on CIFAR-10 dataset.
+
+# C.8 PERFORMANCE EVALUATION ON WIDE RESNET (WRN-32-10)
+
+In Table 1, we compare our GAIRAT, GAIR-FAT with standard AT and FAT. CIFAR-10 dataset is normalized into [0,1]: Each pixel is scaled by 1/255. We perform the standard CIFAR-10 data augmentation: a random 4 pixel crop followed by a random horizontal flip. In AT, we train WRN32-10 for 120 epochs using SGD with 0.9 momentum. The initial learning rate is 0.1 reduced to 0.01, 0.001 and 0.0005 at epoch 60, 90 and 110. The weight decay is 0.0002. For generating the adversarial data for updating the model, the perturbation bound $\epsilon _ { \mathrm { t r a i n } } = 0 . 0 3 1$ , the PGD step is fixed to 10, and the step size is fixed to 0.007. The training settings come from FAT’s Github. 4 In GAIRAT, we choose 60 epochs burn-in period and then use Eq. (6) with $\lambda = 0$ as the weight assignment function; the rest keeps the same as AT. The hyperparameter $\tau$ of FAT and begins from 0 and increases by 3 at Epoch 40 and 70 respectively; the rest keeps the same as AT. In GAIR-FAT, we choose 60 epochs burn-in period and then use Eq. (6) with $\lambda = 0$ as the weight assignment function; the rest keeps the same as FAT.
+
+As suggested by results of the experiments in Section 4.1, the robust test accuracy usually gets significantly boosted when the learning rate is firstly reduced to 0.01. Thus, we save the model checkpoints at Epochs 59-100 for evaluations, among which, the best checkpoint is selected based on the PGD-20 attack since $\mathrm { P G D + }$ is extremely computationally expensive. We also save the last checkpoint at Epoch 120 for evaluations. We run AT, FAT, GAIRAT and GAIR-FAT with 5 repeated times with different random seeds.
+
+As for the evaluations, we test the checkpoint using three metrics: standard test accuracy on natural data (Natural), robust test accuracy on adversarial data generated by PGD-20 and $\mathrm { P G D + }$ . PGD20 follows the same setting of the PGD-20 used by Wang et al. $( 2 0 1 9 ) ^ { 5 }$ . $\mathrm { P G D + }$ is the same as $P G _ { o u r s }$ used by Carmon et al. $( 2 0 1 9 ) ^ { 6 }$ . The adversarial attacks have the same perturbation bound $\epsilon _ { t e s t } = 0 . 0 3 1$ . For PGD-20, the step number is 20, and the step size $\alpha = \bar { \epsilon } _ { t e s t } / 4$ . There is a random start, i.e., uniformly random perturbations $( [ - \epsilon _ { t e s t } , + \epsilon _ { t e s t } ] )$ added to natural data before PGD perturbations. For $\mathrm { P G D + }$ , the step number is 40, and the step size $\alpha = 0 . 0 1$ . There are 5 random starts for each natural test data. Therefore, for each natural test data, we have $4 0 \times 5 = 2 0 0$ PGD iterations for the robustness evaluation.
+
+In Table 1, the best checkpoint is chosen among the model checkpoints at Epochs 59-100 (selected based on the robust accuracy on PGD-20 test data). In practice, we can use a hold-out validation set to determine the best checkpoint, since (Rice et al., 2020) found the validation curve over epochs matches the test curves over epochs. The last checkpoint is the model checkpoint at Epoch 120. Our experiments find that GAIRAT reaches the best robustness at Epoch 90 (three trails) and 92 (two trails), and AT reaches the best robustness at Epoch 60 (five trails). FAT reaches the best robustness at Epoch 60 (four trails) and 61 (one trail). GAIR-FAT reaches the best robustness at around Epoch 90 (five trails). We report the median test accuracy and its standard deviation over 5 repeated trails.
+
+PGD attacks with different iterations In Table 1, each defense method has five trails with five different random seeds; therefore, each defense method has ten models (five last checkpoints and five best checkpoints). In Figure 21, for each defense, we randomly choose one last-checkpoint and one best-checkpoint and evaluate them using PGD-10, PGD-20, PGD-40, PGD-60, PGD-80, and PGD-100. All the PGD attacks use the same $\epsilon _ { t e s t } = 0 . 0 3 1$ and the step size $\alpha = ( 2 . 5 \cdot \epsilon _ { t e s t } ) / 1 0 0$ . We ensure that we can reach the boundary of the $\epsilon$ -ball from any starting point within it and still allow for movement on the boundary, which is suggested by Madry et al. (2018). The results show the PGD attacks have converged with more iterations.
+
+![](images/8b207fdf6b87a8ac20d2b80fe08db94dbcef722a72c5e4ae4de4d96644bc15b5.jpg)  
+Figure 21: Comparison of PGD attacks with different PGD iterations on CIFAR-10 dataset.
+
+# C.9 PERFORMANCE EVALUATION ON WIDE RESNET (GAIR-TRADES)
+
+Table 2: Test accuracy of TRADES and GAIR-TRADES (WRN-34-10) on CIFAR-10 dataset   
+
+<table><tr><td rowspan="2">Defense</td><td colspan="3">Best checkpoint</td><td colspan="3">Last checkpoint</td></tr><tr><td>Natural</td><td>PGD-20</td><td>PGD+</td><td>Natural</td><td>PGD-20</td><td>PGD+</td></tr><tr><td>TRADES (β= 6)</td><td>84.88±0.35</td><td>56.43± 0.24</td><td>54.33±0.38</td><td>85.66±0.33</td><td>53.31± 0.25</td><td>50.11± 0.25</td></tr><tr><td>GAIR-TRADES (β = 6)</td><td>86.99 ± 0.31</td><td>63.32 ± 0.50</td><td>56.77 ± 0.87</td><td>86.86 ± 0.26</td><td>60.65 ± 1.00</td><td>52.70± 0.93</td></tr></table>
+
+In Table 2, we compare our GAIR-TRADES with TRADES. CIFAR-10 dataset normalization and augmentations keep the same as Appendix C.8. Instead, we use WRN-34-10, which keeps the same as Zhang et al. (2020b). We train WRN-34-10 for 100 epochs using SGD with 0.9 momentum. The initial learning rate is 0.1 reduced to 0.01 and 0.01 at epoch 75 and 90. The weight decay is 0.0002. For generating the adversarial data for updating the model, the perturbation bound $\epsilon _ { \mathrm { t r a i n } } = 0 . 0 3 1$ , the PGD step is fixed to 10, and the step size is fixed to 0.007. Since TRADES has a trade-off parameter $\beta$ , for fair comparison, our GAIR-TRADES uses the same $\beta = 6$ . In GAIR-TRADES, we choose 75 epochs burn-in period and then use Eq. (6) with $\lambda = - 1$ as the weight assignment function. We run TRADES and GAIR-TRADES five repeated trails with different random seeds.
+
+The evaluations are the same as Appendix C.8 except the step size $\alpha = 0 . 0 0 3$ for PGD-20 attack, which keeps the same as Zhang et al. $( 2 0 2 0 \mathrm { b } ) ^ { 7 }$ .
+
+In Table 2, the best checkpoint is chosen among the model checkpoints at Epochs 75-100 (w.r.t. the PGD-20 robustness). The last checkpoint is evaluated based on the model checkpoint at Epoch 100. Our experiments find that GAIR-TRADES reaches the best robustness at Epoch 90 (three trails), 96 (one trail) and 98 (one trail), and TRADES reaches the best robustness at Epoch 76 (three trail), 77 (one trails) and 79 (one trail). We report the median test accuracy and its standard deviation over 5 repeated trails.
+
+Table 2 shows that our GAIR-TRADES can have both improved accuracy and robustness.
+
+# C.10 BENCHMARKING ROBUSTNESS WITH ADDITIONAL UNLABELED (U) DATA
+
+In this section, we verify the efficacy of our GAIRAT method by utilizing additional 500K U data pre-processed by Carmon et al. (2019) for CIFAR-10 dataset.
+
+Carmon et al. (2019) scratched additional U data from 80 Million Tiny Images (Torralba et al., 2008); then, they used standard training to obtain a classifier to give pseudo labels to those U data.
+
+Among those U data, they selected 500K U data (with pseudo labels). Combining 50K labeled CIFAR-10’s training data and pseudo-labeled 500K U data, they propose a robust training method named RST which utilized the learning objective function of TRADES, i.e.,
+
+$$
+\ell _ { C E } ( f _ { \theta } ( x ) , y ) + \beta \ell _ { K L } ( f _ { \theta } ( \tilde { x } ) , f _ { \theta } ( x ) ) ,
+$$
+
+where $\tilde { x }$ is generated by PGD-10 attack with CE loss.
+
+Based on the RST method, we introduce our instance-reweighting mechanism, i.e., our GAIR-RST. To be specific, we change the learning objective function to
+
+$$
+\ell _ { C E } ( f _ { \theta } ( x ) , y ) + \beta \left\{ \omega \ell _ { K L } ( f _ { \theta } ( \tilde { x } ) , f _ { \theta } ( x ) ) + ( 1 - \omega ) \ell _ { K L } ( f _ { \theta } ( \tilde { x } _ { C W } ) , f _ { \theta } ( x ) ) \right\} ,
+$$
+
+where the ${ \tilde { x } } _ { C W }$ refers to the adversarial data generated by $\mathbf { C } \& \mathbf { W }$ attack (Carlini & Wagner, 2017) and $\omega$ is the as Eq. (6).
+
+Table 3: Evaluations using standard WRN-28-10   
+
+<table><tr><td>Method/Paper</td><td>Natural</td><td>AA</td></tr><tr><td>Gowal et al. . (2020)</td><td>89.48</td><td>62.60</td></tr><tr><td>Wu et al. (2020)</td><td>88.25</td><td>60.04</td></tr><tr><td>GAIR-RST (Ours)</td><td>89.36</td><td>59.64</td></tr><tr><td>Carmon et al. (2019)</td><td>89.69</td><td>59.53</td></tr><tr><td>Sehwag et al. (2020)</td><td>88.98</td><td>57.14</td></tr><tr><td>Wang et al. (2020b)</td><td>87.50</td><td>56.29</td></tr><tr><td>Hendrycks et al. (2019)</td><td>87.11</td><td>54.92</td></tr></table>
+
+The results of other methods are reported at AA’s GitHub
+
+In Table 3, we compare the performance of our GAIR-RST with other methods that use WRN-28- 10 under auto attacks (AA) (Croce & Hein, 2020). All the methods utilized the same set of U data which are from RST’s GitHub8 and the results are reported on the leaderboard of AA’s GitHub9. Our GAIR-RST use the same training settings (e.g., learning rate schedule, $\epsilon _ { t r a i n } = 0 . 0 3 1 )$ as RST. The evaluations are on the full set of the AA in (Croce & Hein, 2020) with $\epsilon _ { t e s t } = 0 . 0 3 1$ , which keeps the same as training.
+
+The results show our geometry-aware instance-reweighted method can facilitate a competitive model by utilizing additional U data.

parse/train/rJY3vK9eg/rJY3vK9eg.md

@@ -0,0 +1,397 @@
+# NEURAL COMBINATORIAL OPTIMIZATION WITH REINFORCEMENT LEARNING
+
+Irwan Bello∗, Hieu Pham∗, Quoc V. Le, Mohammad Norouzi, Samy Bengi Google Brain {ibello,hyhieu,qvl,mnorouzi,bengio}@google.com
+
+# ABSTRACT
+
+This paper presents a framework to tackle combinatorial optimization problems using neural networks and reinforcement learning. We focus on the traveling salesman problem (TSP) and train a recurrent neural network that, given a set of city coordinates, predicts a distribution over different city permutations. Using negative tour length as the reward signal, we optimize the parameters of the recurrent neural network using a policy gradient method. We compare learning the network parameters on a set of training graphs against learning them on individual test graphs. Without much engineering and heuristic designing, Neural Combinatorial Optimization achieves close to optimal results on 2D Euclidean graphs with up to 100 nodes. Applied to the KnapSack, another NP-hard problem, the same method obtains optimal solutions for instances with up to 200 items. These results, albeit still far from state-of-the-art, give insights into how neural networks can be used as a general tool for tackling combinatorial optimization problems.
+
+# 1 INTRODUCTION
+
+Combinatorial optimization is a fundamental problem in computer science. A canonical example is the traveling salesman problem (TSP), where given a graph, one needs to search the space of permutations to find an optimal sequence of nodes with minimal total edge weights (tour length). The TSP and its variants have myriad applications in planning, manufacturing, genetics, etc. (see (Applegate et al., 2011) for an overview).
+
+Finding the optimal TSP solution is NP-hard, even in the two-dimensional Euclidean case (Papadimitriou, 1977), where the nodes are 2D points and edge weights are Euclidean distances between pairs of points. In practice, TSP solvers rely on handcrafted heuristics that guide their search procedures to find competitive (and in many cases optimal) tours efficiently. Even though these heuristics work well on TSP, once the problem statement changes slightly, they need to be revised. In contrast, machine learning methods have the potential to be applicable across many optimization tasks by automatically discovering their own heuristics based on the training data, thus requiring less handengineering than solvers that are optimized for one task only.
+
+While most successful machine learning techniques fall into the family of supervised learning, where a mapping from training inputs to outputs is learned, supervised learning is not applicable to most combinatorial optimization problems because one does not have access to optimal labels. However, one can compare the quality of a set of solutions using a verifier, and provide some reward feedbacks to a learning algorithm. Hence, we follow the reinforcement learning (RL) paradigm to tackle combinatorial optimization. We empirically demonstrate that, even when using optimal solutions as labeled data to optimize a supervised mapping, the generalization is rather poor compared to an RL agent that explores different tours and observes their corresponding rewards.
+
+We propose Neural Combinatorial Optimization, a framework to tackle combinatorial optimization problems using reinforcement learning and neural networks. We consider two approaches based on policy gradients (Williams, 1992). The first approach, called RL pretraining, uses a training set to optimize a recurrent neural network (RNN) that parameterizes a stochastic policy over solutions, using the expected reward as objective. At test time, the policy is fixed, and one performs inference by greedy decoding or sampling. The second approach, called active search, involves no pretraining. It starts from a random policy and iteratively optimizes the RNN parameters on a single test instance, again using the expected reward objective, while keeping track of the best solution sampled during the search. We find that combining RL pretraining and active search works best in practice.
+
+![](images/1ff035637247f258db525f5d1f250cf5f2bbb4ac3018e402f402b8331eb07fd5.jpg)  
+Figure 1: Tour length ratios of LK-H (Helsgaun, 2000) local search and our best method (RL pretraining-Active Search) against optimality, guaranteed by Concorde (Applegate et al., 2006). Generic local search, obtained via Googles vehicle routing problem solver (Google, 2016), applies a set of heuristics starting from the (Christofides, 1976) solution. Note that our method is five orders of magnitude slower than LK-H and Concorde.
+
+On 2D Euclidean graphs with up to 100 nodes, Neural Combinatorial Optimization significantly outperforms the supervised learning approach to the TSP (Vinyals et al., 2015b) and obtains close to optimal results when allowed more computation time (see Figure 1). We illustrate the flexibility of the method by also applying it to the KnapSack problem, for which we get optimal results for instances with up to 200 items. Our results, while still inferior to the state-of-the-art in many dimensions (such as speed, scale and performance), give insights into how neural networks can be used as a general tool for tackling combinatorial optimization problems, especially those that are difficult to design heuristics for.
+
+# 2 PREVIOUS WORK
+
+The Traveling Salesman Problem is a well studied combinatorial optimization problem and many exact or approximate algorithms have been proposed for both Euclidean and non-Euclidean graphs. Christofides (1976) proposes a heuristic algorithm that involves computing a minimum-spanning tree and a minimum-weight perfect matching. The algorithm has polynomial running time and returns solutions that are guaranteed to be within a factor of $1 . 5 \times$ to optimality in the metric instance of the TSP.
+
+The best known exact dynamic programming algorithm for TSP has a complexity of $\Theta ( 2 ^ { n } n ^ { 2 } )$ , making it infeasible to scale up to large instances, say with 40 points. Nevertheless, state of the art TSP solvers, thanks to carefully handcrafted heuristics that describe how to navigate the space of feasible solutions in an efficient manner, can solve symmetric TSP instances with thousands of nodes. Concorde (Applegate et al., 2006), widely accepted as one of the best exact TSP solvers, makes use of cutting plane algorithms (Dantzig et al., 1954; Padberg & Rinaldi, 1990; Applegate et al., 2003), iteratively solving linear programming relaxations of the TSP, in conjunction with a branch-and-bound approach that prunes parts of the search space that provably will not contain an optimal solution. Similarly, the Lin-Kernighan-Helsgaun heuristic (Helsgaun, 2000), inspired from the Lin-Kernighan heuristic (Lin & Kernighan, 1973), is a state of the art approximate search heuristic for the symmetric TSP and has been shown to solve instances with hundreds of nodes to optimality.
+
+More generic solvers, such as Google’s vehicle routing problem solver (Google, 2016) that tackles a superset of the TSP, typically rely on a combination of local search algorithms and metaheuristics. Local search algorithms apply a specified set of local move operators on candidate solutions, based on hand-engineered heuristics such as 2-opt (Johnson, 1990), to navigate from solution to solution in the search space. A metaheuristic is then applied to propose uphill moves and escape local optima. A popular choice of metaheuristic for the TSP and its variants is guided local search (Voudouris & Tsang, 1999), which moves out of a local minimum by penalizing particular solution features that it considers should not occur in a good solution.
+
+The difficulty in applying existing search heuristics to newly encountered problems - or even new instances of a similar problem - is a well-known challenge that stems from the No Free Lunch theorem (Wolpert & Macready, 1997). Because all search algorithms have the same performance when averaged over all problems, one must appropriately rely on a prior over problems when selecting a search algorithm to guarantee performance. This challenge has fostered interest in raising the level of generality at which optimization systems operate (Burke et al., 2003) and is the underlying motivation behind hyper-heuristics, defined as ”search method[s] or learning mechanism[s] for selecting or generating heuristics to solve computation search problems”. Hyper-heuristics aim to be easier to use than problem specific methods by partially abstracting away the knowledge intensive process of selecting heuristics given a combinatorial problem and have been shown to successfully combine human-defined heuristics in superior ways across many tasks (see (Burke et al., 2013) for a survey). However, hyper-heuristics operate on the search space of heuristics, rather than the search space of solutions, therefore still initially relying on human created heuristics.
+
+The application of neural networks to combinatorial optimization has a distinguished history, where the majority of research focuses on the Traveling Salesman Problem (Smith, 1999). One of the earliest proposals is the use of Hopfield networks (Hopfield & Tank, 1985) for the TSP. The authors modify the network’s energy function to make it equivalent to TSP objective and use Lagrange multipliers to penalize the violations of the problem’s constraints. A limitation of this approach is that it is sensitive to hyperparameters and parameter initialization as analyzed by (Wilson & Pawley, 1988). Overcoming this limitation is central to the subsequent work in the field, especially by (Aiyer et al., 1990; Gee, 1993). Parallel to the development of Hopfield networks is the work on using deformable template models to solve TSP. Perhaps most prominent is the invention of Elastic Nets as a means to solve TSP (Durbin, 1987), and the application of Self Organizing Map to TSP (Fort, 1988; Angeniol et al., 1988; Kohonen, 1990). Addressing the limitations of deformable template models is central to the following work in this area (Burke, 1994; Favata & Walker, 1991; Vakhutinsky & Golden, 1995). Even though these neural networks have many appealing properties, they are still limited as research work. When being carefully benchmarked, they have not yielded satisfying results compared to algorithmic methods (Sarwar & Bhatti, 2012; La Maire & Mladenov, 2012). Perhaps due to the negative results, this research direction is largely overlooked since the turn of the century.
+
+Motivated by the recent advancements in sequence-to-sequence learning (Sutskever et al., 2014), neural networks are again the subject of study for optimization in various domains (Yutian et al., 2016), including discrete ones (Zoph & Le, 2016). In particular, the TSP is revisited in the introduction of Pointer Networks (Vinyals et al., 2015b), where a recurrent network with non-parametric softmaxes is trained in a supervised manner to predict the sequence of visited cities. Despite architecural improvements, their models were trained using supervised signals given by an approximate solver.
+
+# 3 NEURAL NETWORK ARCHITECTURE FOR TSP
+
+We focus on the 2D Euclidean TSP in this paper. Given an input graph, represented as a sequence of $n$ cities in a two dimensional space $s = \{ \mathbf { \bar { x } } _ { i } \} _ { i = 1 } ^ { n }$ where each $\bar { \mathbf { x } } _ { i } \in \mathbb { R } ^ { 2 }$ , we are concerned with finding a permutation of the points $\pi$ , termed a tour, that visits each city once and has the minimum total length. We define the length of a tour defined by a permutation $\pi$ as
+
+$$
+L ( \pi \mid s ) = \left\| \mathbf { x } _ { \pi ( n ) } - \mathbf { x } _ { \pi ( 1 ) } \right\| _ { 2 } + \sum _ { i = 1 } ^ { n - 1 } \left\| \mathbf { x } _ { \pi ( i ) } - \mathbf { x } _ { \pi ( i + 1 ) } \right\| _ { 2 } ,
+$$
+
+where $\lVert \cdot \rVert _ { 2 }$ denotes $\ell _ { 2 }$ norm.
+
+We aim to learn the parameters of a stochastic policy $p ( \pi \mid s )$ that given an input set of points $s$ assigns high probabilities to short tours and low probabilities to long tours. Our neural network
+
+![](images/617f6b30f93ad3f6b942335c7b275ae2f57b67551499b6e623f271e6b3996445.jpg)  
+Figure 2: A pointer network architecture introduced by (Vinyals et al., 2015b).
+
+architecture uses the chain rule to factorize the probability of a tour as
+
+$$
+p ( \pi \mid s ) = \prod _ { i = 1 } ^ { n } p \left( \pi ( i ) \mid \pi ( < i ) , s \right) ,
+$$
+
+and then uses individual softmax modules to represent each term on the RHS of (2).
+
+We are inspired by previous work (Sutskever et al., 2014) that makes use of the same factorization based on the chain rule to address sequence to sequence problems like machine translation. One can use a vanilla sequence to sequence model to address the TSP where the output vocabulary is $\{ 1 , 2 , \ldots , n \}$ . However, there are two major issues with this approach: (1) networks trained in this fashion cannot generalize to inputs with more than $n$ cities. (2) one needs to have access to groundtruth output permutations to optimize the parameters with conditional log-likelihood. We address both isssues in this paper.
+
+For generalization beyond a pre-specified graph size, we follow the approach of (Vinyals et al., 2015b), which makes use of a set of non-parameteric softmax modules, resembling the attention mechanism from (Bahdanau et al., 2015). This approach, named pointer network, allows the model to effectively point to a specific position in the input sequence rather than predicting an index value from a fixed-size vocabulary. We employ the pointer network architecture, depicted in Figure 2, as our policy model to parameterize $p ( \pi \mid s )$ .
+
+# 3.1 ARCHITECTURE DETAILS
+
+Our pointer network comprises two recurrent neural network (RNN) modules, encoder and decoder, both of which consist of Long Short-Term Memory (LSTM) cells (Hochreiter & Schmidhuber, 1997). The encoder network reads the input sequence $s$ , one city at a time, and transforms it into a sequence of latent memory states $\{ e n c _ { i } \} _ { i = 1 } ^ { n }$ where $e n c _ { i } \in \mathbb { R } ^ { d }$ . The input to the encoder network at time step $i$ is a $d$ -dimensional embedding of a 2D point $\mathbf { x } _ { i }$ , which is obtained via a linear transformation of $\mathbf { x } _ { i }$ shared across all input steps. The decoder network also maintains its latent memory states $\{ d e c _ { i } \} _ { i = 1 } ^ { n }$ where $d e c _ { i } \in \mathbb { R } ^ { d }$ and, at each step $i$ , uses a pointing mechanism to produce a distribution over the next city to visit in the tour. Once the next city is selected, it is passed as the input to the next decoder step. The input of the first decoder step (denoted by $\langle g \rangle$ in Figure 2) is a d-dimensional vector treated as a trainable parameter of our neural network.
+
+Our attention function, formally defined in Appendix A.1, takes as input a query vector $q = d e c _ { i } \in$ $\mathbb { R } ^ { d }$ and a set of reference vectors $r e f = \{ e n c _ { 1 } , \ldots , e n c _ { k } \}$ where $e n c _ { i } \in \bar { \mathbb { R } } ^ { d }$ , and predicts a distribution $A ( r e f , q )$ over the set of $k$ references. This probability distribution represents the degree to which the model is pointing to reference $r _ { i }$ upon seeing query $q$ .
+
+Vinyals et al. (2015a) also suggest including some additional computation steps, named glimpses, to aggregate the contributions of different parts of the input sequence, very much like (Bahdanau et al., 2015). We discuss this approach in details in Appendix A.1. In our experiments, we find that utilizing one glimpse in the pointing mechanism yields performance gains at an insignificant cost latency.
+
+# Algorithm 1 Actor-critic training
+
+1: procedure TRAIN(training set $S$ , number of training steps $T$ , batch size $B$ )   
+2: Initialize pointer network params $\theta$   
+3: Initialize critic network params $\theta _ { v }$   
+4: for $t = 1$ to $T$ do   
+5: $s _ { i } \sim \operatorname { S A M P L E I N P U T } ( S )$ for $i \in \{ 1 , \ldots , B \}$   
+6: $\pi _ { i } \sim$ SAMPLESOLUTION $\left( \boldsymbol { p } _ { \boldsymbol { \theta } } ( . | \boldsymbol { s } _ { i } ) \right)$ for $i \in \{ 1 , \ldots , B \}$   
+7: $b _ { i }  b _ { \theta _ { v } } ( s _ { i } )$ for $i \in \{ 1 , \ldots , B \}$   
+8: $\begin{array} { r } { g _ { \theta }  \frac { 1 } { B } \sum _ { i = 1 } ^ { B } ( L ( \pi _ { i } | s _ { i } ) - b _ { i } ) \nabla _ { \theta } \log p _ { \theta } ( \pi _ { i } | s _ { i } ) } \end{array}$   
+9: $\begin{array} { r } { \mathcal { L } _ { v }  \frac { 1 } { B } \sum _ { i = 1 } ^ { B } \| b _ { i } - L ( \pi _ { i } ) \| _ { 2 } ^ { 2 } } \end{array}$   
+10: θ ← ADAM(θ, gθ)   
+11: $\boldsymbol { \theta } _ { v } \gets \mathrm { A D A M } ( \theta _ { v } , \nabla { \theta } _ { v } \mathcal { L } _ { v } )$   
+12: end for   
+13: return θ   
+14: end procedure
+
+# 4 OPTIMIZATION WITH POLICY GRADIENTS
+
+Vinyals et al. (2015b) proposes training a pointer network using a supervised loss function comprising conditional log-likelihood, which factors into a cross entropy objective between the network’s output probabilities and the targets provided by a TSP solver. Learning from examples in such a way is undesirable for NP-hard problems because (1) the performance of the model is tied to the quality of the supervised labels, (2) getting high-quality labeled data is expensive and may be infeasible for new problem statements, (3) one cares about finding a competitive solution more than replicating the results of another algorithm.
+
+By contrast, we believe Reinforcement Learning (RL) provides an appropriate paradigm for training neural networks for combinatorial optimization, especially because these problems have relatively simple reward mechanisms that could be even used at test time. We hence propose to use model-free policy-based Reinforcement Learning to optimize the parameters of a pointer network denoted $\pmb \theta$ . Our training objective is the expected tour length which, given an input graph $s$ , is defined as
+
+$$
+J ( \pmb \theta \mid s ) = \mathbb { E } _ { \pi \sim p _ { \theta } ( . \mid s ) } L ( \pi \mid s ) .
+$$
+
+During training, our graphs are drawn from a distribution $s$ , and the total training objective involves sampling from the distribution of graphs, i.e. $J ( \pmb \theta ) = \mathbb { E } _ { s \sim S } J ( \pmb \theta \mid s )$ .
+
+We resort to policy gradient methods and stochastic gradient descent to optimize the parameters. The gradient of (3) is formulated using the well-known REINFORCE algorithm (Williams, 1992):
+
+$$
+\nabla _ { \theta } J ( \theta \mid s ) = \mathbb { E } _ { \pi \sim p _ { \theta } ( . \mid s ) } \Big [ \big ( L ( \pi \mid s ) - b ( s ) \big ) \nabla _ { \theta } \log p _ { \theta } ( \pi \mid s ) \Big ] ,
+$$
+
+where $b ( s )$ denotes a baseline function that does not depend on $\pi$ and estimates the expected tour length to reduce the variance of the gradients.
+
+By drawing $B$ i.i.d. sample graphs $s _ { 1 } , s _ { 2 } , \ldots , s _ { B } \sim \mathcal { S }$ and sampling a single tour per graph, i.e. $\pi _ { i } \sim p _ { \theta } ( . \mid s _ { i } )$ , the gradient in (4) is approximated with Monte Carlo sampling as follows:
+
+$$
+\nabla _ { \theta } J ( \theta ) \approx \frac { 1 } { B } \sum _ { i = 1 } ^ { B } \Big ( L ( \pi _ { i } | s _ { i } ) - b ( s _ { i } ) \Big ) \nabla _ { \theta } \log p _ { \theta } ( \pi _ { i } \mid s _ { i } ) .
+$$
+
+A simple and popular choice of the baseline $b ( s )$ is an exponential moving average of the rewards obtained by the network over time to account for the fact that the policy improves with training. While this choice of baseline proved sufficient to improve upon the Christofides algorithm, it suffers from not being able to differentiate between different input graphs. In particular, the optimal tour $\pi ^ { * }$ for a difficult graph $s$ may be still discouraged if $L ( \pi ^ { * } | s ) > b$ because $b$ is shared across all instances in the batch.
+
+Using a parametric baseline to estimate the expected tour length $\mathbb { E } _ { \pi \sim p _ { \theta } ( . | s ) } L ( \pi \mid s )$ typically improves learning. Therefore, we introduce an auxiliary network, called a critic and parameterized
+
+# Algorithm 2 Active Search
+
+1: procedure ACTIVESEARCH(input s, $\theta$ , number of candidates K, B,   
+2: π ← RANDOMSOLUTION()   
+3: Lπ ← L(π | s)   
+4: n ← d KB e   
+5: for t = 1 . . . n do   
+6: πi ∼ SAMPLESOLUTION(pθ(. | s)) for $i \in \{ 1 , \ldots , B \}$   
+7: j ← ARGMIN(L(π1 | s) . . . L(πB | s))   
+8: Lj ← L(πj | s)   
+9: if Lj < Lπ then   
+10: π ← πj   
+11: Lπ ← Lj   
+12: 13: 14: $\begin{array} { r l } & { \overset { \vartriangle } { \boldsymbol { g } _ { \theta } }  \frac { 1 } { B } \sum _ { i = 1 } ^ { B } ( L ( \pi _ { i } \mid \boldsymbol { s } ) - b ) \nabla _ { \theta } \log p _ { \theta } ( \pi _ { i } \mid \boldsymbol { s } ) } \\ & { \overset { \theta  \boldsymbol { \mathrm { A D A M } } } { \boldsymbol { b } } + ( 1 - \alpha ) \times ( \frac { 1 } { B } \sum _ { i = 1 } ^ { B } b _ { i } ) } \\ & { \overset { \boldsymbol { b } } { \underset {  } { \boldsymbol { b } } }  \alpha \times \boldsymbol { b } + ( 1 - \alpha ) \times ( \frac { 1 } { B } \sum _ { i = 1 } ^ { B } b _ { i } ) } \end{array}$   
+15:   
+16: end for   
+17: return $\pi$   
+18: end procedure
+
+by $\theta _ { v }$ , to learn the expected tour length found by our current policy $p _ { \theta }$ given an input sequence $s$ The critic is trained with stochastic gradient descent on a mean squared error objective between its predictions $b _ { \theta _ { v } } \left( s \right)$ and the actual tour lengths sampled by the most recent policy. The additional objective is formulated as
+
+$$
+\mathcal { L } ( \theta _ { v } ) = \frac { 1 } { B } \sum _ { i = 1 } ^ { B } \left. b _ { \theta _ { v } } ( s _ { i } ) - L ( \pi _ { i } \mid s _ { i } ) \right. _ { 2 } ^ { 2 } .
+$$
+
+Critic’s architecture for TSP. We now explain how our critic maps an input sequence $s$ into a baseline prediction $b _ { \theta _ { v } } \left( s \right)$ . Our critic comprises three neural network modules: 1) an LSTM encoder, 2) an LSTM process block and 3) a 2-layer ReLU neural network decoder. Its encoder has the same architecture as that of our pointer network’s encoder and encodes an input sequence $s$ into a sequence of latent memory states and a hidden state $h$ . The process block, similarly to (Vinyals et al., 2015a), then performs $\mathrm { \bf P }$ steps of computation over the hidden state $h$ . Each processing step updates this hidden state by glimpsing at the memory states as described in Appendix A.1 and feeds the output of the glimpse function as input to the next processing step. At the end of the process block, the obtained hidden state is then decoded into a baseline prediction (i.e a single scalar) by two fully connected layers with respectively d and 1 unit(s).
+
+Our training algorithm, described in Algorithm 1, is closely related to the asynchronous advantage actor-critic (A3C) proposed in (Mnih et al., 2016), as the difference between the sampled tour lengths and the critic’s predictions is an unbiased estimate of the advantage function. We perform our updates asynchronously across multiple workers, but each worker also handles a mini-batch of graphs for better gradient estimates.
+
+# 4.1 SEARCH STRATEGIES
+
+As evaluating a tour length is inexpensive, our TSP agent can easily simulate a search procedure at inference time by considering multiple candidate solutions per graph and selecting the best. This inference process resembles how solvers search over a large set of feasible solutions. In this paper, we consider two search strategies detailed below, which we refer to as sampling and active search.
+
+Sampling. Our first approach is simply to sample multiple candidate tours from our stochastic policy $p _ { \theta } ( . | s )$ and select the shortest one. In contrast to heuristic solvers, we do not enforce our model to sample different tours during the process. However, we can control the diversity of the sampled tours with a temperature hyperparameter when sampling from our non-parametric softmax (see Appendix A.2). This sampling process yields significant improvements over greedy decoding, which always selects the index with the largest probability. We also considered perturbing the pointing mechanism with random noise and greedily decoding from the obtained modified policy, similarly to (Cho, 2016), but this proves less effective than sampling in our experiments.
+
+Table 1: Different learning configurations.   
+
+<table><tr><td rowspan=1 colspan=1>Configuration</td><td rowspan=1 colspan=1>Learn ontraining data</td><td rowspan=1 colspan=1>Samplingon test set</td><td rowspan=1 colspan=1>Refiningon test set</td></tr><tr><td rowspan=1 colspan=1>RL pretraining-Greedy</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>No</td></tr><tr><td rowspan=1 colspan=1>Active Search (AS)</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Yes</td></tr><tr><td rowspan=1 colspan=1>RL pretraining-Sampling</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>No</td></tr><tr><td rowspan=1 colspan=1>RL pretraining-Active Search</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Yes</td></tr></table>
+
+Active Search. Rather than sampling with a fixed model and ignoring the reward information obtained from the sampled solutions, one can refine the parameters of the stochastic policy $p _ { \theta }$ during inference to minimize $\mathbb { E } _ { \pi \sim p _ { \theta } ( . | s ) } L ( \pi \mid s )$ on a single test input $s$ . This approach proves especially competitive when starting from a trained model. Remarkably, it also produces satisfying solutions when starting from an untrained model. We refer to these two approaches as $R L$ pretraining-Active Search and Active Search because the model actively updates its parameters while searching for candidate solutions on a single test instance.
+
+Active Search applies policy gradients similarly to Algorithm 1 but draws Monte Carlo samples over candidate solutions $\pi _ { 1 } \ldots \pi _ { B } \sim p _ { \theta } ( \cdot | s ) $ for a single test input. It resorts to an exponential moving average baseline, rather than a critic, as there is no need to differentiate between inputs. Our Active Search training algorithm is presented in Algorithm 2. We note that while RL training does not require supervision, it still requires training data and hence generalization depends on the training data distribution. In contrast, Active Search is distribution independent. Finally, since we encode a set of cities as a sequence, we randomly shuffle the input sequence before feeding it to our pointer network. This increases the stochasticity of the sampling procedure and leads to large improvements in Active Search.
+
+# 5 EXPERIMENTS
+
+We conduct experiments to investigate the behavior of the proposed Neural Combinatorial Optimization methods. We consider three benchmark tasks, Euclidean TSP20, 50 and 100, for which we generate a test set of 1, 000 graphs. Points are drawn uniformly at random in the unit square $[ 0 , 1 ] ^ { 2 }$ .
+
+# 5.1 EXPERIMENTAL DETAILS
+
+Across all experiments, we use mini-batches of 128 sequences, LSTM cells with 128 hidden units, and embed the two coordinates of each point in a 128-dimensional space. We train our models with the Adam optimizer (Kingma & Ba, 2014) and use an initial learning rate of $1 0 ^ { - 3 }$ for TSP20 and TSP50 and $\mathrm { \dot { 1 } 0 ^ { - 4 } }$ for TSP100 that we decay every 5000 steps by a factor of 0.96. We initialize our parameters uniformly at random within $[ - 0 . 0 8 , 0 . 0 8 ]$ and clip the $L 2$ norm of our gradients to 1.0. We use up to one attention glimpse. When searching, the mini-batches either consist of replications of the test sequence or its permutations. The baseline decay is set to $\alpha = 0 . 9 9$ in Active Search. Our model and training code in Tensorflow (Abadi et al., 2016) will be made availabe soon. Table 1 summarizes the configurations and different search strategies used in the experiments. The variations of our method, experimental procedure and results are as follows.
+
+Supervised Learning. In addition to the described baselines, we implement and train a pointer network with supervised learning, similarly to (Vinyals et al., 2015b). While our supervised data consists of one million optimal tours, we find that our supervised learning results are not as good as those reported in by (Vinyals et al., 2015b). We suspect that learning from optimal tours is harder for supervised pointer networks due to subtle features that the model cannot figure out only by looking at given supervised targets. We thus refer to the results in (Vinyals et al., 2015b) for TSP20 and TSP50 and report our results on TSP100, all of which are suboptimal compared to other approaches.
+
+Table 2: Average tour lengths (lower is better). Results marked (†) are from (Vinyals et al., 2015b).   
+
+<table><tr><td rowspan="2">Task</td><td rowspan="2">Supervised Learning</td><td colspan="4">RL pretraining</td><td rowspan="2">AS</td><td rowspan="2">Christo -fides</td><td rowspan="2">OR Tools’ local search</td><td rowspan="2">Optimal</td></tr><tr><td>greedy</td><td>greedy@16</td><td>sampling</td><td>AS</td></tr><tr><td>TSP20</td><td>3.88（）</td><td>3.89</td><td>1</td><td>3.82</td><td>3.82</td><td>3.96</td><td>4.30</td><td>3.85</td><td>3.82</td></tr><tr><td>TSP50</td><td>6.09(t)</td><td>5.95</td><td>5.80</td><td>5.70</td><td>5.70</td><td>5.87</td><td>6.62</td><td>5.80</td><td>5.68</td></tr><tr><td>TSP100</td><td>10.81</td><td>8.30</td><td>7.97</td><td>7.88</td><td>7.83</td><td>8.19</td><td>9.18</td><td>7.99</td><td>7.77</td></tr></table>
+
+RL pretraining. For the RL experiments, we generate training mini-batches of inputs on the fly and update the model parameters with the Actor Critic Algorithm 1. We use a validation set of 10, 000 randomly generated instances for hyper-parameters tuning. Our critic consists of an encoder network which has the same architecture as that of the policy network, but followed by 3 processing steps and 2 fully connected layers. We find that clipping the logits to $[ - 1 0 , 1 0 ]$ with a tanh(·) activation function, as described in Appendix A.2, helps with exploration and yields marginal performance gains. The simplest search strategy using an RL pretrained model is greedy decoding, i.e. selecting the city with the largest probability at each decoding step. We also experiment with decoding greedily from a set of 16 pretrained models at inference time. For each graph, the tour found by each individual model is collected and the shortest tour is chosen. We refer to those approaches as RL pretraining-greedy and RL pretraining-greedy $@ l 6$ .
+
+RL pretraining-Sampling. For each test instance, we sample $1 , 2 8 0 , 0 0 0$ candidate solutions from a pretrained model and keep track of the shortest tour. A grid search over the temperature hyperparameter found respective temperatures of 2.0, 2.2 and 1.5 to yield the best results for TSP20, TSP50 and TSP100. We refer to the tuned temperature hyperparameter as $T ^ { * }$ . Since sampling does not require parameter udpates and is entirely parallelizable, we use a larger batch size for speed purposes.
+
+RL pretraining-Active Search. For each test instance, we initialize the model parameters from a pretrained RL model and run Active Search for up to 10, 000 training steps with a batch size of 128, sampling a total of 1, 280, 000 candidate solutions. We set the learning rate to a hundredth of the initial learning rate the TSP agent was trained on (i.e. $1 0 ^ { - 5 }$ for TSP20/TSP50 and $1 0 ^ { - 6 }$ for TSP100).
+
+Active Search. We allow the model to train much longer to account for the fact that it starts from scratch. For each test graph, we run Active Search for 100, 000 training steps on TSP20/TSP50 and 200, 000 training steps on TSP100.
+
+# 5.2 RESULTS AND ANALYSES
+
+We compare our methods against 3 different baselines of increasing performance and complexity: 1) Christofides, 2) the vehicle routing solver from OR-Tools (Google, 2016) and 3) optimality. Christofides solutions are obtained in polynomial time and guaranteed to be within a 1.5 ratio of optimality. OR-Tools improves over Christofides’ solutions with simple local search operators, including 2-opt (Johnson, 1990) and a version of the Lin-Kernighan heuristic (Lin & Kernighan, 1973), stopping when it reaches a local minimum. In order to escape poor local optima, ORTools’ local search can also be run in conjunction with different metaheuristics, such as simulated annealing (Kirkpatrick et al., 1983), tabu search (Glover & Laguna, 2013) or guided local search (Voudouris & Tsang, 1999). OR-Tools’ vehicle routing solver can tackle a superset of the TSP and operates at a higher level of generality than solvers that are highly specific to the TSP. While not state-of-the art for the TSP, it is a common choice for general routing problems and provides a reasonable baseline between the simplicity of the most basic local search operators and the sophistication of the strongest solvers. Optimal solutions are obtained via Concorde (Applegate et al., 2006) and LK-H’s local search (Helsgaun, 2012; 2000). While only Concorde provably solves instances to optimality, we empirically find that LK-H also achieves optimal solutions on all of our test sets after 50 trials per graph (which is the default parameter setting).
+
+We report the average tour lengths of our approaches on TSP20, TSP50, and TSP100 in Table 2. Notably, results demonstrate that training with RL significantly improves over supervised learning (Vinyals et al., 2015b). All our methods comfortably surpass Christofides’ heuristic, including RL pretraining-Greedy which also does not rely on search. Table 3 compares the running times of our greedy methods to the aforementioned baselines, with our methods running on a single Nvidia Tesla K80 GPU, Concorde and LK-H running on an Intel Xeon CPU E5-1650 v3 3.50GHz CPU and ORTool on an Intel Haswell CPU. We find that both greedy approaches are time-efficient but still quite far from optimality.
+
+Table 3: Running times in seconds (s) of greedy methods compared to OR Tool’s local search and solvers that find the optimal solutions. Time is measured over the entire test set and averaged. LK-H was run for 50 trials per graph (the default parameter setting). It is likely that optimal solutions were found in fewer trials, resulting in shorter running times.   
+
+<table><tr><td rowspan="2">Task</td><td colspan="2">RL pretraining</td><td rowspan="2">OR-Tools&#x27; local search</td><td colspan="2">Optimal</td></tr><tr><td>greedy</td><td>greedy@16</td><td>Concorde</td><td>LK-H</td></tr><tr><td>TSP50</td><td>0.003s</td><td>0.04s</td><td>0.02s</td><td>0.05s</td><td>0.14s</td></tr><tr><td>TSP100</td><td>0.01s</td><td>0.15s</td><td>0.10s</td><td>0.22s</td><td>0.88s</td></tr></table>
+
+Table 4: Average tour lengths of RL pretraining-Sampling and RL pretraining-Active Search as they sample more solutions. Corresponding running times on a single Tesla K80 GPU are in parantheses.   
+
+<table><tr><td rowspan="2">Task</td><td rowspan="2"># Solutions</td><td colspan="3">RL pretraining</td></tr><tr><td>Sampling T =1</td><td>Sampling T =T*</td><td>Active Search</td></tr><tr><td>TSP50</td><td>128 1,280 12,800</td><td>5.80 (3.4s) 5.77 (3.4s) 5.75 (13.8s)</td><td>5.80 (3.4s) 5.75 (3.4s) 5.73 (13.8s)</td><td>5.80 (0.5s) 5.76 (5s) 5.74 (50s)</td></tr><tr><td></td><td>128.000 1,280,000 128</td><td>5.73 (110s) 5.72 (1080s) 8.05 (10.3s) 8.00 (10.3s)</td><td>5.71 (110s) 5.70 (1080s) 8.09 (10.3s) 8.00 (10.3s)</td><td>5.72 (500s) 5.70 (5000s) 8.04 (1.2s)</td></tr><tr><td>TSP100</td><td>1,280 12,800 128,000 1,280,000</td><td>7.95 (31s) 7.92 (265s) 7.89 (2640s)</td><td>7.95 (31s) 7.91 (265s) 7.88 (2640s)</td><td>7.98 (12s) 7.92 (120s) 7.87 (1200s) 7.83 (12000s)</td></tr></table>
+
+Searching at inference time proves crucial to get closer to optimality but comes at the expense of longer running times. Fortunately, the search from RL pretraining-Sampling and RL pretrainingActive Search can be stopped early with a small performance tradeoff in terms of the final objective. This can be seen in Table 4, where we show their performances and corresponding running times as a function of how many solutions they consider.
+
+We also find that many of our RL pretraining methods outperform OR-Tools’ local search, including RL pretraining-Greedy $@ 1 6$ which runs similarly fast. Table 6 in Appendix A.3 presents the performance of the metaheuristics as they consider more solutions and the corresponding running times. In our experiments, Neural Combinatorial proves superior than Simulated Annealing but is slightly less competitive that Tabu Search and much less so than Guided Local Search.
+
+We present a more detailed comparison of our methods in Figure 3, where we sort the ratios to optimality of our different learning configurations. RL pretraining-Sampling and RL pretrainingActive Search are the most competitive Neural Combinatorial Optimization methods and recover the optimal solution in a significant number of our test cases. We find that for small solution spaces, RL pretraining-Sampling, with a finetuned softmax temperature, outperforms RL pretraining-Active Search with the latter sometimes orienting the search towards suboptimal regions of the solution space (see TSP50 results in Table 4 and Figure 3). Furthermore, RL pretraining-Sampling benefits from being fully parallelizable and runs faster than RL pretraining-Active Search. However, for larger solution spaces, RL-pretraining Active Search proves superior both when controlling for the number of sampled solutions or the running time. Interestingly, Active Search - which starts from an untrained model - also produces competitive tours but requires a considerable amount of time (respectively 7 and 25 hours per instance of TSP50/TSP100). Finally, we show randomly picked example tours found by our methods in Figure 4 in Appendix A.4.
+
+![](images/2fbc96e10b80d35ec853e691c0d69a285dbaa6933ef81b6a838aea1d234ce2bc.jpg)  
+Figure 3: Sorted tour length ratios to optimality
+
+# 6 GENERALIZATION TO OTHER PROBLEMS
+
+In this section, we discuss how to apply Neural Combinatorial Optimization to other problems than the TSP. In Neural Combinatorial Optimization, the model architecture is tied to the given combinatorial optimization problem. Examples of useful networks include the pointer network, when the output is a permutation or a truncated permutation or a subset of the input, and the classical seq2seq model for other kinds of structured outputs. For combinatorial problems that require to assign labels to elements of the input, such as graph coloring, it is also possible to combine a pointer module and a softmax module to simultaneously point and assign at decoding time. Given a model that encodes an instance of a given combinatorial optimization task and repeatedly branches into subtrees to construct a solution, the training procedures described in Section 4 can then be applied by adapting the reward function depending on the optimization problem being considered.
+
+Additionally, one also needs to ensure the feasibility of the obtained solutions. For certain combinatorial problems, it is straightforward to know exactly which branches do not lead to any feasible solutions at decoding time. We can then simply manually assign them a zero probability when decoding, similarly to how we enforce our model to not point at the same city twice in our pointing mechanism (see Appendix A.1). However, for many combinatorial problems, coming up with a feasible solution can be a challenge in itself. Consider, for example, the Travelling Salesman Problem with Time Windows, where the travelling salesman has the additional constraint of visiting each city during a specific time window. It might be that most branches being considered early in the tour do not lead to any solution that respects all time windows. In such cases, knowing exactly which branches are feasible requires searching their subtrees, a time-consuming process that is not much easier than directly searching for the optimal solution unless using problem-specific heuristics.
+
+Rather than explicitly constraining the model to only sample feasible solutions, one can also let the model learn to respect the problem’s constraints. A simple approach, to be verified experimentally in future work, consists in augmenting the objective function with a term that penalizes solutions for violating the problem’s constraints, similarly to penalty methods in constrained optimization. While this does not guarantee that the model consistently samples feasible solutions at inference time, this is not necessarily problematic as we can simply ignore infeasible solutions and resample from the model (for RL pretraining-Sampling and RL-pretraining Active Search). It is also conceivable to combine both approaches by assigning zero probabilities to branches that are easily identifiable as infeasible while still penalizing infeasible solutions once they are entirely constructed.
+
+# 6.1 KNAPSACK EXAMPLE
+
+As an example of the flexibility of Neural Combinatorial Optimization, we consider the KnapSack problem, another intensively studied problem in computer science. Given a set of $n$ items $i = 1 . . . n$ each with weight $w _ { i }$ and value $v _ { i }$ and a maximum weight capacity of $W$ , the 0-1 KnapSack problem consists in maximizing the sum of the values of items present in the knapsack so that the sum of the weights is less than or equal to the knapsack capacity:
+
+$$
+\begin{array} { r l } { \underset { S \subseteq \{ 1 , 2 , \ldots , n \} } { \mathrm { m a x } } } & { \displaystyle \sum _ { i \in S } v _ { i } } \\ { \mathrm { s u b j e c t ~ t o } } & { \displaystyle \sum _ { i \in S } w _ { i } \leq W } \end{array}
+$$
+
+With $w _ { i }$ , $v _ { i }$ and $W$ taking real values, the problem is NP-hard (Kellerer et al., 2004). A naive heuristic is to take the items ordered by their weight-to-value ratios until they fill up the weight capacity. Two simple heuristics are ExpKnap, which employs branch-and-bound with Linear Programming bounds (Pisinger, 1995), and MinKnap, which uses dynamic programming with enumerative bounds (Pisinger, 1997). Exact solutions can also be obtained by quantizing the weights to high precisions and then performing dynamic programming with pseudo-polynomial complexity (Bertsimas & Demir, 2002).
+
+We apply the pointer network and encode each KnapSack instance as a sequence of 2D vectors $( w _ { i } , v _ { i } )$ . At decoding time, the pointer network points to items to include in the knapsack and stops when the total weight of the items collected so far exceeds the weight capacity. We generate three datasets, KNAP50, KNAP100 and KNAP200, of a thousand instances with items’ weights and values drawn uniformly at random in [0, 1]. Without loss of generality (since we can scale the items’ weights), we set the capacities to 12.5 for KNAP50 and 25 for KNAP100 and KNAP200. We present the performances of RL pretraining-Greedy and Active Search (which we run for 5, 000 training steps) in Table 5 and compare them to the following baselines: 1) random search (which we let sample as many feasible solutions seen by Active Search), 2) the greedy value-to-weight ratio heuristic, 3) MinKnap, 4) ExpKnap, 5) OR-Tools’ KnapSack solver (Google, 2016) and 6) optimality (which we obtained by quantizing the weights to high precisions and using dynamic programming).
+
+Table 5: Results of RL pretraining-Greedy and Active Search on KnapSack (higher is better).   
+
+<table><tr><td>Task</td><td>RL pretraining greedy</td><td>Active Search</td><td>Random Search</td><td>Greedy</td><td>MinKnap / ExpKnap /OR-Tools</td><td>Optimal</td></tr><tr><td>KNAP50</td><td>19.86</td><td>20.07</td><td>17.91</td><td>19.24</td><td>20.07</td><td>20.07</td></tr><tr><td>KNAP100</td><td>40.27</td><td>40.50</td><td>33.23</td><td>38.53</td><td>40.50</td><td>40.50</td></tr><tr><td>KNAP200</td><td>57.10</td><td>57.45</td><td>35.95</td><td>55.42</td><td>57.45</td><td>57.45</td></tr></table>
+
+# 7 CONCLUSION
+
+This paper presents Neural Combinatorial Optimization, a framework to tackle combinatorial optimization with reinforcement learning and neural networks. We focus on the traveling salesman problem (TSP) and present a set of results for each variation of the framework. Experiments demonstrate that Neural Combinatorial Optimization achieves close to optimal results on 2D Euclidean graphs with up to 100 nodes. Our results, while still far from the strongest solvers (especially those which are optimized for one problem), provide an interesting research avenue for using neural networks as a general tool for tackling combinatorial optimization problems.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to thank Vincent Furnon, Mustafa Ispir, Lukasz Kaiser, Oriol Vinyals, Barret Zoph, the Google Brain team and the anonymous ICLR reviewers for insightful comments and discussion.
+
+# REFERENCES
+
+Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for largescale machine learning. arXiv preprint arXiv:1605.08695, 2016.
+
+Sreeram V. B. Aiyer, Mahesan Niranjan, and Frank Fallside. A theoretical investigation into the performance of the Hopfield model. IEEE Transactions on Neural Networks, 1(2):204–215, 1990.
+
+Bernard Angeniol, Gael De La Croix Vaubois, and Jean-Yves Le Texier. Self-organizing feature maps and the Travelling Salesman Problem. Neural Networks, 1(4):289–293, 1988.
+
+David Applegate, Robert Bixby, Vasek Chv ˇ atal, and William Cook. Implementing the dantzig- ´ fulkerson-johnson algorithm for large traveling salesman problems. Mathematical programming, 2003.
+
+David L Applegate, Robert E Bixby, Vasek Chvatal, and William J Cook. Concorde tsp solver, 2006. URL www.math.uwaterloo.ca/tsp/concorde.
+
+David L Applegate, Robert E Bixby, Vasek Chvatal, and William J Cook. The traveling salesman problem: a computational study. Princeton university press, 2011.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015.
+
+Dimitris Bertsimas and Ramazan Demir. An approximate dynamic programming approach to multidimensional knapsack problems. Management Science, 48(4):550–565, 2002.
+
+Edmund Burke, Graham Kendall, Jim Newall, Emma Hart, Peter Ross, and Sonia Schulenburg. Hyperheuristics: An emerging direction in modern search technology. Springer, 2003.
+
+Edmund K. Burke, Michel Gendreau, Matthew R. Hyde, Graham Kendall, Gabriela Ochoa, Ender zcan, and Rong Qu. Hyper-heuristics: a survey of the state of the art. JORS, 64(12):1695–1724, 2013.
+
+Laura I. Burke. Neural methods for the Traveling Salesman Problem: insights from operations research. Neural Networks, 7(4):681–690, 1994.
+
+Kyunghyun Cho. Noisy parallel approximate decoding for conditional recurrent language model. arXiv preprint arXiv:1605.03835, 2016.
+
+Nicos Christofides. Worst-case analysis of a new heuristic for the Travelling Salesman Problem. In Report 388. Graduate School of Industrial Administration, CMU, 1976.
+
+George Dantzig, Ray Fulkerson, and Selmer Johnson. Solution of a large-scale traveling-salesman problem. Journal of the operations research society of America, 1954.
+
+Richard Durbin. An analogue approach to the Travelling Salesman. Nature, 326:16, 1987.
+
+Favio Favata and Richard Walker. A study of the application of Kohonen-type neural networks to the travelling salesman problem. Biological Cybernetics, 64(6):463–468, 1991.
+
+J. C. Fort. Solving a combinatorial problem via self-organizing process: an application of the Kohonen algorithm to the traveling salesman problem. Biological Cybernetics, 59(1):33–40, 1988.
+
+Andrew Howard Gee. Problem solving with optimization networks. PhD thesis, Citeseer, 1993.
+
+Fred Glover and Manuel Laguna. Tabu Search. Springer, 2013.
+
+Google. Or-tools, google optimization tools, 2016. URL https://developers.google. com/optimization.
+
+Keld Helsgaun. An effective implementation of the Lin-Kernighan traveling salesman. European Journal of Operational Research, 126:106–130, 2000.
+
+Keld Helsgaun. LK-H, 2012. URL http://akira.ruc.dk/˜keld/research/LKH/.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. Neural Computations, 1997.
+
+John J. Hopfield and David W. Tank. ”Neural” computation of decisions in optimization problems. Biological Cybernetics, 52(3):141–152, 1985.
+
+DS Johnson. Local search and the traveling salesman problem. In Proceedings of 17th International Colloquium on Automata Languages and Programming, Lecture Notes in Computer Science,(Springer-Verlag, Berlin, 1990), pp. 443–460, 1990.
+
+Hans Kellerer, Ulrich Pferschy, and David Pisinger. Knapsack Problems. Springer-Verlag Berlin Heidelberg, 2004.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2014.
+
+S. Kirkpatrick, C. D. Gelatt, and M. P. Vecchi. Optimization by simulated annealing. SCIENCE, 220, 1983.
+
+Teuvo Kohonen. The self-organizing map. Proceedings of the IEEE, 78(9):1464–1480, 1990.
+
+Bert F. J. La Maire and Valeri M. Mladenov. Comparison of neural networks for solving the Travelling Salesman Problem. In NEUREL, pp. 21–24. IEEE, 2012.
+
+S. Lin and B. W. Kernighan. An effective heuristic algorithm for the traveling-salesman problem. Operations Research, 21(2):498–516, 1973.
+
+Volodymyr Mnih, Adri Puigdomnech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. arXiv preprint arXiv:1605.03835, 2016.
+
+Manfred Padberg and Giovanni Rinaldi. A branch-and-cut algorithm for the resolution of largescale symmetric traveling salesman problems. Society for Industrial and Applied Mathematics, 33:60–100, 1990.
+
+Christos H. Papadimitriou. The Euclidean Travelling Salesman Problem is NP-complete. Theoretical Computer Science, 4(3):237–244, 1977.
+
+David Pisinger. An expanding-core algorithm for the exact 0-1 knapsack problem european journal of operational research. European Journal of Operational Research, pp. 175–187, 1995.
+
+David Pisinger. A minimal algorithm for the 0-1 knapsack problem. Operations Research, pp. 758–767, 1997.
+
+Farah Sarwar and Abdul Aziz Bhatti. Critical analysis of Hopfield’s neural network model for TSP and its comparison with heuristic algorithm for shortest path computation. In IBCAST, 2012.
+
+Kate A. Smith. Neural networks for combinatorial optimization: a review of more than a decade of research. INFORMS Journal on Computing, 1999.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, pp. 3104–3112, 2014.
+
+Andrew I. Vakhutinsky and Bruce L. Golden. A hierarchical strategy for solving traveling salesman problems using elastic nets. Journal of Heuristics, 1(1):67–76, 1995.
+
+Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: Sequence to sequence for sets. arXiv preprint arXiv:1511.06391, 2015a.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015b.
+
+Christos Voudouris and Edward Tsang. Guided local search and its application to the traveling salesman problem. European journal of operational research, 1999.
+
+Ronald Williams. Simple statistical gradient following algorithms for connectionnist reinforcement learning. In Machine Learning, 1992.
+
+G. V. Wilson and G. S. Pawley. On the stability of the travelling salesman problem algorithm of hopfield and tank. Biological Cybernetics, 58(1):63–70, 1988.
+
+D. H. Wolpert and W. G. Macready. No free lunch theorems for optimization. Transactions on Evolutionary Computation, 1(1):67–82, April 1997.
+
+Chen Yutian, Hoffman Matthew W., Colmenarejo Sergio Gomez, Denil Misha, Lillicrap Timothy P., and de Freitas Nando. Learning to learn for global optimization of black box functions. arXiv preprint arXiv:1611.03824, 2016.
+
+Barret Zoph and Quoc Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+# A APPENDIX
+
+# A.1 POINTING AND ATTENDING
+
+Pointing mechanism: Its computations are parameterized by two attention matrices $W _ { r e f } , W _ { q } \in$ $\mathbb { R } ^ { d \times d }$ and an attention vector $v \in \mathbb { R } ^ { d }$ as follows:
+
+$$
+\begin{array} { r l } & { { u _ { i } } = \left\{ \begin{array} { l l } { { v ^ { \top } } \cdot \operatorname { t a n h } \left( { W _ { r e f } } \cdot { r _ { i } } + { W _ { q } } \cdot q \right) } & { \mathrm { i f ~ } i \ne \pi ( j ) \mathrm { ~ f o r ~ a l l ~ } j < i } \\ { - \infty } & { \mathrm { o t h e r w i s e } } \end{array} \right. \mathrm { f o r ~ } i = 1 , 2 , . . . , k } \\ & { A ( r e f , q ; W _ { r e f } , W _ { q } , v ) \stackrel { \mathrm { d e f } } { = } s o f t m a x ( u ) . } \end{array}
+$$
+
+Our pointer network, at decoder step $j$ , then assigns the probability of visiting the next point $\pi ( j )$ of the tour as follows:
+
+$$
+p ( \pi ( j ) | \pi ( < j ) , s ) \stackrel { \mathrm { d e f } } { = } A ( e n c _ { 1 : n } , d e c _ { j } ) .
+$$
+
+Setting the logits of cities that already appeared in the tour to $- \infty$ , as shown in Equation 8, ensures that our model only points at cities that have yet to be visited and hence outputs valid TSP tours.
+
+Attending mechanism: Specifically, our glimpse function $G ( r e f , q )$ takes the same inputs as the attention function $A$ and is parameterized by $\bar { W } _ { r e f } ^ { g } , W _ { q } ^ { g } \in \mathbb { R } ^ { \bar { d } \times \bar { d } }$ and $v ^ { g } \in \mathbb { R } ^ { d }$ . It performs the following computations:
+
+$$
+\begin{array} { l } { { \displaystyle p = A ( r e f , q ; W _ { r e f } ^ { g } , W _ { q } ^ { g } , v ^ { g } ) } } \\ { { \displaystyle G ( r e f , q ; W _ { r e f } ^ { g } , W _ { q } ^ { g } , v ^ { g } ) \stackrel { \mathrm { d e f } } { = } \sum _ { i = 1 } ^ { k } r _ { i } p _ { i } . } } \end{array}
+$$
+
+The glimpse function $G$ essentially computes a linear combination of the reference vectors weighted by the attention probabilities. It can also be applied multiple times on the same reference set $r e f$ :
+
+$$
+\begin{array} { l } { g _ { 0 } \stackrel { \mathrm { d e f } } { = } q } \\ { g _ { l } \stackrel { \mathrm { d e f } } { = } G ( r e f , g _ { l - 1 } ; W _ { r e f } ^ { g } , W _ { q } ^ { g } , v ^ { g } ) } \end{array}
+$$
+
+Finally, the ultimate $g _ { l }$ vector is passed to the attention function $A ( r e f , g _ { l } ; W _ { r e f } , W _ { q } , v )$ to produce the probabilities of the pointing mechanism. We observed empirically that glimpsing more than once with the same parameters made the model less likely to learn and barely improved the results.
+
+# A.2 IMPROVING EXPLORATION
+
+Softmax temperature: We modify Equation 9 as follows:
+
+$$
+A ( r e f , q , T ; W _ { r e f } , W _ { q } , v ) \stackrel { \mathrm { d e f } } { = } s o f t m a x ( u / T ) ,
+$$
+
+where $T$ is a temperature hyperparameter set to $T = 1$ during training. When $T > 1$ , the distribution represented by $A ( r e f , q )$ becomes less steep, hence preventing the model from being overconfident.
+
+Logit clipping: We modify Equation 9 as follows:
+
+$$
+A ( r e f , q ; W _ { r e f } , W _ { q } , v ) \stackrel { \mathrm { d e f } } { = } s o f t m a x ( C \operatorname { t a n h } ( u ) ) ,
+$$
+
+where $C$ is a hyperparameter that controls the range of the logits and hence the entropy of $A ( r e f , q )$
+
+# A.3 OR TOOL’S METAHEURISTICS BASELINES FOR TSP
+
+Table 6: Performance of OR-Tools’ metaheuristics as they consider more solutions. Corresponding running times in seconds (s) on a single Intel Haswell CPU are in parantheses.   
+
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>#Solutions</td><td rowspan=1 colspan=1>Simulated Annealing</td><td rowspan=1 colspan=1>Tabu Search</td><td rowspan=1 colspan=1>Guided Local Search</td></tr><tr><td rowspan=4 colspan=1>TSP50</td><td rowspan=4 colspan=1>11281,28012,800128.0001,280,000</td><td rowspan=2 colspan=1>6.62 (0.03s)5.81 (0.24s)</td><td rowspan=1 colspan=1>6.62 (0.03s)</td><td rowspan=4 colspan=1>6.62 (0.03s)5.76 (0.5s)5.69 (5s)5.68 (48s)5.68 (450s)5.68 (4530s)</td></tr><tr><td rowspan=1 colspan=1>5.79 (3.4s)</td></tr><tr><td rowspan=2 colspan=1>5.81 (4.2s)5.81 (44s)5.81 (460s)5.81 (3960s)</td><td rowspan=1 colspan=1>5.73 (36s)5.69 (330s)</td></tr><tr><td rowspan=1 colspan=1>5.68 (3200s)5.68 (29650s)</td></tr><tr><td rowspan=2 colspan=1>TSP100</td><td rowspan=2 colspan=1>11281,28012,800128.0001,280,000</td><td rowspan=2 colspan=1>9.18 (0.07s)8.00 (0.67s)7.99 (15.7s)7.99 (166s)7.99 (1650s)7.99 (15810s)</td><td rowspan=1 colspan=1>9.18 (0.07s)7.99 (15.3s)</td><td rowspan=2 colspan=1>9.18 (0.07s)7.94 (1.44s)7.84 (18.4s)7.77 (182s)7.77 (1740s)7.77 (16150s)</td></tr><tr><td rowspan=1 colspan=1>7.93 (255s)7.84 (2460s)7.79 (22740s)7.78 (208230s)</td></tr></table>
+
+# A.4 SAMPLE TOURS
+
+![](images/cf80da1b4bfc812d8683181d0df5aa70e02d9a19ab9a78d326884784f5fcf757.jpg)  
+Figure 4: Sample tours. Top: TSP50; Bottom: TSP100.

parse/train/rJY3vK9eg/rJY3vK9eg_content_list.json

@@ -0,0 +1,1956 @@
+[
+    {
+        "type": "text",
+        "text": "NEURAL COMBINATORIAL OPTIMIZATION WITH REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            679,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Irwan Bello∗, Hieu Pham∗, Quoc V. Le, Mohammad Norouzi, Samy Bengi Google Brain {ibello,hyhieu,qvl,mnorouzi,bengio}@google.com ",
+        "bbox": [
+            183,
+            170,
+            691,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper presents a framework to tackle combinatorial optimization problems using neural networks and reinforcement learning. We focus on the traveling salesman problem (TSP) and train a recurrent neural network that, given a set of city coordinates, predicts a distribution over different city permutations. Using negative tour length as the reward signal, we optimize the parameters of the recurrent neural network using a policy gradient method. We compare learning the network parameters on a set of training graphs against learning them on individual test graphs. Without much engineering and heuristic designing, Neural Combinatorial Optimization achieves close to optimal results on 2D Euclidean graphs with up to 100 nodes. Applied to the KnapSack, another NP-hard problem, the same method obtains optimal solutions for instances with up to 200 items. These results, albeit still far from state-of-the-art, give insights into how neural networks can be used as a general tool for tackling combinatorial optimization problems. ",
+        "bbox": [
+            233,
+            281,
+            764,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            334,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Combinatorial optimization is a fundamental problem in computer science. A canonical example is the traveling salesman problem (TSP), where given a graph, one needs to search the space of permutations to find an optimal sequence of nodes with minimal total edge weights (tour length). The TSP and its variants have myriad applications in planning, manufacturing, genetics, etc. (see (Applegate et al., 2011) for an overview). ",
+        "bbox": [
+            176,
+            518,
+            825,
+            587
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Finding the optimal TSP solution is NP-hard, even in the two-dimensional Euclidean case (Papadimitriou, 1977), where the nodes are 2D points and edge weights are Euclidean distances between pairs of points. In practice, TSP solvers rely on handcrafted heuristics that guide their search procedures to find competitive (and in many cases optimal) tours efficiently. Even though these heuristics work well on TSP, once the problem statement changes slightly, they need to be revised. In contrast, machine learning methods have the potential to be applicable across many optimization tasks by automatically discovering their own heuristics based on the training data, thus requiring less handengineering than solvers that are optimized for one task only. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While most successful machine learning techniques fall into the family of supervised learning, where a mapping from training inputs to outputs is learned, supervised learning is not applicable to most combinatorial optimization problems because one does not have access to optimal labels. However, one can compare the quality of a set of solutions using a verifier, and provide some reward feedbacks to a learning algorithm. Hence, we follow the reinforcement learning (RL) paradigm to tackle combinatorial optimization. We empirically demonstrate that, even when using optimal solutions as labeled data to optimize a supervised mapping, the generalization is rather poor compared to an RL agent that explores different tours and observes their corresponding rewards. ",
+        "bbox": [
+            174,
+            713,
+            823,
+            825
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose Neural Combinatorial Optimization, a framework to tackle combinatorial optimization problems using reinforcement learning and neural networks. We consider two approaches based on policy gradients (Williams, 1992). The first approach, called RL pretraining, uses a training set to optimize a recurrent neural network (RNN) that parameterizes a stochastic policy over solutions, using the expected reward as objective. At test time, the policy is fixed, and one performs inference by greedy decoding or sampling. The second approach, called active search, involves no pretraining. It starts from a random policy and iteratively optimizes the RNN parameters on a single test instance, again using the expected reward objective, while keeping track of the best solution sampled during the search. We find that combining RL pretraining and active search works best in practice. ",
+        "bbox": [
+            176,
+            832,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ff035637247f258db525f5d1f250cf5f2bbb4ac3018e402f402b8331eb07fd5.jpg",
+        "image_caption": [
+            "Figure 1: Tour length ratios of LK-H (Helsgaun, 2000) local search and our best method (RL pretraining-Active Search) against optimality, guaranteed by Concorde (Applegate et al., 2006). Generic local search, obtained via Googles vehicle routing problem solver (Google, 2016), applies a set of heuristics starting from the (Christofides, 1976) solution. Note that our method is five orders of magnitude slower than LK-H and Concorde. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            109,
+            799,
+            272
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            391,
+            823,
+            446
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "On 2D Euclidean graphs with up to 100 nodes, Neural Combinatorial Optimization significantly outperforms the supervised learning approach to the TSP (Vinyals et al., 2015b) and obtains close to optimal results when allowed more computation time (see Figure 1). We illustrate the flexibility of the method by also applying it to the KnapSack problem, for which we get optimal results for instances with up to 200 items. Our results, while still inferior to the state-of-the-art in many dimensions (such as speed, scale and performance), give insights into how neural networks can be used as a general tool for tackling combinatorial optimization problems, especially those that are difficult to design heuristics for. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PREVIOUS WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            585,
+            351,
+            602
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Traveling Salesman Problem is a well studied combinatorial optimization problem and many exact or approximate algorithms have been proposed for both Euclidean and non-Euclidean graphs. Christofides (1976) proposes a heuristic algorithm that involves computing a minimum-spanning tree and a minimum-weight perfect matching. The algorithm has polynomial running time and returns solutions that are guaranteed to be within a factor of $1 . 5 \\times$ to optimality in the metric instance of the TSP. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The best known exact dynamic programming algorithm for TSP has a complexity of $\\Theta ( 2 ^ { n } n ^ { 2 } )$ , making it infeasible to scale up to large instances, say with 40 points. Nevertheless, state of the art TSP solvers, thanks to carefully handcrafted heuristics that describe how to navigate the space of feasible solutions in an efficient manner, can solve symmetric TSP instances with thousands of nodes. Concorde (Applegate et al., 2006), widely accepted as one of the best exact TSP solvers, makes use of cutting plane algorithms (Dantzig et al., 1954; Padberg & Rinaldi, 1990; Applegate et al., 2003), iteratively solving linear programming relaxations of the TSP, in conjunction with a branch-and-bound approach that prunes parts of the search space that provably will not contain an optimal solution. Similarly, the Lin-Kernighan-Helsgaun heuristic (Helsgaun, 2000), inspired from the Lin-Kernighan heuristic (Lin & Kernighan, 1973), is a state of the art approximate search heuristic for the symmetric TSP and has been shown to solve instances with hundreds of nodes to optimality. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More generic solvers, such as Google’s vehicle routing problem solver (Google, 2016) that tackles a superset of the TSP, typically rely on a combination of local search algorithms and metaheuristics. Local search algorithms apply a specified set of local move operators on candidate solutions, based on hand-engineered heuristics such as 2-opt (Johnson, 1990), to navigate from solution to solution in the search space. A metaheuristic is then applied to propose uphill moves and escape local optima. A popular choice of metaheuristic for the TSP and its variants is guided local search (Voudouris & Tsang, 1999), which moves out of a local minimum by penalizing particular solution features that it considers should not occur in a good solution. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The difficulty in applying existing search heuristics to newly encountered problems - or even new instances of a similar problem - is a well-known challenge that stems from the No Free Lunch theorem (Wolpert & Macready, 1997). Because all search algorithms have the same performance when averaged over all problems, one must appropriately rely on a prior over problems when selecting a search algorithm to guarantee performance. This challenge has fostered interest in raising the level of generality at which optimization systems operate (Burke et al., 2003) and is the underlying motivation behind hyper-heuristics, defined as ”search method[s] or learning mechanism[s] for selecting or generating heuristics to solve computation search problems”. Hyper-heuristics aim to be easier to use than problem specific methods by partially abstracting away the knowledge intensive process of selecting heuristics given a combinatorial problem and have been shown to successfully combine human-defined heuristics in superior ways across many tasks (see (Burke et al., 2013) for a survey). However, hyper-heuristics operate on the search space of heuristics, rather than the search space of solutions, therefore still initially relying on human created heuristics. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The application of neural networks to combinatorial optimization has a distinguished history, where the majority of research focuses on the Traveling Salesman Problem (Smith, 1999). One of the earliest proposals is the use of Hopfield networks (Hopfield & Tank, 1985) for the TSP. The authors modify the network’s energy function to make it equivalent to TSP objective and use Lagrange multipliers to penalize the violations of the problem’s constraints. A limitation of this approach is that it is sensitive to hyperparameters and parameter initialization as analyzed by (Wilson & Pawley, 1988). Overcoming this limitation is central to the subsequent work in the field, especially by (Aiyer et al., 1990; Gee, 1993). Parallel to the development of Hopfield networks is the work on using deformable template models to solve TSP. Perhaps most prominent is the invention of Elastic Nets as a means to solve TSP (Durbin, 1987), and the application of Self Organizing Map to TSP (Fort, 1988; Angeniol et al., 1988; Kohonen, 1990). Addressing the limitations of deformable template models is central to the following work in this area (Burke, 1994; Favata & Walker, 1991; Vakhutinsky & Golden, 1995). Even though these neural networks have many appealing properties, they are still limited as research work. When being carefully benchmarked, they have not yielded satisfying results compared to algorithmic methods (Sarwar & Bhatti, 2012; La Maire & Mladenov, 2012). Perhaps due to the negative results, this research direction is largely overlooked since the turn of the century. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            603
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Motivated by the recent advancements in sequence-to-sequence learning (Sutskever et al., 2014), neural networks are again the subject of study for optimization in various domains (Yutian et al., 2016), including discrete ones (Zoph & Le, 2016). In particular, the TSP is revisited in the introduction of Pointer Networks (Vinyals et al., 2015b), where a recurrent network with non-parametric softmaxes is trained in a supervised manner to predict the sequence of visited cities. Despite architecural improvements, their models were trained using supervised signals given by an approximate solver. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 NEURAL NETWORK ARCHITECTURE FOR TSP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            589,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We focus on the 2D Euclidean TSP in this paper. Given an input graph, represented as a sequence of $n$ cities in a two dimensional space $s = \\{ \\mathbf { \\bar { x } } _ { i } \\} _ { i = 1 } ^ { n }$ where each $\\bar { \\mathbf { x } } _ { i } \\in \\mathbb { R } ^ { 2 }$ , we are concerned with finding a permutation of the points $\\pi$ , termed a tour, that visits each city once and has the minimum total length. We define the length of a tour defined by a permutation $\\pi$ as ",
+        "bbox": [
+            174,
+            760,
+            825,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8315780cf0ed72769391b2e6630643d3c8751a5104cb1e8144b3eee14fecd60d.jpg",
+        "text": "$$\nL ( \\pi \\mid s ) = \\left\\| \\mathbf { x } _ { \\pi ( n ) } - \\mathbf { x } _ { \\pi ( 1 ) } \\right\\| _ { 2 } + \\sum _ { i = 1 } ^ { n - 1 } \\left\\| \\mathbf { x } _ { \\pi ( i ) } - \\mathbf { x } _ { \\pi ( i + 1 ) } \\right\\| _ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            823,
+            689,
+            867
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\lVert \\cdot \\rVert _ { 2 }$ denotes $\\ell _ { 2 }$ norm. ",
+        "bbox": [
+            174,
+            875,
+            362,
+            890
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We aim to learn the parameters of a stochastic policy $p ( \\pi \\mid s )$ that given an input set of points $s$ assigns high probabilities to short tours and low probabilities to long tours. Our neural network ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/617f6b30f93ad3f6b942335c7b275ae2f57b67551499b6e623f271e6b3996445.jpg",
+        "image_caption": [
+            "Figure 2: A pointer network architecture introduced by (Vinyals et al., 2015b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            99,
+            730,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "architecture uses the chain rule to factorize the probability of a tour as ",
+        "bbox": [
+            173,
+            330,
+            632,
+            344
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/34416e5569ceda79b104df30d955df7fe159ac7e70e2cf81881470d9502ead3c.jpg",
+        "text": "$$\np ( \\pi \\mid s ) = \\prod _ { i = 1 } ^ { n } p \\left( \\pi ( i ) \\mid \\pi ( < i ) , s \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            348,
+            617,
+            390
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and then uses individual softmax modules to represent each term on the RHS of (2). ",
+        "bbox": [
+            176,
+            393,
+            720,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We are inspired by previous work (Sutskever et al., 2014) that makes use of the same factorization based on the chain rule to address sequence to sequence problems like machine translation. One can use a vanilla sequence to sequence model to address the TSP where the output vocabulary is $\\{ 1 , 2 , \\ldots , n \\}$ . However, there are two major issues with this approach: (1) networks trained in this fashion cannot generalize to inputs with more than $n$ cities. (2) one needs to have access to groundtruth output permutations to optimize the parameters with conditional log-likelihood. We address both isssues in this paper. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            512
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For generalization beyond a pre-specified graph size, we follow the approach of (Vinyals et al., 2015b), which makes use of a set of non-parameteric softmax modules, resembling the attention mechanism from (Bahdanau et al., 2015). This approach, named pointer network, allows the model to effectively point to a specific position in the input sequence rather than predicting an index value from a fixed-size vocabulary. We employ the pointer network architecture, depicted in Figure 2, as our policy model to parameterize $p ( \\pi \\mid s )$ . ",
+        "bbox": [
+            174,
+            518,
+            825,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 ARCHITECTURE DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            619,
+            392,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our pointer network comprises two recurrent neural network (RNN) modules, encoder and decoder, both of which consist of Long Short-Term Memory (LSTM) cells (Hochreiter & Schmidhuber, 1997). The encoder network reads the input sequence $s$ , one city at a time, and transforms it into a sequence of latent memory states $\\{ e n c _ { i } \\} _ { i = 1 } ^ { n }$ where $e n c _ { i } \\in \\mathbb { R } ^ { d }$ . The input to the encoder network at time step $i$ is a $d$ -dimensional embedding of a 2D point $\\mathbf { x } _ { i }$ , which is obtained via a linear transformation of $\\mathbf { x } _ { i }$ shared across all input steps. The decoder network also maintains its latent memory states $\\{ d e c _ { i } \\} _ { i = 1 } ^ { n }$ where $d e c _ { i } \\in \\mathbb { R } ^ { d }$ and, at each step $i$ , uses a pointing mechanism to produce a distribution over the next city to visit in the tour. Once the next city is selected, it is passed as the input to the next decoder step. The input of the first decoder step (denoted by $\\langle g \\rangle$ in Figure 2) is a d-dimensional vector treated as a trainable parameter of our neural network. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            784
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our attention function, formally defined in Appendix A.1, takes as input a query vector $q = d e c _ { i } \\in$ $\\mathbb { R } ^ { d }$ and a set of reference vectors $r e f = \\{ e n c _ { 1 } , \\ldots , e n c _ { k } \\}$ where $e n c _ { i } \\in \\bar { \\mathbb { R } } ^ { d }$ , and predicts a distribution $A ( r e f , q )$ over the set of $k$ references. This probability distribution represents the degree to which the model is pointing to reference $r _ { i }$ upon seeing query $q$ . ",
+        "bbox": [
+            174,
+            790,
+            825,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Vinyals et al. (2015a) also suggest including some additional computation steps, named glimpses, to aggregate the contributions of different parts of the input sequence, very much like (Bahdanau et al., 2015). We discuss this approach in details in Appendix A.1. In our experiments, we find that utilizing one glimpse in the pointing mechanism yields performance gains at an insignificant cost latency. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Actor-critic training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            397,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: procedure TRAIN(training set $S$ , number of training steps $T$ , batch size $B$ )   \n2: Initialize pointer network params $\\theta$   \n3: Initialize critic network params $\\theta _ { v }$   \n4: for $t = 1$ to $T$ do   \n5: $s _ { i } \\sim \\operatorname { S A M P L E I N P U T } ( S )$ for $i \\in \\{ 1 , \\ldots , B \\}$   \n6: $\\pi _ { i } \\sim$ SAMPLESOLUTION $\\left( \\boldsymbol { p } _ { \\boldsymbol { \\theta } } ( . | \\boldsymbol { s } _ { i } ) \\right)$ for $i \\in \\{ 1 , \\ldots , B \\}$   \n7: $b _ { i }  b _ { \\theta _ { v } } ( s _ { i } )$ for $i \\in \\{ 1 , \\ldots , B \\}$   \n8: $\\begin{array} { r } { g _ { \\theta }  \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } ( L ( \\pi _ { i } | s _ { i } ) - b _ { i } ) \\nabla _ { \\theta } \\log p _ { \\theta } ( \\pi _ { i } | s _ { i } ) } \\end{array}$   \n9: $\\begin{array} { r } { \\mathcal { L } _ { v }  \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } \\| b _ { i } - L ( \\pi _ { i } ) \\| _ { 2 } ^ { 2 } } \\end{array}$   \n10: θ ← ADAM(θ, gθ)   \n11: $\\boldsymbol { \\theta } _ { v } \\gets \\mathrm { A D A M } ( \\theta _ { v } , \\nabla { \\theta } _ { v } \\mathcal { L } _ { v } )$   \n12: end for   \n13: return θ   \n14: end procedure ",
+        "bbox": [
+            176,
+            122,
+            648,
+            309
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 OPTIMIZATION WITH POLICY GRADIENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            335,
+            549,
+            351
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Vinyals et al. (2015b) proposes training a pointer network using a supervised loss function comprising conditional log-likelihood, which factors into a cross entropy objective between the network’s output probabilities and the targets provided by a TSP solver. Learning from examples in such a way is undesirable for NP-hard problems because (1) the performance of the model is tied to the quality of the supervised labels, (2) getting high-quality labeled data is expensive and may be infeasible for new problem statements, (3) one cares about finding a competitive solution more than replicating the results of another algorithm. ",
+        "bbox": [
+            173,
+            366,
+            825,
+            463
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By contrast, we believe Reinforcement Learning (RL) provides an appropriate paradigm for training neural networks for combinatorial optimization, especially because these problems have relatively simple reward mechanisms that could be even used at test time. We hence propose to use model-free policy-based Reinforcement Learning to optimize the parameters of a pointer network denoted $\\pmb \\theta$ . Our training objective is the expected tour length which, given an input graph $s$ , is defined as ",
+        "bbox": [
+            173,
+            469,
+            825,
+            540
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aaa88af7e50ba08b4ca380bc41186738523f79602a6098ace0951fbec4b34598.jpg",
+        "text": "$$\nJ ( \\pmb \\theta \\mid s ) = \\mathbb { E } _ { \\pi \\sim p _ { \\theta } ( . \\mid s ) } L ( \\pi \\mid s ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            547,
+            606,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "During training, our graphs are drawn from a distribution $s$ , and the total training objective involves sampling from the distribution of graphs, i.e. $J ( \\pmb \\theta ) = \\mathbb { E } _ { s \\sim S } J ( \\pmb \\theta \\mid s )$ . ",
+        "bbox": [
+            173,
+            570,
+            825,
+            601
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We resort to policy gradient methods and stochastic gradient descent to optimize the parameters. The gradient of (3) is formulated using the well-known REINFORCE algorithm (Williams, 1992): ",
+        "bbox": [
+            173,
+            606,
+            821,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/950d4930c5f14fb8456ff66ebf5ad3cfe347d13336b4e19275d9a609e3453d92.jpg",
+        "text": "$$\n\\nabla _ { \\theta } J ( \\theta \\mid s ) = \\mathbb { E } _ { \\pi \\sim p _ { \\theta } ( . \\mid s ) } \\Big [ \\big ( L ( \\pi \\mid s ) - b ( s ) \\big ) \\nabla _ { \\theta } \\log p _ { \\theta } ( \\pi \\mid s ) \\Big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            642,
+            704,
+            669
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $b ( s )$ denotes a baseline function that does not depend on $\\pi$ and estimates the expected tour length to reduce the variance of the gradients. ",
+        "bbox": [
+            171,
+            676,
+            823,
+            704
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By drawing $B$ i.i.d. sample graphs $s _ { 1 } , s _ { 2 } , \\ldots , s _ { B } \\sim \\mathcal { S }$ and sampling a single tour per graph, i.e. $\\pi _ { i } \\sim p _ { \\theta } ( . \\mid s _ { i } )$ , the gradient in (4) is approximated with Monte Carlo sampling as follows: ",
+        "bbox": [
+            173,
+            712,
+            823,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e666c4d4235878154bd4d3148c683188496512a044d0a73cbfb2a1156936a53c.jpg",
+        "text": "$$\n\\nabla _ { \\theta } J ( \\theta ) \\approx \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } \\Big ( L ( \\pi _ { i } | s _ { i } ) - b ( s _ { i } ) \\Big ) \\nabla _ { \\theta } \\log p _ { \\theta } ( \\pi _ { i } \\mid s _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            747,
+            692,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A simple and popular choice of the baseline $b ( s )$ is an exponential moving average of the rewards obtained by the network over time to account for the fact that the policy improves with training. While this choice of baseline proved sufficient to improve upon the Christofides algorithm, it suffers from not being able to differentiate between different input graphs. In particular, the optimal tour $\\pi ^ { * }$ for a difficult graph $s$ may be still discouraged if $L ( \\pi ^ { * } | s ) > b$ because $b$ is shared across all instances in the batch. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using a parametric baseline to estimate the expected tour length $\\mathbb { E } _ { \\pi \\sim p _ { \\theta } ( . | s ) } L ( \\pi \\mid s )$ typically improves learning. Therefore, we introduce an auxiliary network, called a critic and parameterized ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Active Search ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            356,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: procedure ACTIVESEARCH(input s, $\\theta$ , number of candidates K, B,   \n2: π ← RANDOMSOLUTION()   \n3: Lπ ← L(π | s)   \n4: n ← d KB e   \n5: for t = 1 . . . n do   \n6: πi ∼ SAMPLESOLUTION(pθ(. | s)) for $i \\in \\{ 1 , \\ldots , B \\}$   \n7: j ← ARGMIN(L(π1 | s) . . . L(πB | s))   \n8: Lj ← L(πj | s)   \n9: if Lj < Lπ then   \n10: π ← πj   \n11: Lπ ← Lj   \n12: 13: 14: $\\begin{array} { r l } & { \\overset { \\vartriangle } { \\boldsymbol { g } _ { \\theta } }  \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } ( L ( \\pi _ { i } \\mid \\boldsymbol { s } ) - b ) \\nabla _ { \\theta } \\log p _ { \\theta } ( \\pi _ { i } \\mid \\boldsymbol { s } ) } \\\\ & { \\overset { \\theta  \\boldsymbol { \\mathrm { A D A M } } } { \\boldsymbol { b } } + ( 1 - \\alpha ) \\times ( \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } b _ { i } ) } \\\\ & { \\overset { \\boldsymbol { b } } { \\underset {  } { \\boldsymbol { b } } }  \\alpha \\times \\boldsymbol { b } + ( 1 - \\alpha ) \\times ( \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } b _ { i } ) } \\end{array}$   \n15:   \n16: end for   \n17: return $\\pi$   \n18: end procedure ",
+        "bbox": [
+            176,
+            122,
+            593,
+            356
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "by $\\theta _ { v }$ , to learn the expected tour length found by our current policy $p _ { \\theta }$ given an input sequence $s$ The critic is trained with stochastic gradient descent on a mean squared error objective between its predictions $b _ { \\theta _ { v } } \\left( s \\right)$ and the actual tour lengths sampled by the most recent policy. The additional objective is formulated as ",
+        "bbox": [
+            174,
+            385,
+            823,
+            440
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b9e3f5858a75435786c4deba923072020b2de4edd46d87a26fa656b75314b53.jpg",
+        "text": "$$\n\\mathcal { L } ( \\theta _ { v } ) = \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } \\left. b _ { \\theta _ { v } } ( s _ { i } ) - L ( \\pi _ { i } \\mid s _ { i } ) \\right. _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            449,
+            642,
+            492
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Critic’s architecture for TSP. We now explain how our critic maps an input sequence $s$ into a baseline prediction $b _ { \\theta _ { v } } \\left( s \\right)$ . Our critic comprises three neural network modules: 1) an LSTM encoder, 2) an LSTM process block and 3) a 2-layer ReLU neural network decoder. Its encoder has the same architecture as that of our pointer network’s encoder and encodes an input sequence $s$ into a sequence of latent memory states and a hidden state $h$ . The process block, similarly to (Vinyals et al., 2015a), then performs $\\mathrm { \\bf P }$ steps of computation over the hidden state $h$ . Each processing step updates this hidden state by glimpsing at the memory states as described in Appendix A.1 and feeds the output of the glimpse function as input to the next processing step. At the end of the process block, the obtained hidden state is then decoded into a baseline prediction (i.e a single scalar) by two fully connected layers with respectively d and 1 unit(s). ",
+        "bbox": [
+            173,
+            506,
+            825,
+            646
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our training algorithm, described in Algorithm 1, is closely related to the asynchronous advantage actor-critic (A3C) proposed in (Mnih et al., 2016), as the difference between the sampled tour lengths and the critic’s predictions is an unbiased estimate of the advantage function. We perform our updates asynchronously across multiple workers, but each worker also handles a mini-batch of graphs for better gradient estimates. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            723
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 SEARCH STRATEGIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            741,
+            362,
+            755
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As evaluating a tour length is inexpensive, our TSP agent can easily simulate a search procedure at inference time by considering multiple candidate solutions per graph and selecting the best. This inference process resembles how solvers search over a large set of feasible solutions. In this paper, we consider two search strategies detailed below, which we refer to as sampling and active search. ",
+        "bbox": [
+            174,
+            767,
+            823,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sampling. Our first approach is simply to sample multiple candidate tours from our stochastic policy $p _ { \\theta } ( . | s )$ and select the shortest one. In contrast to heuristic solvers, we do not enforce our model to sample different tours during the process. However, we can control the diversity of the sampled tours with a temperature hyperparameter when sampling from our non-parametric softmax (see Appendix A.2). This sampling process yields significant improvements over greedy decoding, which always selects the index with the largest probability. We also considered perturbing the pointing mechanism with random noise and greedily decoding from the obtained modified policy, similarly to (Cho, 2016), but this proves less effective than sampling in our experiments. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/de2ceb36ca965bc4826aa9e1cb6fa8ed6c7173e9dba936caec5eca28af0484b1.jpg",
+        "table_caption": [
+            "Table 1: Different learning configurations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Configuration</td><td rowspan=1 colspan=1>Learn ontraining data</td><td rowspan=1 colspan=1>Samplingon test set</td><td rowspan=1 colspan=1>Refiningon test set</td></tr><tr><td rowspan=1 colspan=1>RL pretraining-Greedy</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>No</td></tr><tr><td rowspan=1 colspan=1>Active Search (AS)</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Yes</td></tr><tr><td rowspan=1 colspan=1>RL pretraining-Sampling</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>No</td></tr><tr><td rowspan=1 colspan=1>RL pretraining-Active Search</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Yes</td></tr></table>",
+        "bbox": [
+            272,
+            122,
+            722,
+            203
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            233,
+            820,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Active Search. Rather than sampling with a fixed model and ignoring the reward information obtained from the sampled solutions, one can refine the parameters of the stochastic policy $p _ { \\theta }$ during inference to minimize $\\mathbb { E } _ { \\pi \\sim p _ { \\theta } ( . | s ) } L ( \\pi \\mid s )$ on a single test input $s$ . This approach proves especially competitive when starting from a trained model. Remarkably, it also produces satisfying solutions when starting from an untrained model. We refer to these two approaches as $R L$ pretraining-Active Search and Active Search because the model actively updates its parameters while searching for candidate solutions on a single test instance. ",
+        "bbox": [
+            174,
+            282,
+            825,
+            380
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Active Search applies policy gradients similarly to Algorithm 1 but draws Monte Carlo samples over candidate solutions $\\pi _ { 1 } \\ldots \\pi _ { B } \\sim p _ { \\theta } ( \\cdot | s ) $ for a single test input. It resorts to an exponential moving average baseline, rather than a critic, as there is no need to differentiate between inputs. Our Active Search training algorithm is presented in Algorithm 2. We note that while RL training does not require supervision, it still requires training data and hence generalization depends on the training data distribution. In contrast, Active Search is distribution independent. Finally, since we encode a set of cities as a sequence, we randomly shuffle the input sequence before feeding it to our pointer network. This increases the stochasticity of the sampling procedure and leads to large improvements in Active Search. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            512
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            326,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments to investigate the behavior of the proposed Neural Combinatorial Optimization methods. We consider three benchmark tasks, Euclidean TSP20, 50 and 100, for which we generate a test set of 1, 000 graphs. Points are drawn uniformly at random in the unit square $[ 0 , 1 ] ^ { 2 }$ . ",
+        "bbox": [
+            176,
+            573,
+            825,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            638,
+            387,
+            652
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Across all experiments, we use mini-batches of 128 sequences, LSTM cells with 128 hidden units, and embed the two coordinates of each point in a 128-dimensional space. We train our models with the Adam optimizer (Kingma & Ba, 2014) and use an initial learning rate of $1 0 ^ { - 3 }$ for TSP20 and TSP50 and $\\mathrm { \\dot { 1 } 0 ^ { - 4 } }$ for TSP100 that we decay every 5000 steps by a factor of 0.96. We initialize our parameters uniformly at random within $[ - 0 . 0 8 , 0 . 0 8 ]$ and clip the $L 2$ norm of our gradients to 1.0. We use up to one attention glimpse. When searching, the mini-batches either consist of replications of the test sequence or its permutations. The baseline decay is set to $\\alpha = 0 . 9 9$ in Active Search. Our model and training code in Tensorflow (Abadi et al., 2016) will be made availabe soon. Table 1 summarizes the configurations and different search strategies used in the experiments. The variations of our method, experimental procedure and results are as follows. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            805
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Supervised Learning. In addition to the described baselines, we implement and train a pointer network with supervised learning, similarly to (Vinyals et al., 2015b). While our supervised data consists of one million optimal tours, we find that our supervised learning results are not as good as those reported in by (Vinyals et al., 2015b). We suspect that learning from optimal tours is harder for supervised pointer networks due to subtle features that the model cannot figure out only by looking at given supervised targets. We thus refer to the results in (Vinyals et al., 2015b) for TSP20 and TSP50 and report our results on TSP100, all of which are suboptimal compared to other approaches. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/af2fa01fd572c1a88bbdd009c9b385446e1c0a32da53f8fae2c43d9ac27fcc69.jpg",
+        "table_caption": [
+            "Table 2: Average tour lengths (lower is better). Results marked (†) are from (Vinyals et al., 2015b). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Task</td><td rowspan=\"2\">Supervised Learning</td><td colspan=\"4\">RL pretraining</td><td rowspan=\"2\">AS</td><td rowspan=\"2\">Christo -fides</td><td rowspan=\"2\">OR Tools’ local search</td><td rowspan=\"2\">Optimal</td></tr><tr><td>greedy</td><td>greedy@16</td><td>sampling</td><td>AS</td></tr><tr><td>TSP20</td><td>3.88（）</td><td>3.89</td><td>1</td><td>3.82</td><td>3.82</td><td>3.96</td><td>4.30</td><td>3.85</td><td>3.82</td></tr><tr><td>TSP50</td><td>6.09(t)</td><td>5.95</td><td>5.80</td><td>5.70</td><td>5.70</td><td>5.87</td><td>6.62</td><td>5.80</td><td>5.68</td></tr><tr><td>TSP100</td><td>10.81</td><td>8.30</td><td>7.97</td><td>7.88</td><td>7.83</td><td>8.19</td><td>9.18</td><td>7.99</td><td>7.77</td></tr></table>",
+        "bbox": [
+            173,
+            123,
+            874,
+            194
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "RL pretraining. For the RL experiments, we generate training mini-batches of inputs on the fly and update the model parameters with the Actor Critic Algorithm 1. We use a validation set of 10, 000 randomly generated instances for hyper-parameters tuning. Our critic consists of an encoder network which has the same architecture as that of the policy network, but followed by 3 processing steps and 2 fully connected layers. We find that clipping the logits to $[ - 1 0 , 1 0 ]$ with a tanh(·) activation function, as described in Appendix A.2, helps with exploration and yields marginal performance gains. The simplest search strategy using an RL pretrained model is greedy decoding, i.e. selecting the city with the largest probability at each decoding step. We also experiment with decoding greedily from a set of 16 pretrained models at inference time. For each graph, the tour found by each individual model is collected and the shortest tour is chosen. We refer to those approaches as RL pretraining-greedy and RL pretraining-greedy $@ l 6$ . ",
+        "bbox": [
+            173,
+            220,
+            825,
+            375
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "RL pretraining-Sampling. For each test instance, we sample $1 , 2 8 0 , 0 0 0$ candidate solutions from a pretrained model and keep track of the shortest tour. A grid search over the temperature hyperparameter found respective temperatures of 2.0, 2.2 and 1.5 to yield the best results for TSP20, TSP50 and TSP100. We refer to the tuned temperature hyperparameter as $T ^ { * }$ . Since sampling does not require parameter udpates and is entirely parallelizable, we use a larger batch size for speed purposes. ",
+        "bbox": [
+            173,
+            391,
+            825,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "RL pretraining-Active Search. For each test instance, we initialize the model parameters from a pretrained RL model and run Active Search for up to 10, 000 training steps with a batch size of 128, sampling a total of 1, 280, 000 candidate solutions. We set the learning rate to a hundredth of the initial learning rate the TSP agent was trained on (i.e. $1 0 ^ { - 5 }$ for TSP20/TSP50 and $1 0 ^ { - 6 }$ for TSP100). ",
+        "bbox": [
+            173,
+            492,
+            825,
+            561
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Active Search. We allow the model to train much longer to account for the fact that it starts from scratch. For each test graph, we run Active Search for 100, 000 training steps on TSP20/TSP50 and 200, 000 training steps on TSP100. ",
+        "bbox": [
+            176,
+            579,
+            823,
+            621
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 RESULTS AND ANALYSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            392,
+            654
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare our methods against 3 different baselines of increasing performance and complexity: 1) Christofides, 2) the vehicle routing solver from OR-Tools (Google, 2016) and 3) optimality. Christofides solutions are obtained in polynomial time and guaranteed to be within a 1.5 ratio of optimality. OR-Tools improves over Christofides’ solutions with simple local search operators, including 2-opt (Johnson, 1990) and a version of the Lin-Kernighan heuristic (Lin & Kernighan, 1973), stopping when it reaches a local minimum. In order to escape poor local optima, ORTools’ local search can also be run in conjunction with different metaheuristics, such as simulated annealing (Kirkpatrick et al., 1983), tabu search (Glover & Laguna, 2013) or guided local search (Voudouris & Tsang, 1999). OR-Tools’ vehicle routing solver can tackle a superset of the TSP and operates at a higher level of generality than solvers that are highly specific to the TSP. While not state-of-the art for the TSP, it is a common choice for general routing problems and provides a reasonable baseline between the simplicity of the most basic local search operators and the sophistication of the strongest solvers. Optimal solutions are obtained via Concorde (Applegate et al., 2006) and LK-H’s local search (Helsgaun, 2012; 2000). While only Concorde provably solves instances to optimality, we empirically find that LK-H also achieves optimal solutions on all of our test sets after 50 trials per graph (which is the default parameter setting). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We report the average tour lengths of our approaches on TSP20, TSP50, and TSP100 in Table 2. Notably, results demonstrate that training with RL significantly improves over supervised learning (Vinyals et al., 2015b). All our methods comfortably surpass Christofides’ heuristic, including RL pretraining-Greedy which also does not rely on search. Table 3 compares the running times of our greedy methods to the aforementioned baselines, with our methods running on a single Nvidia Tesla K80 GPU, Concorde and LK-H running on an Intel Xeon CPU E5-1650 v3 3.50GHz CPU and ORTool on an Intel Haswell CPU. We find that both greedy approaches are time-efficient but still quite far from optimality. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5e0e718e7e82a59bdf4503306fb332a1bfe854530eef9dc013259e26b2f65c95.jpg",
+        "table_caption": [
+            "Table 3: Running times in seconds (s) of greedy methods compared to OR Tool’s local search and solvers that find the optimal solutions. Time is measured over the entire test set and averaged. LK-H was run for 50 trials per graph (the default parameter setting). It is likely that optimal solutions were found in fewer trials, resulting in shorter running times. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Task</td><td colspan=\"2\">RL pretraining</td><td rowspan=\"2\">OR-Tools&#x27; local search</td><td colspan=\"2\">Optimal</td></tr><tr><td>greedy</td><td>greedy@16</td><td>Concorde</td><td>LK-H</td></tr><tr><td>TSP50</td><td>0.003s</td><td>0.04s</td><td>0.02s</td><td>0.05s</td><td>0.14s</td></tr><tr><td>TSP100</td><td>0.01s</td><td>0.15s</td><td>0.10s</td><td>0.22s</td><td>0.88s</td></tr></table>",
+        "bbox": [
+            272,
+            160,
+            722,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ff61505a08c7d0de3591b0dd6f5d14192df7def1e4be9dd314b1b7fc1df6a226.jpg",
+        "table_caption": [
+            "Table 4: Average tour lengths of RL pretraining-Sampling and RL pretraining-Active Search as they sample more solutions. Corresponding running times on a single Tesla K80 GPU are in parantheses. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Task</td><td rowspan=\"2\"># Solutions</td><td colspan=\"3\">RL pretraining</td></tr><tr><td>Sampling T =1</td><td>Sampling T =T*</td><td>Active Search</td></tr><tr><td>TSP50</td><td>128 1,280 12,800</td><td>5.80 (3.4s) 5.77 (3.4s) 5.75 (13.8s)</td><td>5.80 (3.4s) 5.75 (3.4s) 5.73 (13.8s)</td><td>5.80 (0.5s) 5.76 (5s) 5.74 (50s)</td></tr><tr><td></td><td>128.000 1,280,000 128</td><td>5.73 (110s) 5.72 (1080s) 8.05 (10.3s) 8.00 (10.3s)</td><td>5.71 (110s) 5.70 (1080s) 8.09 (10.3s) 8.00 (10.3s)</td><td>5.72 (500s) 5.70 (5000s) 8.04 (1.2s)</td></tr><tr><td>TSP100</td><td>1,280 12,800 128,000 1,280,000</td><td>7.95 (31s) 7.92 (265s) 7.89 (2640s)</td><td>7.95 (31s) 7.91 (265s) 7.88 (2640s)</td><td>7.98 (12s) 7.92 (120s) 7.87 (1200s) 7.83 (12000s)</td></tr></table>",
+        "bbox": [
+            240,
+            287,
+            753,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            498,
+            825,
+            583
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Searching at inference time proves crucial to get closer to optimality but comes at the expense of longer running times. Fortunately, the search from RL pretraining-Sampling and RL pretrainingActive Search can be stopped early with a small performance tradeoff in terms of the final objective. This can be seen in Table 4, where we show their performances and corresponding running times as a function of how many solutions they consider. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also find that many of our RL pretraining methods outperform OR-Tools’ local search, including RL pretraining-Greedy $@ 1 6$ which runs similarly fast. Table 6 in Appendix A.3 presents the performance of the metaheuristics as they consider more solutions and the corresponding running times. In our experiments, Neural Combinatorial proves superior than Simulated Annealing but is slightly less competitive that Tabu Search and much less so than Guided Local Search. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            736
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We present a more detailed comparison of our methods in Figure 3, where we sort the ratios to optimality of our different learning configurations. RL pretraining-Sampling and RL pretrainingActive Search are the most competitive Neural Combinatorial Optimization methods and recover the optimal solution in a significant number of our test cases. We find that for small solution spaces, RL pretraining-Sampling, with a finetuned softmax temperature, outperforms RL pretraining-Active Search with the latter sometimes orienting the search towards suboptimal regions of the solution space (see TSP50 results in Table 4 and Figure 3). Furthermore, RL pretraining-Sampling benefits from being fully parallelizable and runs faster than RL pretraining-Active Search. However, for larger solution spaces, RL-pretraining Active Search proves superior both when controlling for the number of sampled solutions or the running time. Interestingly, Active Search - which starts from an untrained model - also produces competitive tours but requires a considerable amount of time (respectively 7 and 25 hours per instance of TSP50/TSP100). Finally, we show randomly picked example tours found by our methods in Figure 4 in Appendix A.4. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/2fbc96e10b80d35ec853e691c0d69a285dbaa6933ef81b6a838aea1d234ce2bc.jpg",
+        "image_caption": [
+            "Figure 3: Sorted tour length ratios to optimality "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            109,
+            799,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 GENERALIZATION TO OTHER PROBLEMS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            343,
+            540,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss how to apply Neural Combinatorial Optimization to other problems than the TSP. In Neural Combinatorial Optimization, the model architecture is tied to the given combinatorial optimization problem. Examples of useful networks include the pointer network, when the output is a permutation or a truncated permutation or a subset of the input, and the classical seq2seq model for other kinds of structured outputs. For combinatorial problems that require to assign labels to elements of the input, such as graph coloring, it is also possible to combine a pointer module and a softmax module to simultaneously point and assign at decoding time. Given a model that encodes an instance of a given combinatorial optimization task and repeatedly branches into subtrees to construct a solution, the training procedures described in Section 4 can then be applied by adapting the reward function depending on the optimization problem being considered. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            518
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Additionally, one also needs to ensure the feasibility of the obtained solutions. For certain combinatorial problems, it is straightforward to know exactly which branches do not lead to any feasible solutions at decoding time. We can then simply manually assign them a zero probability when decoding, similarly to how we enforce our model to not point at the same city twice in our pointing mechanism (see Appendix A.1). However, for many combinatorial problems, coming up with a feasible solution can be a challenge in itself. Consider, for example, the Travelling Salesman Problem with Time Windows, where the travelling salesman has the additional constraint of visiting each city during a specific time window. It might be that most branches being considered early in the tour do not lead to any solution that respects all time windows. In such cases, knowing exactly which branches are feasible requires searching their subtrees, a time-consuming process that is not much easier than directly searching for the optimal solution unless using problem-specific heuristics. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rather than explicitly constraining the model to only sample feasible solutions, one can also let the model learn to respect the problem’s constraints. A simple approach, to be verified experimentally in future work, consists in augmenting the objective function with a term that penalizes solutions for violating the problem’s constraints, similarly to penalty methods in constrained optimization. While this does not guarantee that the model consistently samples feasible solutions at inference time, this is not necessarily problematic as we can simply ignore infeasible solutions and resample from the model (for RL pretraining-Sampling and RL-pretraining Active Search). It is also conceivable to combine both approaches by assigning zero probabilities to branches that are easily identifiable as infeasible while still penalizing infeasible solutions once they are entirely constructed. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            810
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6.1 KNAPSACK EXAMPLE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            838,
+            364,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As an example of the flexibility of Neural Combinatorial Optimization, we consider the KnapSack problem, another intensively studied problem in computer science. Given a set of $n$ items $i = 1 . . . n$ each with weight $w _ { i }$ and value $v _ { i }$ and a maximum weight capacity of $W$ , the 0-1 KnapSack problem consists in maximizing the sum of the values of items present in the knapsack so that the sum of the weights is less than or equal to the knapsack capacity: ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            526,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/23d7393b27091ee155cff5b6b1cce4f16b2625bbc1fb64fd5340734b376511b1.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { S \\subseteq \\{ 1 , 2 , \\ldots , n \\} } { \\mathrm { m a x } } } & { \\displaystyle \\sum _ { i \\in S } v _ { i } } \\\\ { \\mathrm { s u b j e c t ~ t o } } & { \\displaystyle \\sum _ { i \\in S } w _ { i } \\leq W } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            125,
+            591,
+            195
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "With $w _ { i }$ , $v _ { i }$ and $W$ taking real values, the problem is NP-hard (Kellerer et al., 2004). A naive heuristic is to take the items ordered by their weight-to-value ratios until they fill up the weight capacity. Two simple heuristics are ExpKnap, which employs branch-and-bound with Linear Programming bounds (Pisinger, 1995), and MinKnap, which uses dynamic programming with enumerative bounds (Pisinger, 1997). Exact solutions can also be obtained by quantizing the weights to high precisions and then performing dynamic programming with pseudo-polynomial complexity (Bertsimas & Demir, 2002). ",
+        "bbox": [
+            173,
+            202,
+            825,
+            300
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We apply the pointer network and encode each KnapSack instance as a sequence of 2D vectors $( w _ { i } , v _ { i } )$ . At decoding time, the pointer network points to items to include in the knapsack and stops when the total weight of the items collected so far exceeds the weight capacity. We generate three datasets, KNAP50, KNAP100 and KNAP200, of a thousand instances with items’ weights and values drawn uniformly at random in [0, 1]. Without loss of generality (since we can scale the items’ weights), we set the capacities to 12.5 for KNAP50 and 25 for KNAP100 and KNAP200. We present the performances of RL pretraining-Greedy and Active Search (which we run for 5, 000 training steps) in Table 5 and compare them to the following baselines: 1) random search (which we let sample as many feasible solutions seen by Active Search), 2) the greedy value-to-weight ratio heuristic, 3) MinKnap, 4) ExpKnap, 5) OR-Tools’ KnapSack solver (Google, 2016) and 6) optimality (which we obtained by quantizing the weights to high precisions and using dynamic programming). ",
+        "bbox": [
+            173,
+            306,
+            825,
+            474
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/cf3061e9b278f018278ac77437dc5d2bae658bb14b0b58d60e83cdec6ea04090.jpg",
+        "table_caption": [
+            "Table 5: Results of RL pretraining-Greedy and Active Search on KnapSack (higher is better). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>RL pretraining greedy</td><td>Active Search</td><td>Random Search</td><td>Greedy</td><td>MinKnap / ExpKnap /OR-Tools</td><td>Optimal</td></tr><tr><td>KNAP50</td><td>19.86</td><td>20.07</td><td>17.91</td><td>19.24</td><td>20.07</td><td>20.07</td></tr><tr><td>KNAP100</td><td>40.27</td><td>40.50</td><td>33.23</td><td>38.53</td><td>40.50</td><td>40.50</td></tr><tr><td>KNAP200</td><td>57.10</td><td>57.45</td><td>35.95</td><td>55.42</td><td>57.45</td><td>57.45</td></tr></table>",
+        "bbox": [
+            174,
+            511,
+            864,
+            580
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            609,
+            318,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This paper presents Neural Combinatorial Optimization, a framework to tackle combinatorial optimization with reinforcement learning and neural networks. We focus on the traveling salesman problem (TSP) and present a set of results for each variation of the framework. Experiments demonstrate that Neural Combinatorial Optimization achieves close to optimal results on 2D Euclidean graphs with up to 100 nodes. Our results, while still far from the strongest solvers (especially those which are optimized for one problem), provide an interesting research avenue for using neural networks as a general tool for tackling combinatorial optimization problems. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            762,
+            356,
+            776
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank Vincent Furnon, Mustafa Ispir, Lukasz Kaiser, Oriol Vinyals, Barret Zoph, the Google Brain team and the anonymous ICLR reviewers for insightful comments and discussion. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            285,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for largescale machine learning. arXiv preprint arXiv:1605.08695, 2016. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sreeram V. B. Aiyer, Mahesan Niranjan, and Frank Fallside. A theoretical investigation into the performance of the Hopfield model. IEEE Transactions on Neural Networks, 1(2):204–215, 1990. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bernard Angeniol, Gael De La Croix Vaubois, and Jean-Yves Le Texier. Self-organizing feature maps and the Travelling Salesman Problem. Neural Networks, 1(4):289–293, 1988. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Applegate, Robert Bixby, Vasek Chv ˇ atal, and William Cook. Implementing the dantzig- ´ fulkerson-johnson algorithm for large traveling salesman problems. Mathematical programming, 2003. ",
+        "bbox": [
+            176,
+            179,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David L Applegate, Robert E Bixby, Vasek Chvatal, and William J Cook. Concorde tsp solver, 2006. URL www.math.uwaterloo.ca/tsp/concorde. ",
+        "bbox": [
+            171,
+            229,
+            823,
+            261
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David L Applegate, Robert E Bixby, Vasek Chvatal, and William J Cook. The traveling salesman problem: a computational study. Princeton university press, 2011. ",
+        "bbox": [
+            174,
+            268,
+            823,
+            297
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015. ",
+        "bbox": [
+            174,
+            306,
+            820,
+            337
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dimitris Bertsimas and Ramazan Demir. An approximate dynamic programming approach to multidimensional knapsack problems. Management Science, 48(4):550–565, 2002. ",
+        "bbox": [
+            174,
+            343,
+            820,
+            375
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Edmund Burke, Graham Kendall, Jim Newall, Emma Hart, Peter Ross, and Sonia Schulenburg. Hyperheuristics: An emerging direction in modern search technology. Springer, 2003. ",
+        "bbox": [
+            174,
+            381,
+            821,
+            411
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Edmund K. Burke, Michel Gendreau, Matthew R. Hyde, Graham Kendall, Gabriela Ochoa, Ender zcan, and Rong Qu. Hyper-heuristics: a survey of the state of the art. JORS, 64(12):1695–1724, 2013. ",
+        "bbox": [
+            173,
+            419,
+            825,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Laura I. Burke. Neural methods for the Traveling Salesman Problem: insights from operations research. Neural Networks, 7(4):681–690, 1994. ",
+        "bbox": [
+            173,
+            472,
+            823,
+            501
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho. Noisy parallel approximate decoding for conditional recurrent language model. arXiv preprint arXiv:1605.03835, 2016. ",
+        "bbox": [
+            173,
+            508,
+            821,
+            540
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicos Christofides. Worst-case analysis of a new heuristic for the Travelling Salesman Problem. In Report 388. Graduate School of Industrial Administration, CMU, 1976. ",
+        "bbox": [
+            173,
+            547,
+            823,
+            577
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George Dantzig, Ray Fulkerson, and Selmer Johnson. Solution of a large-scale traveling-salesman problem. Journal of the operations research society of America, 1954. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            614
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Durbin. An analogue approach to the Travelling Salesman. Nature, 326:16, 1987. ",
+        "bbox": [
+            171,
+            622,
+            766,
+            638
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Favio Favata and Richard Walker. A study of the application of Kohonen-type neural networks to the travelling salesman problem. Biological Cybernetics, 64(6):463–468, 1991. ",
+        "bbox": [
+            174,
+            647,
+            823,
+            678
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. C. Fort. Solving a combinatorial problem via self-organizing process: an application of the Kohonen algorithm to the traveling salesman problem. Biological Cybernetics, 59(1):33–40, 1988. ",
+        "bbox": [
+            173,
+            684,
+            823,
+            715
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew Howard Gee. Problem solving with optimization networks. PhD thesis, Citeseer, 1993. ",
+        "bbox": [
+            173,
+            723,
+            797,
+            739
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Fred Glover and Manuel Laguna. Tabu Search. Springer, 2013. ",
+        "bbox": [
+            173,
+            747,
+            591,
+            763
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Google. Or-tools, google optimization tools, 2016. URL https://developers.google. com/optimization. ",
+        "bbox": [
+            171,
+            771,
+            821,
+            800
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Keld Helsgaun. An effective implementation of the Lin-Kernighan traveling salesman. European Journal of Operational Research, 126:106–130, 2000. ",
+        "bbox": [
+            173,
+            809,
+            821,
+            838
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Keld Helsgaun. LK-H, 2012. URL http://akira.ruc.dk/˜keld/research/LKH/. ",
+        "bbox": [
+            171,
+            847,
+            795,
+            863
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. Neural Computations, 1997. ",
+        "bbox": [
+            173,
+            871,
+            816,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John J. Hopfield and David W. Tank. ”Neural” computation of decisions in optimization problems. Biological Cybernetics, 52(3):141–152, 1985. ",
+        "bbox": [
+            171,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "DS Johnson. Local search and the traveling salesman problem. In Proceedings of 17th International Colloquium on Automata Languages and Programming, Lecture Notes in Computer Science,(Springer-Verlag, Berlin, 1990), pp. 443–460, 1990. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hans Kellerer, Ulrich Pferschy, and David Pisinger. Knapsack Problems. Springer-Verlag Berlin Heidelberg, 2004. ",
+        "bbox": [
+            174,
+            155,
+            820,
+            185
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2014. ",
+        "bbox": [
+            173,
+            195,
+            797,
+            210
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "S. Kirkpatrick, C. D. Gelatt, and M. P. Vecchi. Optimization by simulated annealing. SCIENCE, 220, 1983. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            250
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Teuvo Kohonen. The self-organizing map. Proceedings of the IEEE, 78(9):1464–1480, 1990. ",
+        "bbox": [
+            173,
+            258,
+            789,
+            275
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Bert F. J. La Maire and Valeri M. Mladenov. Comparison of neural networks for solving the Travelling Salesman Problem. In NEUREL, pp. 21–24. IEEE, 2012. ",
+        "bbox": [
+            171,
+            284,
+            820,
+            313
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "S. Lin and B. W. Kernighan. An effective heuristic algorithm for the traveling-salesman problem. Operations Research, 21(2):498–516, 1973. ",
+        "bbox": [
+            174,
+            321,
+            821,
+            352
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adri Puigdomnech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. arXiv preprint arXiv:1605.03835, 2016. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            405
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Manfred Padberg and Giovanni Rinaldi. A branch-and-cut algorithm for the resolution of largescale symmetric traveling salesman problems. Society for Industrial and Applied Mathematics, 33:60–100, 1990. ",
+        "bbox": [
+            173,
+            415,
+            823,
+            457
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christos H. Papadimitriou. The Euclidean Travelling Salesman Problem is NP-complete. Theoretical Computer Science, 4(3):237–244, 1977. ",
+        "bbox": [
+            171,
+            467,
+            823,
+            496
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Pisinger. An expanding-core algorithm for the exact 0-1 knapsack problem european journal of operational research. European Journal of Operational Research, pp. 175–187, 1995. ",
+        "bbox": [
+            174,
+            506,
+            821,
+            536
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Pisinger. A minimal algorithm for the 0-1 knapsack problem. Operations Research, pp. 758–767, 1997. ",
+        "bbox": [
+            174,
+            545,
+            821,
+            574
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Farah Sarwar and Abdul Aziz Bhatti. Critical analysis of Hopfield’s neural network model for TSP and its comparison with heuristic algorithm for shortest path computation. In IBCAST, 2012. ",
+        "bbox": [
+            173,
+            583,
+            821,
+            613
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kate A. Smith. Neural networks for combinatorial optimization: a review of more than a decade of research. INFORMS Journal on Computing, 1999. ",
+        "bbox": [
+            174,
+            622,
+            823,
+            652
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, pp. 3104–3112, 2014. ",
+        "bbox": [
+            173,
+            661,
+            821,
+            691
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Andrew I. Vakhutinsky and Bruce L. Golden. A hierarchical strategy for solving traveling salesman problems using elastic nets. Journal of Heuristics, 1(1):67–76, 1995. ",
+        "bbox": [
+            171,
+            700,
+            825,
+            731
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: Sequence to sequence for sets. arXiv preprint arXiv:1511.06391, 2015a. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            768
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015b. ",
+        "bbox": [
+            171,
+            779,
+            823,
+            808
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christos Voudouris and Edward Tsang. Guided local search and its application to the traveling salesman problem. European journal of operational research, 1999. ",
+        "bbox": [
+            169,
+            818,
+            825,
+            847
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ronald Williams. Simple statistical gradient following algorithms for connectionnist reinforcement learning. In Machine Learning, 1992. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "G. V. Wilson and G. S. Pawley. On the stability of the travelling salesman problem algorithm of hopfield and tank. Biological Cybernetics, 58(1):63–70, 1988. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D. H. Wolpert and W. G. Macready. No free lunch theorems for optimization. Transactions on Evolutionary Computation, 1(1):67–82, April 1997. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Chen Yutian, Hoffman Matthew W., Colmenarejo Sergio Gomez, Denil Misha, Lillicrap Timothy P., and de Freitas Nando. Learning to learn for global optimization of black box functions. arXiv preprint arXiv:1611.03824, 2016. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016. ",
+        "bbox": [
+            169,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            303,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.1 POINTING AND ATTENDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            411,
+            151
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Pointing mechanism: Its computations are parameterized by two attention matrices $W _ { r e f } , W _ { q } \\in$ $\\mathbb { R } ^ { d \\times d }$ and an attention vector $v \\in \\mathbb { R } ^ { d }$ as follows: ",
+        "bbox": [
+            169,
+            164,
+            823,
+            195
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2b6296ac28ea99bb267783e5e9e17885c18987f01f10cc798db4a76a44bacfe.jpg",
+        "text": "$$\n\\begin{array} { r l } & { { u _ { i } } = \\left\\{ \\begin{array} { l l } { { v ^ { \\top } } \\cdot \\operatorname { t a n h } \\left( { W _ { r e f } } \\cdot { r _ { i } } + { W _ { q } } \\cdot q \\right) } & { \\mathrm { i f ~ } i \\ne \\pi ( j ) \\mathrm { ~ f o r ~ a l l ~ } j < i } \\\\ { - \\infty } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. \\mathrm { f o r ~ } i = 1 , 2 , . . . , k } \\\\ & { A ( r e f , q ; W _ { r e f } , W _ { q } , v ) \\stackrel { \\mathrm { d e f } } { = } s o f t m a x ( u ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            204,
+            769,
+            266
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Our pointer network, at decoder step $j$ , then assigns the probability of visiting the next point $\\pi ( j )$ of the tour as follows: ",
+        "bbox": [
+            173,
+            281,
+            825,
+            310
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca5bd13a0803f24f198a79caaa652866bd17db38030798214ec99b17db09d680.jpg",
+        "text": "$$\np ( \\pi ( j ) | \\pi ( < j ) , s ) \\stackrel { \\mathrm { d e f } } { = } A ( e n c _ { 1 : n } , d e c _ { j } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            319,
+            627,
+            340
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Setting the logits of cities that already appeared in the tour to $- \\infty$ , as shown in Equation 8, ensures that our model only points at cities that have yet to be visited and hence outputs valid TSP tours. ",
+        "bbox": [
+            174,
+            358,
+            823,
+            388
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Attending mechanism: Specifically, our glimpse function $G ( r e f , q )$ takes the same inputs as the attention function $A$ and is parameterized by $\\bar { W } _ { r e f } ^ { g } , W _ { q } ^ { g } \\in \\mathbb { R } ^ { \\bar { d } \\times \\bar { d } }$ and $v ^ { g } \\in \\mathbb { R } ^ { d }$ . It performs the following computations: ",
+        "bbox": [
+            173,
+            406,
+            825,
+            452
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d6dca37cca6820bc647f5771e3f0ad3751fa84ad71d83c9aff938ed88c52a18.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle p = A ( r e f , q ; W _ { r e f } ^ { g } , W _ { q } ^ { g } , v ^ { g } ) } } \\\\ { { \\displaystyle G ( r e f , q ; W _ { r e f } ^ { g } , W _ { q } ^ { g } , v ^ { g } ) \\stackrel { \\mathrm { d e f } } { = } \\sum _ { i = 1 } ^ { k } r _ { i } p _ { i } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            462,
+            622,
+            527
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The glimpse function $G$ essentially computes a linear combination of the reference vectors weighted by the attention probabilities. It can also be applied multiple times on the same reference set $r e f$ : ",
+        "bbox": [
+            173,
+            545,
+            825,
+            574
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/218c3b8009449f694385808afec6a4c96876e46efeaab4c91f13710b92fb8cf6.jpg",
+        "text": "$$\n\\begin{array} { l } { g _ { 0 } \\stackrel { \\mathrm { d e f } } { = } q } \\\\ { g _ { l } \\stackrel { \\mathrm { d e f } } { = } G ( r e f , g _ { l - 1 } ; W _ { r e f } ^ { g } , W _ { q } ^ { g } , v ^ { g } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            584,
+            612,
+            632
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Finally, the ultimate $g _ { l }$ vector is passed to the attention function $A ( r e f , g _ { l } ; W _ { r e f } , W _ { q } , v )$ to produce the probabilities of the pointing mechanism. We observed empirically that glimpsing more than once with the same parameters made the model less likely to learn and barely improved the results. ",
+        "bbox": [
+            173,
+            650,
+            826,
+            693
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.2 IMPROVING EXPLORATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            715,
+            403,
+            729
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Softmax temperature: We modify Equation 9 as follows: ",
+        "bbox": [
+            173,
+            742,
+            575,
+            758
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe656ccaa3e16b61910ec5a51766e4e0e5a2d236ad6f4e80f1353f60e72fb813.jpg",
+        "text": "$$\nA ( r e f , q , T ; W _ { r e f } , W _ { q } , v ) \\stackrel { \\mathrm { d e f } } { = } s o f t m a x ( u / T ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            768,
+            651,
+            790
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $T$ is a temperature hyperparameter set to $T = 1$ during training. When $T > 1$ , the distribution represented by $A ( r e f , q )$ becomes less steep, hence preventing the model from being overconfident. ",
+        "bbox": [
+            171,
+            800,
+            825,
+            830
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Logit clipping: We modify Equation 9 as follows: ",
+        "bbox": [
+            173,
+            849,
+            522,
+            866
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a65b3d65a952727e9e65dac6da16023d1b3454f0caafce553165304cf148c954.jpg",
+        "text": "$$\nA ( r e f , q ; W _ { r e f } , W _ { q } , v ) \\stackrel { \\mathrm { d e f } } { = } s o f t m a x ( C \\operatorname { t a n h } ( u ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            877,
+            663,
+            898
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $C$ is a hyperparameter that controls the range of the logits and hence the entropy of $A ( r e f , q )$ ",
+        "bbox": [
+            173,
+            909,
+            820,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3 OR TOOL’S METAHEURISTICS BASELINES FOR TSP",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            578,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/eddf5d599b3a0aa5c367a6aa9feb14aa3dfef36be388b2e38b6f99e1c3b9135f.jpg",
+        "table_caption": [
+            "Table 6: Performance of OR-Tools’ metaheuristics as they consider more solutions. Corresponding running times in seconds (s) on a single Intel Haswell CPU are in parantheses. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>#Solutions</td><td rowspan=1 colspan=1>Simulated Annealing</td><td rowspan=1 colspan=1>Tabu Search</td><td rowspan=1 colspan=1>Guided Local Search</td></tr><tr><td rowspan=4 colspan=1>TSP50</td><td rowspan=4 colspan=1>11281,28012,800128.0001,280,000</td><td rowspan=2 colspan=1>6.62 (0.03s)5.81 (0.24s)</td><td rowspan=1 colspan=1>6.62 (0.03s)</td><td rowspan=4 colspan=1>6.62 (0.03s)5.76 (0.5s)5.69 (5s)5.68 (48s)5.68 (450s)5.68 (4530s)</td></tr><tr><td rowspan=1 colspan=1>5.79 (3.4s)</td></tr><tr><td rowspan=2 colspan=1>5.81 (4.2s)5.81 (44s)5.81 (460s)5.81 (3960s)</td><td rowspan=1 colspan=1>5.73 (36s)5.69 (330s)</td></tr><tr><td rowspan=1 colspan=1>5.68 (3200s)5.68 (29650s)</td></tr><tr><td rowspan=2 colspan=1>TSP100</td><td rowspan=2 colspan=1>11281,28012,800128.0001,280,000</td><td rowspan=2 colspan=1>9.18 (0.07s)8.00 (0.67s)7.99 (15.7s)7.99 (166s)7.99 (1650s)7.99 (15810s)</td><td rowspan=1 colspan=1>9.18 (0.07s)7.99 (15.3s)</td><td rowspan=2 colspan=1>9.18 (0.07s)7.94 (1.44s)7.84 (18.4s)7.77 (182s)7.77 (1740s)7.77 (16150s)</td></tr><tr><td rowspan=1 colspan=1>7.93 (255s)7.84 (2460s)7.79 (22740s)7.78 (208230s)</td></tr></table>",
+        "bbox": [
+            222,
+            167,
+            772,
+            343
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.4 SAMPLE TOURS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            367,
+            331,
+            381
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf80da1b4bfc812d8683181d0df5aa70e02d9a19ab9a78d326884784f5fcf757.jpg",
+        "image_caption": [
+            "Figure 4: Sample tours. Top: TSP50; Bottom: TSP100. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            406,
+            781,
+            632
+        ],
+        "page_idx": 15
+    }
+]

parse/train/rkaT3zWCZ/rkaT3zWCZ.md

@@ -0,0 +1,339 @@
+# BUILDING GENERALIZABLE AGENTS WITH A REALISTIC AND RICH 3D ENVIRONMENT
+
+Yi Wu   
+UC Berkeley   
+jxwuyi@gmail.com
+
+Yuxin Wu & Georgia Gkioxari & Yuandong Tian Facebook AI Research {yuxinwu,gkioxari,yuandong}@fb.com
+
+# ABSTRACT
+
+Teaching an agent to navigate in an unseen 3D environment is a challenging task, even in the event of simulated environments. To generalize to unseen environments, an agent needs to be robust to low-level variations (e.g. color, texture, object changes), and also high-level variations (e.g. layout changes of the environment). To improve overall generalization, all types of variations in the environment have to be taken under consideration via different level of data augmentation steps. To this end, we propose House3D, a rich, extensible and efficient environment that contains 45,622 human-designed 3D scenes of visually realistic houses, ranging from single-room studios to multi-storied houses, equipped with a diverse set of fully labeled 3D objects, textures and scene layouts, based on the SUNCG dataset (Song et al., 2017). The diversity in House3D opens the door towards scene-level augmentation, while the label-rich nature of House3D enables us to inject pixel- & task-level augmentations such as domain randomization (Tobin et al., 2017) and multi-task training. Using a subset of houses in House3D, we show that reinforcement learning agents trained with an enhancement of different levels of augmentations perform much better in unseen environments than our baselines with raw RGB input by over $8 \%$ in terms of navigation success rate. House3D is publicly available at http://github.com/facebookresearch/House3D.
+
+# 1 INTRODUCTION
+
+Recently, deep reinforcement learning has shown its strength on multiple games, such as Atari (Mnih et al., 2015) and Go (Silver et al., 2016), vastly overpowering human performance. Via the various reinforcement learning frameworks, different aspects of intelligence can be learned, including 3D understanding (DeepMind Lab (Beattie et al., 2016) and Malmo (Johnson et al., 2016)), real-time strategy decision (TorchCraft (Synnaeve et al., 2016) and ELF (Tian et al., 2017)), fast reaction (Atari (Bellemare et al., 2013)), long-term planning (Go, Chess), language and communications (ParlAI (Miller et al., 2017) and (Das et al., 2017b)).
+
+A prominent issue in reinforcement learning is generalizability. Commonly, agents trained on a specific environment and for a specific task become highly specialized and fail to perform well on new environments. In the past, there have been efforts to address this issue. In particular, pixellevel variations are applied to the observation signals in order to increase the agent’s robustness to unseen environments (Beattie et al., 2016; Higgins et al., 2017; Tobin et al., 2017). Parametrized environments with varying levels of difficulty are used to yield scene variations but with similar visual observations (Pathak et al., 2017). Transfer learning is applied to similar tasks but with different rewards (Finn et al., 2017b).
+
+Nevertheless, the aforementioned techniques study the problem in simplified environments which lack the diversity, richness and perception challenges of the real world. To this end, we propose a substantially more diverse environment, House3D, to train and test our agents. House3D is a virtual 3D environment consisting of thousands of indoor scenes equipped with a diverse set of scene types, layouts and objects. An overview of House3D is shown in Figure 1a. House3D leverages the SUNCG dataset (Song et al., 2017) which contains 45K human-designed real-world 3D house models, ranging from single studios to houses with gardens, in which objects are fully labeled with categories. We convert the SUNCG dataset to an environment, House3D, which is efficient and extensible for various tasks. In House3D, an agent can freely explore the space while perceiving a large number of objects under various visual appearances.
+
+![](images/82f8173d69c81105594cb3383044abb3a1c9c9a6d48e0e296a2d2e76cd8ff85f.jpg)  
+Figure 1: An overview of House3D environment and RoomNav task. (a) We build an efficient and interactive environment upon the SUNCG dataset (Song et al., 2017) that contains 45K diverse indoor scenes, ranging from studios to two-storied houses with swimming pools and fitness rooms. All 3D objects are fully labeled into over 80 categories. Observations of agents in the environment have multiple modalities, including RGB images, Depth, Segmentation masks (from object category), top-down 2D view, etc. (b) We focus on the task of targeted navigation. Given a high-level description of a room concept, the agent explores the environment to reach the target room.
+
+Based on House3D, we design a task called RoomNav: an agent starts at a random location in a house and is asked to navigate to a destination specified by a high-level semantic concept (e.g. kitchen), following simple rules (e.g. no object penetration), as shown in Figure 1b. We use gated-CNN and gated-LSTM policies trained with standard deep reinforcement learning methods, i.e. A3C (Mnih et al., 2016) and DDPG (Lillicrap et al., 2015), and report success rate on unseen environments over 5 concepts. We show that in order to achieve strong generalization capability, all-levels of augmentations are needed: pixel-level augmentation by domain randomization (Tobin et al., 2017) enhances the agent’s robustness to color variations; object-level augmentation forces the agent to learn multiple concepts (20 in number) simultaneously, and scene-level augmentation, where a diverse set of environments is used, enforce generalizability across diverse scenes, mitigating overfitting to particular scenes. Our final gated-LSTM agent achieves a success rate of $3 5 . { \bar { 8 } } \%$ on 50 unseen environments, $10 \%$ better than the baseline method $( 2 5 . 7 \% )$ .
+
+The remaining of the paper is structured as follows. Section 2 summarizes relevant work. Section 3 describes our environment, House3D, in detail and section 4 describes the task, RoomNav. Section 5 describes our gated models and the applied algorithms to tackle RoomNav. Finally, experimental results are shown in Section 6.
+
+# 2 RELATED WORK
+
+Environments: Table 1 shows the comparison between House3D and most relevant prior works. There are other simulated environments which focus on different domains, such as OpenAI Gym (Brockman et al., 2016), ParlAI (Miller et al., 2017) for language communication as well as some strategic game environments (Synnaeve et al., 2016; Tian et al., 2017; Vinyals et al., 2017), etc. Most of these environments are pertinent to one particular aspect of intelligence, such as dialogue or a single type of game, which makes it hard to facilitate the study of more comprehensive problems. On the contrary, we focus on building a platform that intersects with multiple research directions, such as object and scene understanding, 3D navigation, embodied question answering (Das et al., 2017a), while allowing users to customize the level of complexity to their needs.
+
+Table 1: A summary of popular environments. The attributes include 3D: 3D nature of the rendered objects, Realistic: resemblance to the real-world, Large-scale: a large set of environments, Fast: fast rendering speed and Customizable: flexibility to be customized to other applications.   
+
+<table><tr><td rowspan=1 colspan=1>Environment</td><td rowspan=1 colspan=1>3D</td><td rowspan=1 colspan=1>Realistic</td><td rowspan=1 colspan=1>Large-scale</td><td rowspan=1 colspan=1>Fast</td><td rowspan=1 colspan=1>Customizable</td></tr><tr><td rowspan=1 colspan=1>Atari (Bellemare et al., 2013)</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>OpenAI Universe (Shi 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></tr><tr><td rowspan=1 colspan=1>Malmo (Johnson 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></tr><tr><td rowspan=1 colspan=1>DeepMind Lab (Beattie 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></tr><tr><td rowspan=1 colspan=1>VizDoom (Kempka 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></tr><tr><td rowspan=1 colspan=1>AI2-THOR (Zhu 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></tr><tr><td rowspan=1 colspan=1>Stanford2D-3D (Armeni 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></tr><tr><td rowspan=1 colspan=1>Matterport3D (Chang 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></tr><tr><td rowspan=1 colspan=1>House3D</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>
+
+We build on SUNCG (Song et al., 2017), a dataset that consists of thousands of diverse synthetic indoor scenes equipped with a variety of objects and layouts. Its visual diversity and rich content opens the path to the study of semantic generalization for reinforcement learning agents. Our platform decouples high-performance rendering from data I/O, and thus can use other publicly available 3D scene datasets as well. This includes Al2-THOR (Zhu et al., 2017), SceneNet RGB-D (McCormac et al., 2017), Stanford 3D (Armeni et al., 2016), Matterport 3D (Chang et al., 2017) and so on.
+
+Concurrent works (Brodeur et al., 2017; Savva et al., 2017) also introduce similar platforms as House3D, indicating the interest for large-scale interactive and realistic 3D environments.
+
+3D Navigation: There has been a prominent line of work on the task of navigation in real 3D scenes (Leonard & Durrant-Whyte, 1992). Classical approaches decompose the task into two subtasks by building a 3D map of the scene using SLAM and then planning in this map (Fox et al., 2005). More recently, end-to-end learning methods were introduced to predict robotic actions from raw pixel data (Levine et al., 2016). Some of the most recent works on navigation show the effectiveness of end-to-end learning. Gupta et al. (2017) learn to navigate via mapping and planning using shortest path supervision. Sadeghi & Levine (2017) teach an agent to fly using solely simulated data and deploy it in the real world. Dhiraj et al. (2017) collect a dataset of drones crashing into objects and train self-supervised agents on this data to avoid obstacles.
+
+A number of recent works also use deep reinforcement learning for navigation in simulated 3D scenes. Mirowski et al. (2016); Jaderberg et al. (2016) improve an agent’s navigation ability in mazes by introducing auxiliary tasks. Parisotto & Salakhutdinov (2017) propose a new architecture which stores information of the environment on a 2D map. Karl Moritz Hermann & PhilBlunsom (2017) focus on the task of language grounding by navigating simple 3D scenes. However, these works only evaluate the agent’s generalization ability on pixel-level variations or small mazes. We argue that a much richer environment is crucial for evaluating semantic-level generalization.
+
+Gated Modules: In our work, we focus on the task of RoomNav, where the goal is communicated to the agent as a high-level instruction selected from a set of predefined concepts. To modulate the behavior of the agent in RoomNav, we encode the instruction as an embedding vector which gates the visual signal. The idea of gated attention has been used in the past for language grounding (Chaplot et al., 2017), and transfer learning by language grounding (Narasimhan et al., 2017). Similar to those works, we use concept grounding as an attention mechanism. We believe that our gated reinforcement learning models serve as a strong baseline for the task of semantic based navigation in House3D. Furthermore, our empirical results allow us to draw conclusions on the models’ efficacy when training agents in a large-scale, diverse dataset with an emphasis on generalization.
+
+Generalization: There is a recent trend in reinforcement learning focusing on the problem of generalization, ranging from learning to plan (Tamar et al., 2016), meta-learning (Duan et al., 2016; Finn et al., 2017a) to zero-shot learning (Andreas et al., 2016; Oh et al., 2017; Higgins et al., 2017).
+
+However, these works either focus on over-simplified tasks or test on environments which are only slightly varied from the training ones. In contrast, we use a more diverse set of environments, each containing visually and structurally different observations, and show that the agent can work well in unseen scenes.
+
+In this work, we show improved generalization performance in complex 3D scenes when using depth and segmentation masks on top of the raw visual input. This observation is similar to other works which use a diverse set of input modalities (Mirowski et al., 2016; Tai & Liu, 2016). Our result suggests that it can be possible to decouple real-world robotics from recognition via a vision API provided by an object detection or semantic segmentation system trained on the targeted real scenes. This opens the door towards bridging the gap between simulated environment and real-world (Tobin et al., 2017; Rusu et al., 2016; Christiano et al., 2016).
+
+# 3 HOUSE3D: AN EXTENSIBLE ENVIRONMENT OF 45K 3D HOUSES
+
+We propose House3D, an environment which closely resembles the real world and is rich in content and structure. An overview of House3D is shown in Figure 1a. House3D is developed to provide an efficient and flexible environment of thousands of indoor scenes and facilitates a variety of tasks, e.g. navigation, visual understanding, language grounding, concept learning etc. The environment along with a python API for easy use is available at http://github.com/facebookresearch/ House3D.
+
+# 3.1 DATASET
+
+The 3D scenes in House3D are sourced from the SUNCG dataset (Song et al., 2017), which consists of 45,622 human-designed 3D scenes ranging from single-room studios to multi-floor houses. The SUNCG dataset was designed to encourage research on large-scale 3D object recognition problems and thus carries a variety of objects, scene layouts and structures. On average, there are 8.9 rooms and 1.3 floors per scene There is a diverse set of room and object types in each scene. In total, there are over 20 different room types, such as bedroom, living room, kitchen, bathroom etc., with over 80 different object categories. In total, the SUNCG dataset contains 404,508 different rooms and 5,697,217 object instances drawn from 2644 unique object meshes.
+
+# 3.2 ANNOTATIONS
+
+Each scene in SUNCG is fully annotated with 3D coordinates and its room and object types (e.g. bedroom, shoe cabinet, etc). This allows for a detailed mapping from each 3D location to an object instance (or None at free space) and the room type.
+
+At every time step an agent has access to the following signals: a) the visual RGB signal of its current first person view, b) semantic/instance segmentation masks for all the objects visible in its current view, and c) depth information. For different tasks, these signals might serve for different purposes, e.g., as a feature plane or an auxiliary target. Based on the existing annotations, House3D offers more information, e.g., top-down 2D occupancy maps, connectivity analysis and shortest paths between two points.
+
+# 3.3 RENDERER
+
+To build a realistic 3D environment, we develop a renderer for the SUNCG scenes. The renderer is based on OpenGL, it can run on both Linux and MacOS, and provides RGB images, semantic segmentation masks, instance segmentation masks and depth maps.
+
+As highlighted above, the environment needs to be efficient in order to be used for large-scale reinforcement learning. On a NVIDIA Tesla M40 GPU, our implementation can render $1 2 0 \times 9 0$ -sized frames at over 600 fps, while multiple renderers can run in parallel on one or more GPUs. When rendering multiple houses simultaneously, one M40 GPU can be fully utilized to render at a total of 1800 fps. The default simple physics adds a small overhead to the rendering. The high throughput of our implementation enables efficient learning for a variety of interactive tasks, such as on-policy reinforcement learning.
+
+# 3.4 INTERACTION
+
+In House3D, an agent can live in any location within a 3D scene, as long as it does not collide with object instances (including walls) within a small range, i.e. robot’s radius. Doors, gates and arches are considered passage ways, meaning that an agent can walk through those structures freely. These default design choices add negligible run-time overhead. Note that more complex interaction rules can be incorporated (e.g. manipulation) within House3D using our flexible API, which we leave for future work.
+
+# 4 ROOMNAV: A BENCHMARK TASK FOR CONCEPT-DRIVEN NAVIGATION
+
+Consider the task of concept-driven navigation as shown in Figure 1b. A human may give a high level instruction to the robot, for example, “Go to the kitchen”, so that one can later ask the robot to turn on the oven. The robot needs to behave appropriately conditioned on the house it is located in and the goal, e.g. the semantic concept “kitchen”. In addition, we want the agent to generalize, i.e. to perform well in unseen environments, that is new houses with different layouts and furniture locations.
+
+To study the aforementioned abilities of an agent, we develop a benchmark task, Concept-Driven Navigation (RoomNav), based on House3D. We define the goal to be of the form $^ { 6 6 } \mathrm { g o }$ to $\mathrm { \nabla { X ^ { \prime } { } ^ { * } } }$ , where X denotes a pre-defined room type or object type, which is a semantic concept that an agent needs to interpret from a variety of scenes of distinct visual appearances. To ensure fast experimentation cycles, we perform experiments on a subset of House3D. We manually select 270 houses suitable for a navigation task and split them into a small set (20 houses), a large set (200 houses) and a test set (50 houses), where the test set is used to evaluate the generalization of the trained agents.
+
+Task Formulation: Suppose we have a set of episodic environments $\mathcal { E } ~ = ~ \{ E _ { 1 } , . . , E _ { n } \}$ and a set of semantic concepts $\bar { \mathcal { T } } = \{ I _ { 1 } , . . , I _ { m } \}$ . During each episode, the agent is interacting with one environment $E \in { \mathcal { E } }$ and is given a concept $I \in \mathcal { T }$ . In the beginning of an episode, the agent is randomly placed somewhere in $E$ . At each time step $t$ , the agent receives a visual signal $X _ { t }$ from $E$ via its first person view sensor. Let $s _ { t } = \{ X _ { 1 } , . . , X _ { t } , I \}$ denote the state of the agent at time $t$ . The agent needs to propose an action $a _ { t }$ to navigate and rotate its sensor given $s _ { t }$ . The environment returns a reward signal $r _ { t }$ and terminates when the agent succeeds in finding the destination, or reaches a maximum number of steps.
+
+The objective of this task is to learn an optimal policy $\pi ( \boldsymbol { a } _ { t } | \boldsymbol { s } _ { t } , I )$ that leads to the target defined by $I$ . We train the agent on a set ${ \mathcal { E } } _ { \operatorname { t r a i n } }$ . We evaluate the policy on a disjoint set of environments ${ \mathcal { E } } _ { \mathrm { t e s t } }$ ( $\mathcal { E } _ { \mathrm { t e s t } } \cap \mathcal { E } _ { \mathrm { t r a i n } } = \emptyset ,$ ). For more details see the Appendix.
+
+Environment Statistics: The selected 270 houses are manually verified for navigation; they are well connected, contain desired concepts, and are large enough for exploration. We split them into 3 disjoint sets, denoted by $\mathcal { E } _ { s m a l l }$ , $\mathcal { E } _ { l a r g e }$ and $\mathcal { E } _ { t e s t }$ respectively. For the semantic concepts, we select the five most common room types: kitchen, living room, dining room, bedroom and bathroom. Note that this set can be extended to include objects or even subareas within rooms.
+
+Observations: We utilize three different kinds of visual input signals for $X _ { t }$ , including (1) raw pixel values; (2) semantic segmentation mask of the pixel input; and (3) depth information, and experiment with different combinations of them. We encode each concept $I$ as a one-hot vector representation.
+
+Action Space: Similar to existing navigation works, we define a fixed set of actions, here 12 in number including different scales of rotations and movements. Due to the complexity of the indoor scenes, we also explore a continuous action space similar to (Lowe et al., 2017), which in effect allows the agent to move with different velocities. For more details see the Appendix. In all cases, if the agent hits an obstacle it remains still.
+
+Success Measure and Reward Function: To declare success, we want to ensure that the agent identifies the target room by its unique properties (e.g. presence of appropriate objects in the room such as pan and knives for kitchen and bed for bedroom) instead of merely reaching there by luck. An episode is considered successful if both of the following two criteria are satisfied: (1) the agent is located inside the target room; (2) the agent consecutively sees a designated object category associated with that target room type for at least 2 time steps. We assume that an agent sees an object if there are at least $4 \%$ of pixels in $X _ { t }$ belonging to that object.
+
+For the reward function, ideally two signals suffice to reflect the task requirement: (1) a collision penalty when hitting obstacles; and (2) a success reward when completing the task. However, these basic signals make it too difficult for an RL agent to learn, as the positive reward is too sparse. To provide additional supervision during training, we resort to an informative reward shaping: we compute the approximate shortest distance from the target room to each location in the house and adopt the difference of shortest distances between the agent’s movement as an additional reward signal. Note that our ultimate goal is to learn a policy that could generalize to unseen houses. Our strong reward shaping supervises the agent at training and is not available to the agent at test time. We empirically observe that stronger reward shaping leads to better performances on both training and testing.
+
+# 5 GATED-ATTENTION NETWORKS FOR MULTI-TARGET LEARNING
+
+The RoomNav task can be considered as a multi-target learning problem: the policy needs to condition on both the input $s _ { t }$ and the target concept $I$ . For policy representations which incorporate the target $I$ , we propose two baseline models with a gated-attention architecture, similar to Dhingra et al. (2016) and Chaplot et al. (2017): a gated-CNN network for continuous actions and a gatedLSTM network for discrete actions. We train the gated-CNN policy using the deep deterministic policy gradient (DDPG) (Lillicrap et al., 2015), while the gated-LSTM policy is trained using the asynchronous advantage actor-critic algorithm (A3C) (Mnih et al., 2016).
+
+![](images/a75289ae7bf516017b287610ca208e9db5d32947bd34b698e6fa707f328db54e.jpg)  
+Figure 2: Overview of our proposed models. Bottom part demonstrates the gated-LSTM model for discrete action while the top part shows the gated-CNN model for continuous action. The “Gated Fusion” module denotes the gated-attention architecture.
+
+# 5.1 DDPG WITH GATED-CNN POLICY
+
+# 5.1.1 DEEP DETERMINISTIC POLICY GRADIENT
+
+Suppose we have a deterministic policy $\mu ( s _ { t } | \boldsymbol { \theta } )$ (actor) and the Q-function $Q ( s _ { t } , a | \theta )$ (critic) both parametrized by $\theta$ . DDPG optimizes the policy $\mu ( s _ { t } | \boldsymbol { \theta } )$ by maximizing $\begin{array} { r l r } { L _ { \mu } ( \theta ) } & { { } = } & { \bar { \mathbb { E } _ { s _ { t } } } \left[ Q ( s _ { t } , \mu ( s _ { t } | \theta ) | \theta ) \right] } \end{array}$ , and updates the $\mathrm { Q }$ -function by minimizing $\begin{array} { r l } { L _ { Q } ( \theta ) } & { { } = } \end{array}$ $\mathbb { E } \left[ ( Q ( s _ { t } , a _ { t } | \theta ) - \gamma Q ( s _ { t + 1 } , \mu ( s _ { t + 1 } | \theta ) | \theta ) - r _ { t } ) ^ { 2 } \right]$ .
+
+Here, we use a shared network for both actor and critic with the final loss function $L _ { \mathrm { D D P G } } ( \theta ) =$ $- L _ { \mu } ( \theta ) + \alpha _ { \mathrm { D D P G } } L _ { Q } ( \theta )$ , where $\alpha _ { \mathrm { D D P G } }$ is a constant balancing the two objectives.
+
+# 5.1.2 GATED-CNN FOR CONTINUOUS POLICY
+
+State Encoding: Given state $s _ { t }$ , we first stack the most recent $k$ frames $\begin{array} { r l } { X } & { { } = } \end{array}$ $[ X _ { t } , X _ { t - 1 } , \ldots , X _ { t - k + 1 } ]$ channel-wise and apply a convolutional neural network to derive an image representation $x ~ = ~ f _ { \mathrm { c n n } } ( X | \theta ) ~ \in ~ \mathbb { R } ^ { d _ { X } }$ . We convert the target $I$ into an embedding vector $\dot { y ^ { \cdot } } = \bar { f } _ { \mathrm { e m b e d } } ( I | \theta ) \in \mathbb { R } ^ { d _ { I } }$ . Subsequently, we apply a fusion module $M ( x , y | \theta )$ to derive the final encoding $h _ { s } = M ( x , y | \theta )$ .
+
+Gated-Attention for Feature Fusion: For the fusion module $M ( x , y | \theta )$ , the straightforward version is concatenation, namely $M _ { \mathrm { c a t } } ( x , y | \cdot ) = [ x , y ]$ . In our case, $x$ is always a high-dimensional feature vector (i.e., image feature) while $y$ is a simple low-dimensional conditioning vector (e.g., instruction). Thus, simple concatenation may result in optimization difficulties. For this reason, we propose to use a gated-attention mechanism. Suppose $x \in \mathbb { R } ^ { d _ { x } }$ and $\boldsymbol { y } \in \mathbb { R } ^ { d _ { \boldsymbol { y } } }$ where $d _ { y } ~ < ~ d _ { x }$ . First, we transform $y$ to $y ^ { \prime } \in \mathbb { R } ^ { d _ { X } }$ via an MLP, namely $y ^ { \prime } ~ = ~ f _ { \mathrm { m l p } } ( y | \theta )$ , and then perform a Hadamard (pointwise) product between $x$ and sigmoid $( y ^ { \prime } )$ , which leads to our final gated fusion module $M ( x , y | \theta ) = x \odot$ sigmoid $\left( f _ { \mathrm { m l p } } ( y | \theta ) \right)$ . This gated fusion module could also be interpreted as an attention mechanism over the feature vector which could help better shape the feature representation.
+
+Policy Representation: For the policy, we apply a MLP layer on the state representation $h _ { s }$ , followed by a softmax operator (for bounded velocity) to produce the continuous action. Moreover, in order to produce a stochastic policy for both better exploration and higher robustness, we apply the Gumbel-Softmax trick (Jang et al., 2016), resulting in the final policy $\mu ( s _ { t } | \theta ) =$ Gumbel-Softmax ${ \bf \zeta } ^ { \prime } f _ { \mathrm { m l p } } ( h _ { s } | \boldsymbol { \theta } ) )$ . Note that since we add randomness to $\mu ( s _ { t } | \boldsymbol { \theta } )$ , our DDPG formulation can also be interpreted as the SVG(0) algorithm (Heess et al., 2015).
+
+Q-function: The Q-function $Q ( s , a )$ conditions on both state $s$ and action $a$ . We again apply a gated fusion module to the feature vector $x$ and the action vector $a$ to derive a hidden representation $h _ { Q } = M ( x , a | \theta )$ . We eventually apply another MLP to $h _ { Q }$ to produce the final value $Q ( s , a )$ .
+
+A model demonstration is shown in the top part of Fig. 2, where each block has its own parameters.
+
+5.2 A3C WITH GATED-LSTM POLICY
+
+# 5.2.1 ASYNCHRONOUS ADVANTAGE ACTOR-CRITIC
+
+Suppose we have a discrete policy $\pi ( \boldsymbol { a } ; \boldsymbol { s } | \boldsymbol { \theta } )$ and a value function $v ( s | \theta )$ . A3C optimizes the policy by minimizing the loss function $\begin{array} { r } { L _ { \mathrm { p g } } ( \theta ) = - \mathbb { E } _ { s _ { t } , a _ { t } , r _ { t } } \left[ \sum _ { t = 1 } ^ { T } ( R _ { t } - v ( s _ { t } ) ) \log \pi ( a _ { t } ; s _ { t } | \theta ) \right] } \end{array}$ , where $R _ { t }$ is the discounted accumulative reward defined by $\begin{array} { r } { R _ { t } = \sum _ { i = 0 } ^ { T - t } \gamma ^ { i } r _ { t + i } + v ( s _ { T + 1 } ) } \end{array}$ . The value function is updated by minimizing the loss $L _ { v } ( \theta ) = \mathbb { E } _ { s _ { t } , r _ { t } } [ ( R _ { t } - v ( s _ { t } ) ) ^ { 2 } ]$ .
+
+Finally the overall loss function for A3C is $L _ { \mathrm { A 3 C } } ( \theta ) = L _ { \mathrm { p g } } ( \theta ) + \alpha _ { \mathrm { A 3 C } } L _ { v } ( \theta )$ where $\alpha _ { \mathrm { A } 3 \mathrm { C } }$ is a constant coefficient.
+
+# 5.2.2 GATED-LSTM NETWORK FOR DISCRETE POLICY
+
+State Encoding: Given state $s _ { t }$ , we first apply a CNN module to extract image feature $x _ { t }$ for each input frame $X _ { t }$ . For the target, we apply a gated fusion module to derive a state representation $h _ { t } = { \bar { M } } ( x _ { t } , I | \theta )$ at each time step $t$ . Then, we concatenate $h _ { t }$ with the target $I$ and the result is fed into the LSTM module (Hochreiter & Schmidhuber, 1997) to obtain a sequence of LSTM outputs $\{ o _ { t } \} _ { t }$ , so that the LSTM module has direct access to the target other than the attended visual feature.
+
+Policy and Value Function: For each time step $t$ , we concatenate the state vector $h _ { t }$ with the output of the LSTM $o _ { t }$ to obtain a joint hidden vector $h _ { \mathrm { j o i n t } } = [ h _ { t } , o _ { t } ]$ . Then we apply two MLPs to $h _ { \mathrm { j o i n t } }$ to obtain the policy distribution $\pi ( a ; s _ { t } | \theta )$ as well as the value function $v ( s _ { t } | \theta )$ .
+
+A visualization of the model is in the bottom part of Fig. 2. The parameters of CNN modules are shared across time.
+
+# 6 EXPERIMENTAL RESULTS
+
+We report experimental results for our models on the task of RoomNav. We first compare models with discrete and continuous action spaces with different input modalities. Then we explain our observations and show that techniques targeting different levels of augmentation improve the success rate of navigation in the test set. Moreover, these techniques are complementary to each other.
+
+Setup. We train our baseline models on multiple experimental settings. We use two training datasets. The small set $\mathcal { E } _ { \mathrm { s m a l l } }$ contains 20 houses and the large set $\mathcal { E } _ { \mathrm { l a r g e } }$ contains 200 houses. A held-out dataset ${ \mathcal { E } } _ { \mathrm { t e s t } }$ is used for test, which contains 50 houses.
+
+We mainly focus on success rate on the test set, i.e, how the agent generalizes. For reference, we also report the training performance. The agent fails if it failed to find the concept within 100 steps1. All success rate evaluations use a fixed random seed for a fair comparison. For each model, we run 2000 evaluation episodes on $\mathcal { E } _ { \mathrm { s m a l l } }$ and ${ \mathcal { E } } _ { \mathrm { t e s t } }$ , and 5000 evaluation episodes on $\mathcal { E } _ { \mathrm { l a r g e } }$ to measure overall success rates.
+
+We use gated-CNN and gated-LSTM to denote the networks with gated-attention, and concat-CNN and concat-LSTM for models with simple concatenation. We also experiment with different visual signals to the agents, including RGB image (RGB Only), RGB image with depth information $( \mathrm { R G B + D e p t h } _ { \it . }$ ) and semantics mask with depth information (Mask+Depth). The input image resolution is $1 2 0 \times 9 0$ to preserve image details.
+
+During each simulated episode, we randomly select a house from the environment set and randomly pick an applicable target from the house to instruct the agent. During training, we add an entropy bonus term for both models2 in addition to the original loss function. For evaluation, we keep the final model for DDPG due to its stable learning curve, while for A3C, we take the model with the highest training success rate. We use Pytorch (Paszke et al., 2017) and Adam (Kingma & Ba, 2014). See Appendix for more experiment details.
+
+![](images/2a7e99e411b4b1ed123690d80271e22c9fd61e30671c238b5ca0408323ae7085.jpg)  
+Figure 3: Overall performance of various models trained on (a) ${ \mathcal { E } } _ { \mathrm { s m a l l } }$ (20 houses) with different input signals: RGB Only, RGB $+$ Depth and Mask+Depth; (b) $\mathcal { E } _ { \mathrm { l a r g e } }$ (200 houses) with input signals: RGB $+$ Depth and Mask $^ +$ Depth. In each group, the bars from left to right correspond to gated-LSTM, concat-LSTM, gated-CNN, concat-CNN and random policy respectively.
+
+![](images/831f27bb070ec5c13732af2eab2e624097384a20c5e000ea1853f551e7d1aa7d.jpg)  
+Figure 4: Pixel-level Augmentation: Test performances of various models trained with different input signals, including RGB $^ +$ Depth on $\mathcal { E } _ { \mathrm { s m a l l } }$ , RGB with Domain Randomization on ${ \mathcal { E } } _ { \mathrm { s m a l l } }$ , Mask+Depth on $\mathcal { E } _ { \mathrm { s m a l l } }$ , Mask $^ +$ Depth on $\mathcal { E } _ { \mathrm { l a r g e } }$ . In each group, the bars represent gated-LSTM, concat-LSTM, gated-CNN and concat-CNN from left to right.
+
+6.1 BASELINES: MODELS WITH RGB SIGNALS ON $\mathcal { E } _ { \mathrm { S M A L L } }$
+
+As shown in the bottom part of Fig. 3a, on $\mathcal { E } _ { \mathrm { s m a l l } }$ , the test success rate for models trained on RGB features is unsatisfactory. We observe obvious overfitting behavior: the test performance is drastically worse than training. In particular, the gated-LSTM models achieve even lower success rate than concat-LSTM models, despite the fact that they have much better training performance. In this case, the learning algorithm picks up spurious color patterns in the environments as the guidance towards the goal, which is inapplicable to unseen environments.
+
+In both training and test, we find that depth information improves the performance thus we use it in the following experiments and omit Depth for conciseness.
+
+# 6.2 TECHNIQUES FOR DIFFERENT LEVELS OF AUGMENTATION
+
+Augmentation is a standard technique to improve generalization. However, for complicated tasks, augmentation needs to be taken care at different levels. In this section, we categorize augmentation techniques into 3 levels: (1) pixel-level augmentation: changing the colors and textures; (2) tasklevel augmentation: joint learning for multiple tasks; (3) scene-level augmentation: training on more environments. We analyze the generalization performance with all techniques and conclude that these techniques are complementary and that the best test performance is obtained by combining these techniques together.
+
+Pixel-level Augmentation: We use domain randomization (Tobin et al., 2017), by reassigning each object in the scene a random color but keeping the textures. This breaks the spurious color correlations and pushes the agent to learn a better representation.
+
+We explore domain randomization by generating an additional 180 houses with random object coloring from $\mathcal { E } _ { \mathrm { s m a l l } }$ , which leads to a total of 200 houses. We evaluate the test success rate of various models under different training settings, e.g., RGB, RGB with domain randomization (D.R.) or mask signal. The results are shown in Fig. 4. Interestingly, we noticed that domain randomization yields very similar performance as mask signal on $\mathcal { E } _ { \mathrm { s m a l l } }$ .
+
+One shortcoming of domain randomization is that it requires substantially more training samples and thus suffers from high sample complexity. Thanks to the rich labels in House3D, we instead could use segmentation mask as an input feature plane, which encodes semantic information and is independent of the object color. This helps train generalizable agent with much fewer training samples. On the other hand, an agent trained with domain randomization can operate with RGB input only, without segmentation mask output from a vision subsystem. In the current context, we simply assume adopting segmentation mask input as the technique for pixel-level augmentation.
+
+Task-level Augmentation: We explore task-level augmentation by adding related auxiliary targets during training (Fig. 5). Specifically, in addition to the 5 room types as auxiliary targets, we selected
+
+![](images/47a1cf4d0faa2df7ea6030a18f3c8112a74d0651fb7a73afe7ce8a6d479d18e6.jpg)  
+Figure 5: Task-Level Augmentation: Test performances of LSTM models trained with and without auxiliary targets on both ${ \mathcal { E } } _ { \mathrm { s m a l l } }$ and $\mathcal { E } _ { \mathrm { l a r g e } }$ . In each group, the bars represent gated-LSTM $+ \mathrm { \ R G B }$ , concat-LSTM $^ +$ RGB, gated-LSTM $^ +$ Mask and concat-LSTM $^ +$ Mask from left to right.
+
+15 object concepts (e.g., chair, table, cabinet, etc. See a full list of object concepts in appendix.).   
+We train A3C agents with different input signals on ${ \mathcal { E } } _ { \mathrm { s m a l l } }$ and evaluate their test performances.
+
+We found that auxiliary targets significantly reduce overfitting and increases the generalizability of models with RGB inputs. Because of this effect, gated attention model, which has high model capacity, becomes much more effective on RGB signal when trained with more targets. On the other hand, with mask input, the agent does not need to learn to differentiate the objects, therefore auxiliary targets do not help that much for more complicated models like gated attention models.
+
+Scene-level Augmentation: We could further boost the generalization performance by augmenting the training set with more diverse set of houses, i.e, $\mathcal { E } _ { \mathrm { l a r g e } }$ that contain 200 different houses. This is also a benefit from House3D.
+
+For visual signals, we focus on feature combinations like “RGB $^ +$ Depth” and “M $\mathrm { a s k + D e }$ pth”. Note that for training efficiency, segmentation mask is a surrogate feature to approximate ${ } ^ { 6 6 } { \mathrm { R G B } } +$ domain randomization” as it shows similar results in the small set. Both train and test results are summarized in Fig. 3b.
+
+On a semantically diverse dataset $\mathcal { E } _ { \mathrm { l a r g e } }$ , the overfitting issue is largely resolved. We see drops in the training performance and improve on the generalization. After training on a large number of environments, every model now has a much smaller gap between its training and test performance. This is in particularly true for the models using RGB signal, which suffers from overfitting issues on ${ \mathcal { E } } _ { \mathrm { s m a l l } }$ . Notably, on large dataset, LSTM models generally perform better than CNN models due to its high model capacity.
+
+In addition, similar behavior was also observed during our experiments with techniques for pixellevel augmentation (Fig. 4) and task-level augmentation (Fig. 5). In all the experiments, all the models consistently achieves better generalization performances when trained on $\mathcal { E } _ { \mathrm { l a r g e } }$ , which again emphasizes the benefits of House3D.
+
+The overall best success rate is achieved by gated-attention architecture with semantic signals. It is better than both RGB channels by over $8 \%$ and the counterpart trained on ${ \mathcal { E } } _ { \mathrm { s m a l l } }$ in terms of generalization metric. This means that pixel-level augmentation (e.g., domain randomization and/or segmentation mask) and scene-level augmentation (e.g., using diverse dataset) can improve the performance. Moreover, their effects are complementary.
+
+A diverse environment like $\mathcal { E } _ { \mathrm { l a r g e } }$ also enables the model of larger capacity to work better. For example, LSTMs considerably outperform the simpler reactive models, i.e., CNNs with recent 5 frames as state input. We believe this is due to the larger scale and the high complexity of the training set, which makes it almost impossible for an agent to “remember” the optimal actions for every scenario. Instead, an agent needs to develop high-level abstractions (e.g., high-level exploration strategy, memory, etc). These are helpful induction biases that could lead to a more generalizable model.
+
+Lastly, we also analyze the detailed success rate with respect to each target room in appendix.
+
+# 7 CONCLUSION
+
+In this paper, we propose a new environment, House3D, which contains 45K houses with a diverse set of objects and natural layouts resembling the real-world.
+
+In House3D, we teach an agent to accomplish semantic goals. We define RoomNav, in which an agent needs to understand a given semantic concept, interpret the comprehensive visual signal, navigate to the target, and most importantly, succeed in a new unseen environment. We note that generalization to unseen environments was rarely studied in previous works.
+
+To this end, we quantify the effect of various levels of augmentations, all facilitated by House3D by the means of domain randomization, multi-target training and the diversity of the environment. We resort to well established RL techniques equipped with gating to encode the task at hand. The final performance on unseen environments is much higher than baseline methods by over $8 \%$ . We hope House3D as well as our training techniques can benefit the whole RL community for building generalizable agents.
+
+# REFERENCES
+
+Jacob Andreas, Dan Klein, and Sergey Levine. Modular multitask reinforcement learning with policy sketches. arXiv preprint arXiv:1611.01796, 2016.   
+Iro Armeni, Ozan Sener, Amir R. Zamir, Helen Jiang, Ioannis Brilakis, Martin Fischer, and Silvio Savarese. 3D semantic parsing of large-scale indoor spaces. CVPR, 2016.   
+Charles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler, Andrew ¨ Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, et al. Deepmind lab. ´ arXiv preprint arXiv:1612.03801, 2016.   
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 47:253–279, 2013.   
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. OpenAI gym. arXiv preprint arXiv:1606.01540, 2016.   
+Simon Brodeur, Ethan Perez, Ankesh Anand, Florian Golemo, Luca Celotti, Florian Strub Strub, Jean Rouat, Hugo Larochelle, and Aaron Courville Courville. HoME: a household multimodal environment. arXiv 1711.11017, 2017.   
+Angel Chang, Angela Dai, Thomas Funkhouser, Maciej Halber, Matthias Niessner, Manolis Savva, Shuran Song, Andy Zeng, and Yinda Zhang. Matterport3d: Learning from RGB-D data in indoor environments. International Conference on 3D Vision (3DV), 2017.   
+Devendra Singh Chaplot, Kanthashree Mysore Sathyendra, Rama Kumar Pasumarthi, Dheeraj Rajagopal, and Ruslan Salakhutdinov. Gated-attention architectures for task-oriented language grounding. arXiv preprint arXiv:1706.07230, 2017.   
+Paul Christiano, Zain Shah, Igor Mordatch, Jonas Schneider, Trevor Blackwell, Joshua Tobin, Pieter Abbeel, and Wojciech Zaremba. Transfer from simulation to real world through learning deep inverse dynamics model. arXiv preprint arXiv:1610.03518, 2016.   
+Abhishek Das, Samyak Datta, Georgia Gkioxari, Stefan Lee, Devi Parikh, and Dhruv Batra. Embodied Question Answering. arXiv preprint arXiv:1711.11543, 2017a.   
+Abhishek Das, Satwik Kottur, Stefan Lee, Jos M.F. Moura, and Dhruv Batra. Learning cooperative visual dialog agents with deep reinforcement learning. ICCV, 2017b.   
+Bhuwan Dhingra, Hanxiao Liu, Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Gated-attention readers for text comprehension. arXiv preprint arXiv:1606.01549, 2016.   
+Gandhi Dhiraj, Pinto Lerrel, and Gupta Abhinav. Learning to fly by crashing. IROS, 2017.   
+Yan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel. RL2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016.   
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. arXiv preprint arXiv:1703.03400, 2017a.
+
+Chelsea Finn, Tianhe Yu, Justin Fu, Pieter Abbeel, and Sergey Levine. Generalizing skills with semi-supervised reinforcement learning. ICLR, 2017b.
+
+Dieter Fox, Sebastian Thrun, and Wolfram Burgard. Probabilistic Robotics. MIT press, 2005.
+
+Saurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. CVPR, 2017.
+
+Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pp. 2944–2952, 2015.
+
+Irina Higgins, Arka Pal, Andrei A Rusu, Loic Matthey, Christopher P Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. arXiv preprint arXiv:1707.08475, 2017.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):1735–1780, 1997.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.
+
+Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with Gumbel-Softmax. arXiv preprint arXiv:1611.01144, 2016.
+
+Matthew Johnson, Katja Hofmann, Tim Hutton, and David Bignell. The Malmo platform for artificial intelligence experimentation. In IJCAI, pp. 4246–4247, 2016.
+
+Simon Green Fumin Wang Ryan Faulkner Hubert Soyer David Szepesvari Wojciech Marian Czarnecki Max Jaderberg Denis Teplyashin Marcus Wainwright Chris Apps Demis Hassabis Karl Moritz Hermann, Felix Hill and PhilBlunsom. Grounded language learning in a simulated 3d world. In arXiv 1706.06551. 2017.
+
+Michał Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. Vizdoom: A ´ doom-based AI research platform for visual reinforcement learning. In Computational Intelligence and Games (CIG), 2016 IEEE Conference on, pp. 1–8. IEEE, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+John J. Leonard and Hugh F. Durrant-Whyte. Directed Sonar Sensing for Mobile Robot Navigation. Kluwer Academic Publishers, Norwell, MA, USA, 1992. ISBN 0792392426.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. JMLR, 2016.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. arXiv preprint arXiv:1706.02275, 2017.
+
+John McCormac, Ankur Handa, Stefan Leutenegger, and Andrew J Davison. SceneNet RGB-D: Can 5m synthetic images beat generic ImageNet pre-training on indoor segmentation? In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2678–2687, 2017.
+
+Alexander H Miller, Will Feng, Adam Fisch, Jiasen Lu, Dhruv Batra, Antoine Bordes, Devi Parikh, and Jason Weston. Parlai: A dialog research software platform. arXiv preprint arXiv:1705.06476, 2017.
+
+Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andy Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, et al. Learning to navigate in complex environments. arXiv preprint arXiv:1611.03673, 2016.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016.   
+Karthik Narasimhan, Regina Barzilay, and Tommi Jaakkola. Deep transfer in reinforcement learning by language grounding. arXiv preprint arXiv:1708.00133, 2017.   
+Junhyuk Oh, Satinder Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization with multi-task deep reinforcement learning. arXiv preprint arXiv:1706.05064, 2017.   
+Emilio Parisotto and Ruslan Salakhutdinov. Neural map: Structured memory for deep reinforcement learning. arXiv preprint arXiv:1702.08360, 2017.   
+Adam Paszke, Sam Gross, and Soumith Chintala. Pytorch, 2017. URL http://pytorch.org/.   
+Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by selfsupervised prediction. ICML, 2017.   
+Andrei A Rusu, Matej Vecerik, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell. Sim-to-real ¨ robot learning from pixels with progressive nets. arXiv preprint arXiv:1610.04286, 2016.   
+Fereshteh Sadeghi and Sergey Levine. CAD2RL: Real single-image flight without a single real image. RSS, 2017.   
+Manolis Savva, Angel X. Chang, Alexey Dosovitskiy, Thomas Funkhouser, and Vladlen Koltun. MINOS: Multimodal indoor simulator for navigation in complex environments. arXiv:1712.03931, 2017.   
+Tianlin Shi, Andrej Karpathy, Linxi Fan, Jonathan Hernandez, and Percy Liang. World of Bits: An opendomain platform for web-based agents. In International Conference on Machine Learning, pp. 3135–3144, 2017.   
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.   
+Shuran Song, Fisher Yu, Andy Zeng, Angel X Chang, Manolis Savva, and Thomas Funkhouser. Semantic scene completion from a single depth image. CVPR, 2017.   
+Gabriel Synnaeve, Nantas Nardelli, Alex Auvolat, Soumith Chintala, Timothee Lacroix, Zeming Lin, Florian ´ Richoux, and Nicolas Usunier. Torchcraft: a library for machine learning research on real-time strategy games. arXiv preprint arXiv:1611.00625, 2016.   
+Lei Tai and Ming Liu. Towards cognitive exploration through deep reinforcement learning for mobile robots. arXiv preprint arXiv:1610.01733, 2016.   
+Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. In Advances in Neural Information Processing Systems, pp. 2154–2162, 2016.   
+Yuandong Tian, Qucheng Gong, Wenling Shang, Yuxin Wu, and Larry Zitnick. ELF: An extensive, lightweight and flexible research platform for real-time strategy games. arXiv preprint arXiv:1707.01067, 2017.   
+Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. arXiv preprint arXiv:1703.06907, 2017.   
+Oriol Vinyals, Timo Ewalds, Sergey Bartunov, Petko Georgiev, Alexander Sasha Vezhnevets, Michelle Yeo, Alireza Makhzani, Heinrich Kuttler, John Agapiou, Julian Schrittwieser, et al. Starcraft ii: A new challenge ¨ for reinforcement learning. arXiv preprint arXiv:1708.04782, 2017.   
+Yuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J Lim, Abhinav Gupta, Li Fei-Fei, and Ali Farhadi. Targetdriven visual navigation in indoor scenes using deep reinforcement learning. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 3357–3364. IEEE, 2017.
+
+Table 2: Statistics of the selected environment sets for RoomNav. RoomType% denotes the percentage of houses containing at least one target room of type RoomType.   
+
+<table><tr><td></td><td>3</td><td>avg.#targets</td><td>kitchen%</td><td>dining room %</td><td> living room%</td><td>bedroom%</td><td>bathroom%</td></tr><tr><td>Esmall</td><td>20</td><td>3.9</td><td>0.95</td><td>0.60</td><td>0.60</td><td>0.95</td><td>0.80</td></tr><tr><td>Elarge</td><td>200</td><td>3.7</td><td>1.00</td><td>0.35</td><td>0.63</td><td>0.94</td><td>0.80</td></tr><tr><td>Etest</td><td>50</td><td>3.7</td><td>1.00</td><td>0.48</td><td>0.58</td><td>0.94</td><td>0.70</td></tr></table>
+
+<table><tr><td></td><td>test succ.</td><td>kitchen%</td><td>dining room %</td><td>living room%</td><td>bedroom%</td><td>bathroom%</td></tr><tr><td> gated-LSTM</td><td>35.8</td><td>37.9</td><td>50.4</td><td>48.0</td><td>33.5</td><td>21.2</td></tr><tr><td>gated-CNN</td><td>29.7</td><td>31.6</td><td>42.5</td><td>54.3</td><td>27.6</td><td>17.4</td></tr></table>
+
+Table 3: Detailed test success rates for gated-CNN model and gated-LSTM model with “Mask+Depth” as input signal across different instruction concepts.
+
+# A ROOMNAV TASK DETAILS
+
+# A.1 STATISTICS OF SELECTED HOUSE SETS
+
+We show the statistics of the selected three set of houses in Table 2.
+
+In addition to these 5 houses, we also pick another 15 object concepts in our mid-level generalization experiment as auxiliary targets. The object concepts are: shower, sofa, toilet, bed, plant, television, table-and-chair, chair, table, kitchen-set, bathtub, vehicle, pool, kitchen-cabinet, curtain.
+
+Detailed Specifications: The location information of an agent can be represented by 4 real numbers: the 3D location $( x , y , z )$ and the rotation degree $\rho$ of its first person view sensor, which indicates the front direction of the agent. Note that in RoomNav, the agent is not allowed to change its height $z$ , hence the overall degree of freedom is 3.
+
+An action can be in the form of a triple $\boldsymbol { a } = ( \delta _ { x } , \delta _ { y } , \delta _ { \rho } )$ . After taking the action $a$ , the agent will move to a new 3D location $( x + \delta _ { x } , y + \delta _ { y } , z )$ with a new rotation $\rho + \delta _ { \rho }$ . The physics in House3D will detect collisions with objects under action $a$ and in RoomNav, the agent will remain still in case of a collision. We also restrict the velocity of the agent such that $| \delta _ { x } | , | \delta _ { y } | \leq 0 . 5$ and $| \delta _ { \rho } | \leq 3 0$ to ensure a smooth movement.
+
+Continuous Action: A continuous action $a$ consists of two parts $a = [ m , r ]$ where $m = ( m _ { 1 } , \dots , m _ { 4 } )$ is for movement and $r = ( r _ { 1 } , r _ { 2 } )$ is for rotation. Since the velocity of the agent should be bounded, we require $m$ , $r$ to be a valid probability distribution. Suppose the original location of robot is $( x , y , z )$ and the angle of camera is $\rho$ , then after executing $a$ , the new 3D location will be $( x + ( m _ { 1 } - m _ { 2 } ) * 0 . 5 , y + ( m _ { 3 } - m _ { 4 } ) * 0 . 5 , z )$ and the new angle is $\rho + \left( r _ { 1 } - r _ { 2 } \right) * 3 0$ .
+
+Discrete Action: We define 12 different action triples in the form of $a _ { i } = ( \delta _ { x } , \delta _ { y } , \delta _ { \rho } )$ satisfying the velocity constraints. There are 8 actions for movement: left, forward, right with two scales and two diagonal directions; and 4 actions for rotation: clockwise and counter-clockwise with two scales. In the discrete action setting, we do not allow the agent to move and rotate simultaneously.
+
+Reward Details: In addition to the reward shaping of difference of shortest distances, we have the following rewards. When hitting an obstacle, the agent receives a penalty of 0.3. In the case of success, the winning reward is $+ 1 0$ . In order to encourage exploration (or to prevent eternal rotation), we add a time penalty of 0.1 to the agent for each time step outside the target room. Note that since we restrict the velocity of the agent, the difference of shortest path after an action will be no more than $0 . 5 \times \sqrt { 2 } \approx 0 . 7$ .
+
+# B EXPERIMENT DETAILS
+
+# B.1 NETWORK ARCHITECTURES
+
+We apply a batch normalization layer after each layer in the CNN module. The activation function used is ReLU. The embedding dimension of concept instruction is 25.
+
+Gated-CNN: In the CNN part, we have 4 convolution layers of 64, 64, 128, 128 channels perspective and with kernel size 5 and stride 2, as well as a fully-connected layer of 512 units. We use a linear layer to transform the concept embedding to a 512-dimension vector for gated fusion. The MLP for policy has two hidden layers of 128 and 64 units, and the MLP for Q-function has a single hidden layer of 64 units.
+
+Gated-LSTM: In the CNN module, we have 4 convolution layers of 64, 64, 128, 128 channels each and with kernel size 5 and stride 2, as well as a fully-connected layer of 256 units. We use a linear layer to convert the concept embedding to a 256-dimension vector. The LSTM module has 256 hidden dimensions. The MLP module for policy contains two layers of 128 and 64 hidden units, and the MLP for value function has two hidden layers of 64 and 32 units.
+
+# B.2 TRAINING PARAMETERS
+
+We normalize each channel of the input frame to $[ 0 , 1 ]$ before feeding it into the neural network. Each of the training procedures includes a weight decay of $1 0 ^ { \div 5 }$ and a discounted factor $\gamma = 0 . 9 5$ .
+
+DDPG: We stack $k = 5$ recent frames and use learning rate $1 0 ^ { 4 }$ with batch size 128. We choose $\alpha _ { \mathrm { D D P G } } = 1 0 0$ for all the settings except for the case with input signal of $\mathrm { \mathrm { } ^ { 6 6 } R G B + I }$ Depth” on $\mathcal { E } _ { \mathrm { l a r g e } }$ , where we choose $\alpha _ { \mathrm { D D P G } } =$ 10. We use an entropy bonus term with coefficient 0.001 on $\mathcal { E } _ { \mathrm { s m a l l } }$ and 0.01 on $\mathcal { E } _ { \mathrm { l a r g e } }$ . We use exponential average to update the target network with rate 0.001. A training update is performed every 10 time steps. The replay buffer size is $7 \times \mathrm { \overline { { 1 0 } } ^ { 5 } }$ . We run training for 80000 episodes in all. We use a linear exploration strategy in the first 30000 episodes.
+
+A3C: We clip the reward to the range $[ - 1 , 1 ]$ and use a learning rate $1 e - 3$ with batch size 64. We launch 120 processes on ${ \mathcal { E } } _ { \mathrm { s m a l l } }$ and 200 on $\mathcal { E } _ { \mathrm { l a r g e } }$ . During training we estimate the discounted accumulative rewards and back-propagate through time for every 30 time steps unrolled. We perform a gradient clipping of 1.0 and decay the learning rate by a factor of 1.5 when the difference of KL-divergence becomes larger than 0.01. For training on $\mathcal { E } _ { \mathrm { s m a l l } }$ , we use a entropy bonus term with coefficient 0.1; while on $\mathcal { E } _ { \mathrm { l a r g e } }$ , the coefficient is 0.05. αA3C is 1.0. We perform $1 0 ^ { 5 }$ training updates and keep the best model with the highest training success rate.
+
+# B.3 GENERALIZATION OVER DIFFERENT CONCEPTS
+
+We illustrate in Table 3 the detailed test success rates of our models trained on ${ \mathcal { E } } _ { \operatorname { t r a i n } }$ with respect to each of the 5 concepts. Note that both models have similar behaviour across concepts. In particular, “dining room” and “living room” are the easiest while “bathroom” is the hardest. We suspect that this is because dining room and living room are often with large room space and have the best connectivity to other places. By contrast, bathroom is often very small and harder to find in big houses.
+
+Lastly, we also experiment with adding auxiliary tasks of predicting the current room type during training. We found this does not help the training performance nor the test performance. We believe it is because our reward shaping has already provided strong supervision signals.
+
+# B.4 AVERAGE STEPS TOWARDS SUCCESS
+
+We also measure the number of steps required for an agent in RoomNav. For all the successful episodes, we evaluate the averaged number of steps towards the final target. The numbers are shown in Table 4. A random agent can only succeed when it’s initially spawned very close to the target, and therefore have very small number of steps towards target. Our trained agents, on the other hand, can explore in the environment and reach the target after resonable number of steps. Generally, our DDPG models takes fewer steps than our A3C models thanks to their continuous action space. But in all the settings, the number of steps required for a success is still far less than 100, namely the horizon length.
+
+<table><tr><td></td><td>random</td><td>concat-LSTM</td><td>gated-LSTM</td><td>concat-CNN</td><td>gated-CNN</td></tr><tr><td colspan="6">Avg. #steps towards targets on &amp;small with different input signals</td></tr><tr><td>RGB+Depth (train)</td><td>14.2</td><td>35.9</td><td>41.0</td><td>31.7</td><td>33.8</td></tr><tr><td>RGB+Depth (test)</td><td>13.3</td><td>27.1</td><td>29.8</td><td>26.1</td><td>25.3</td></tr><tr><td>Mask+Depth (train)</td><td>14.2</td><td>38.4</td><td>40.9</td><td>34.9</td><td>36.6</td></tr><tr><td>Mask+Depth (test)</td><td>13.3</td><td>31.9</td><td>34.3</td><td>26.2</td><td>30.4</td></tr><tr><td colspan="6">Avg. #steps towards targets on Elarge with different input signals</td></tr><tr><td>RGB+Depth (train)</td><td>16.0</td><td>36.4</td><td>35.6</td><td>31.0</td><td>32.4</td></tr><tr><td>RGB+Depth (test)</td><td>13.3</td><td>34.0</td><td>33.8</td><td>24.4</td><td>25.7</td></tr><tr><td>Mask+Depth (train)</td><td>16.0</td><td>40.1</td><td>38.8</td><td>34.6</td><td>36.2</td></tr><tr><td>Mask+Depth (test)</td><td>13.3</td><td>34.8</td><td>34.3</td><td>30.6</td><td>30.9</td></tr></table>
+
+Table 4: Averaged number of steps towards the target in all success trials for all the evaluated models with various input signals and different environments.

parse/train/rkaT3zWCZ/rkaT3zWCZ_content_list.json

@@ -0,0 +1,1748 @@
+[
+    {
+        "type": "text",
+        "text": "BUILDING GENERALIZABLE AGENTS WITH A REALISTIC AND RICH 3D ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yi Wu   \nUC Berkeley   \njxwuyi@gmail.com ",
+        "bbox": [
+            184,
+            170,
+            343,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yuxin Wu & Georgia Gkioxari & Yuandong Tian Facebook AI Research {yuxinwu,gkioxari,yuandong}@fb.com ",
+        "bbox": [
+            183,
+            233,
+            527,
+            276
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            311,
+            544,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Teaching an agent to navigate in an unseen 3D environment is a challenging task, even in the event of simulated environments. To generalize to unseen environments, an agent needs to be robust to low-level variations (e.g. color, texture, object changes), and also high-level variations (e.g. layout changes of the environment). To improve overall generalization, all types of variations in the environment have to be taken under consideration via different level of data augmentation steps. To this end, we propose House3D, a rich, extensible and efficient environment that contains 45,622 human-designed 3D scenes of visually realistic houses, ranging from single-room studios to multi-storied houses, equipped with a diverse set of fully labeled 3D objects, textures and scene layouts, based on the SUNCG dataset (Song et al., 2017). The diversity in House3D opens the door towards scene-level augmentation, while the label-rich nature of House3D enables us to inject pixel- & task-level augmentations such as domain randomization (Tobin et al., 2017) and multi-task training. Using a subset of houses in House3D, we show that reinforcement learning agents trained with an enhancement of different levels of augmentations perform much better in unseen environments than our baselines with raw RGB input by over $8 \\%$ in terms of navigation success rate. House3D is publicly available at http://github.com/facebookresearch/House3D. ",
+        "bbox": [
+            233,
+            340,
+            764,
+            604
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            628,
+            336,
+            643
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, deep reinforcement learning has shown its strength on multiple games, such as Atari (Mnih et al., 2015) and Go (Silver et al., 2016), vastly overpowering human performance. Via the various reinforcement learning frameworks, different aspects of intelligence can be learned, including 3D understanding (DeepMind Lab (Beattie et al., 2016) and Malmo (Johnson et al., 2016)), real-time strategy decision (TorchCraft (Synnaeve et al., 2016) and ELF (Tian et al., 2017)), fast reaction (Atari (Bellemare et al., 2013)), long-term planning (Go, Chess), language and communications (ParlAI (Miller et al., 2017) and (Das et al., 2017b)). ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A prominent issue in reinforcement learning is generalizability. Commonly, agents trained on a specific environment and for a specific task become highly specialized and fail to perform well on new environments. In the past, there have been efforts to address this issue. In particular, pixellevel variations are applied to the observation signals in order to increase the agent’s robustness to unseen environments (Beattie et al., 2016; Higgins et al., 2017; Tobin et al., 2017). Parametrized environments with varying levels of difficulty are used to yield scene variations but with similar visual observations (Pathak et al., 2017). Transfer learning is applied to similar tasks but with different rewards (Finn et al., 2017b). ",
+        "bbox": [
+            174,
+            763,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nevertheless, the aforementioned techniques study the problem in simplified environments which lack the diversity, richness and perception challenges of the real world. To this end, we propose a substantially more diverse environment, House3D, to train and test our agents. House3D is a virtual 3D environment consisting of thousands of indoor scenes equipped with a diverse set of scene types, layouts and objects. An overview of House3D is shown in Figure 1a. House3D leverages the SUNCG dataset (Song et al., 2017) which contains 45K human-designed real-world 3D house models, ranging from single studios to houses with gardens, in which objects are fully labeled with categories. We convert the SUNCG dataset to an environment, House3D, which is efficient and extensible for various tasks. In House3D, an agent can freely explore the space while perceiving a large number of objects under various visual appearances. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/82f8173d69c81105594cb3383044abb3a1c9c9a6d48e0e296a2d2e76cd8ff85f.jpg",
+        "image_caption": [
+            "Figure 1: An overview of House3D environment and RoomNav task. (a) We build an efficient and interactive environment upon the SUNCG dataset (Song et al., 2017) that contains 45K diverse indoor scenes, ranging from studios to two-storied houses with swimming pools and fitness rooms. All 3D objects are fully labeled into over 80 categories. Observations of agents in the environment have multiple modalities, including RGB images, Depth, Segmentation masks (from object category), top-down 2D view, etc. (b) We focus on the task of targeted navigation. Given a high-level description of a room concept, the agent explores the environment to reach the target room. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            101,
+            789,
+            311
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            450,
+            825,
+            547
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on House3D, we design a task called RoomNav: an agent starts at a random location in a house and is asked to navigate to a destination specified by a high-level semantic concept (e.g. kitchen), following simple rules (e.g. no object penetration), as shown in Figure 1b. We use gated-CNN and gated-LSTM policies trained with standard deep reinforcement learning methods, i.e. A3C (Mnih et al., 2016) and DDPG (Lillicrap et al., 2015), and report success rate on unseen environments over 5 concepts. We show that in order to achieve strong generalization capability, all-levels of augmentations are needed: pixel-level augmentation by domain randomization (Tobin et al., 2017) enhances the agent’s robustness to color variations; object-level augmentation forces the agent to learn multiple concepts (20 in number) simultaneously, and scene-level augmentation, where a diverse set of environments is used, enforce generalizability across diverse scenes, mitigating overfitting to particular scenes. Our final gated-LSTM agent achieves a success rate of $3 5 . { \\bar { 8 } } \\%$ on 50 unseen environments, $10 \\%$ better than the baseline method $( 2 5 . 7 \\% )$ . ",
+        "bbox": [
+            173,
+            555,
+            825,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The remaining of the paper is structured as follows. Section 2 summarizes relevant work. Section 3 describes our environment, House3D, in detail and section 4 describes the task, RoomNav. Section 5 describes our gated models and the applied algorithms to tackle RoomNav. Finally, experimental results are shown in Section 6. ",
+        "bbox": [
+            174,
+            728,
+            823,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            806,
+            344,
+            823
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Environments: Table 1 shows the comparison between House3D and most relevant prior works. There are other simulated environments which focus on different domains, such as OpenAI Gym (Brockman et al., 2016), ParlAI (Miller et al., 2017) for language communication as well as some strategic game environments (Synnaeve et al., 2016; Tian et al., 2017; Vinyals et al., 2017), etc. Most of these environments are pertinent to one particular aspect of intelligence, such as dialogue or a single type of game, which makes it hard to facilitate the study of more comprehensive problems. On the contrary, we focus on building a platform that intersects with multiple research directions, such as object and scene understanding, 3D navigation, embodied question answering (Das et al., 2017a), while allowing users to customize the level of complexity to their needs. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/c705b76257396026da1ea66666d2321b5a9e2f449f0236c74ed82217a651ea09.jpg",
+        "table_caption": [
+            "Table 1: A summary of popular environments. The attributes include 3D: 3D nature of the rendered objects, Realistic: resemblance to the real-world, Large-scale: a large set of environments, Fast: fast rendering speed and Customizable: flexibility to be customized to other applications. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Environment</td><td rowspan=1 colspan=1>3D</td><td rowspan=1 colspan=1>Realistic</td><td rowspan=1 colspan=1>Large-scale</td><td rowspan=1 colspan=1>Fast</td><td rowspan=1 colspan=1>Customizable</td></tr><tr><td rowspan=1 colspan=1>Atari (Bellemare et al., 2013)</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>OpenAI Universe (Shi 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></tr><tr><td rowspan=1 colspan=1>Malmo (Johnson 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></tr><tr><td rowspan=1 colspan=1>DeepMind Lab (Beattie 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></tr><tr><td rowspan=1 colspan=1>VizDoom (Kempka 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></tr><tr><td rowspan=1 colspan=1>AI2-THOR (Zhu 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></tr><tr><td rowspan=1 colspan=1>Stanford2D-3D (Armeni 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></tr><tr><td rowspan=1 colspan=1>Matterport3D (Chang 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></tr><tr><td rowspan=1 colspan=1>House3D</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": [
+            218,
+            101,
+            776,
+            239
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            324,
+            825,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We build on SUNCG (Song et al., 2017), a dataset that consists of thousands of diverse synthetic indoor scenes equipped with a variety of objects and layouts. Its visual diversity and rich content opens the path to the study of semantic generalization for reinforcement learning agents. Our platform decouples high-performance rendering from data I/O, and thus can use other publicly available 3D scene datasets as well. This includes Al2-THOR (Zhu et al., 2017), SceneNet RGB-D (McCormac et al., 2017), Stanford 3D (Armeni et al., 2016), Matterport 3D (Chang et al., 2017) and so on. ",
+        "bbox": [
+            173,
+            372,
+            825,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Concurrent works (Brodeur et al., 2017; Savva et al., 2017) also introduce similar platforms as House3D, indicating the interest for large-scale interactive and realistic 3D environments. ",
+        "bbox": [
+            174,
+            478,
+            823,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3D Navigation: There has been a prominent line of work on the task of navigation in real 3D scenes (Leonard & Durrant-Whyte, 1992). Classical approaches decompose the task into two subtasks by building a 3D map of the scene using SLAM and then planning in this map (Fox et al., 2005). More recently, end-to-end learning methods were introduced to predict robotic actions from raw pixel data (Levine et al., 2016). Some of the most recent works on navigation show the effectiveness of end-to-end learning. Gupta et al. (2017) learn to navigate via mapping and planning using shortest path supervision. Sadeghi & Levine (2017) teach an agent to fly using solely simulated data and deploy it in the real world. Dhiraj et al. (2017) collect a dataset of drones crashing into objects and train self-supervised agents on this data to avoid obstacles. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            638
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A number of recent works also use deep reinforcement learning for navigation in simulated 3D scenes. Mirowski et al. (2016); Jaderberg et al. (2016) improve an agent’s navigation ability in mazes by introducing auxiliary tasks. Parisotto & Salakhutdinov (2017) propose a new architecture which stores information of the environment on a 2D map. Karl Moritz Hermann & PhilBlunsom (2017) focus on the task of language grounding by navigating simple 3D scenes. However, these works only evaluate the agent’s generalization ability on pixel-level variations or small mazes. We argue that a much richer environment is crucial for evaluating semantic-level generalization. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gated Modules: In our work, we focus on the task of RoomNav, where the goal is communicated to the agent as a high-level instruction selected from a set of predefined concepts. To modulate the behavior of the agent in RoomNav, we encode the instruction as an embedding vector which gates the visual signal. The idea of gated attention has been used in the past for language grounding (Chaplot et al., 2017), and transfer learning by language grounding (Narasimhan et al., 2017). Similar to those works, we use concept grounding as an attention mechanism. We believe that our gated reinforcement learning models serve as a strong baseline for the task of semantic based navigation in House3D. Furthermore, our empirical results allow us to draw conclusions on the models’ efficacy when training agents in a large-scale, diverse dataset with an emphasis on generalization. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generalization: There is a recent trend in reinforcement learning focusing on the problem of generalization, ranging from learning to plan (Tamar et al., 2016), meta-learning (Duan et al., 2016; Finn et al., 2017a) to zero-shot learning (Andreas et al., 2016; Oh et al., 2017; Higgins et al., 2017). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, these works either focus on over-simplified tasks or test on environments which are only slightly varied from the training ones. In contrast, we use a more diverse set of environments, each containing visually and structurally different observations, and show that the agent can work well in unseen scenes. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work, we show improved generalization performance in complex 3D scenes when using depth and segmentation masks on top of the raw visual input. This observation is similar to other works which use a diverse set of input modalities (Mirowski et al., 2016; Tai & Liu, 2016). Our result suggests that it can be possible to decouple real-world robotics from recognition via a vision API provided by an object detection or semantic segmentation system trained on the targeted real scenes. This opens the door towards bridging the gap between simulated environment and real-world (Tobin et al., 2017; Rusu et al., 2016; Christiano et al., 2016). ",
+        "bbox": [
+            174,
+            166,
+            825,
+            263
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 HOUSE3D: AN EXTENSIBLE ENVIRONMENT OF 45K 3D HOUSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            285,
+            745,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose House3D, an environment which closely resembles the real world and is rich in content and structure. An overview of House3D is shown in Figure 1a. House3D is developed to provide an efficient and flexible environment of thousands of indoor scenes and facilitates a variety of tasks, e.g. navigation, visual understanding, language grounding, concept learning etc. The environment along with a python API for easy use is available at http://github.com/facebookresearch/ House3D. ",
+        "bbox": [
+            174,
+            318,
+            825,
+            400
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            417,
+            279,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The 3D scenes in House3D are sourced from the SUNCG dataset (Song et al., 2017), which consists of 45,622 human-designed 3D scenes ranging from single-room studios to multi-floor houses. The SUNCG dataset was designed to encourage research on large-scale 3D object recognition problems and thus carries a variety of objects, scene layouts and structures. On average, there are 8.9 rooms and 1.3 floors per scene There is a diverse set of room and object types in each scene. In total, there are over 20 different room types, such as bedroom, living room, kitchen, bathroom etc., with over 80 different object categories. In total, the SUNCG dataset contains 404,508 different rooms and 5,697,217 object instances drawn from 2644 unique object meshes. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 ANNOTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            574,
+            316,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each scene in SUNCG is fully annotated with 3D coordinates and its room and object types (e.g. bedroom, shoe cabinet, etc). This allows for a detailed mapping from each 3D location to an object instance (or None at free space) and the room type. ",
+        "bbox": [
+            176,
+            599,
+            825,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At every time step an agent has access to the following signals: a) the visual RGB signal of its current first person view, b) semantic/instance segmentation masks for all the objects visible in its current view, and c) depth information. For different tasks, these signals might serve for different purposes, e.g., as a feature plane or an auxiliary target. Based on the existing annotations, House3D offers more information, e.g., top-down 2D occupancy maps, connectivity analysis and shortest paths between two points. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 RENDERER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            292,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To build a realistic 3D environment, we develop a renderer for the SUNCG scenes. The renderer is based on OpenGL, it can run on both Linux and MacOS, and provides RGB images, semantic segmentation masks, instance segmentation masks and depth maps. ",
+        "bbox": [
+            176,
+            777,
+            821,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As highlighted above, the environment needs to be efficient in order to be used for large-scale reinforcement learning. On a NVIDIA Tesla M40 GPU, our implementation can render $1 2 0 \\times 9 0$ -sized frames at over 600 fps, while multiple renderers can run in parallel on one or more GPUs. When rendering multiple houses simultaneously, one M40 GPU can be fully utilized to render at a total of 1800 fps. The default simple physics adds a small overhead to the rendering. The high throughput of our implementation enables efficient learning for a variety of interactive tasks, such as on-policy reinforcement learning. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 INTERACTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            312,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In House3D, an agent can live in any location within a 3D scene, as long as it does not collide with object instances (including walls) within a small range, i.e. robot’s radius. Doors, gates and arches are considered passage ways, meaning that an agent can walk through those structures freely. These default design choices add negligible run-time overhead. Note that more complex interaction rules can be incorporated (e.g. manipulation) within House3D using our flexible API, which we leave for future work. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 ROOMNAV: A BENCHMARK TASK FOR CONCEPT-DRIVEN NAVIGATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            239,
+            799,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Consider the task of concept-driven navigation as shown in Figure 1b. A human may give a high level instruction to the robot, for example, “Go to the kitchen”, so that one can later ask the robot to turn on the oven. The robot needs to behave appropriately conditioned on the house it is located in and the goal, e.g. the semantic concept “kitchen”. In addition, we want the agent to generalize, i.e. to perform well in unseen environments, that is new houses with different layouts and furniture locations. ",
+        "bbox": [
+            173,
+            275,
+            825,
+            358
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To study the aforementioned abilities of an agent, we develop a benchmark task, Concept-Driven Navigation (RoomNav), based on House3D. We define the goal to be of the form $^ { 6 6 } \\mathrm { g o }$ to $\\mathrm { \\nabla { X ^ { \\prime } { } ^ { * } } }$ , where X denotes a pre-defined room type or object type, which is a semantic concept that an agent needs to interpret from a variety of scenes of distinct visual appearances. To ensure fast experimentation cycles, we perform experiments on a subset of House3D. We manually select 270 houses suitable for a navigation task and split them into a small set (20 houses), a large set (200 houses) and a test set (50 houses), where the test set is used to evaluate the generalization of the trained agents. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            463
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Task Formulation: Suppose we have a set of episodic environments $\\mathcal { E } ~ = ~ \\{ E _ { 1 } , . . , E _ { n } \\}$ and a set of semantic concepts $\\bar { \\mathcal { T } } = \\{ I _ { 1 } , . . , I _ { m } \\}$ . During each episode, the agent is interacting with one environment $E \\in { \\mathcal { E } }$ and is given a concept $I \\in \\mathcal { T }$ . In the beginning of an episode, the agent is randomly placed somewhere in $E$ . At each time step $t$ , the agent receives a visual signal $X _ { t }$ from $E$ via its first person view sensor. Let $s _ { t } = \\{ X _ { 1 } , . . , X _ { t } , I \\}$ denote the state of the agent at time $t$ . The agent needs to propose an action $a _ { t }$ to navigate and rotate its sensor given $s _ { t }$ . The environment returns a reward signal $r _ { t }$ and terminates when the agent succeeds in finding the destination, or reaches a maximum number of steps. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The objective of this task is to learn an optimal policy $\\pi ( \\boldsymbol { a } _ { t } | \\boldsymbol { s } _ { t } , I )$ that leads to the target defined by $I$ . We train the agent on a set ${ \\mathcal { E } } _ { \\operatorname { t r a i n } }$ . We evaluate the policy on a disjoint set of environments ${ \\mathcal { E } } _ { \\mathrm { t e s t } }$ ( $\\mathcal { E } _ { \\mathrm { t e s t } } \\cap \\mathcal { E } _ { \\mathrm { t r a i n } } = \\emptyset ,$ ). For more details see the Appendix. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Environment Statistics: The selected 270 houses are manually verified for navigation; they are well connected, contain desired concepts, and are large enough for exploration. We split them into 3 disjoint sets, denoted by $\\mathcal { E } _ { s m a l l }$ , $\\mathcal { E } _ { l a r g e }$ and $\\mathcal { E } _ { t e s t }$ respectively. For the semantic concepts, we select the five most common room types: kitchen, living room, dining room, bedroom and bathroom. Note that this set can be extended to include objects or even subareas within rooms. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Observations: We utilize three different kinds of visual input signals for $X _ { t }$ , including (1) raw pixel values; (2) semantic segmentation mask of the pixel input; and (3) depth information, and experiment with different combinations of them. We encode each concept $I$ as a one-hot vector representation. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Action Space: Similar to existing navigation works, we define a fixed set of actions, here 12 in number including different scales of rotations and movements. Due to the complexity of the indoor scenes, we also explore a continuous action space similar to (Lowe et al., 2017), which in effect allows the agent to move with different velocities. For more details see the Appendix. In all cases, if the agent hits an obstacle it remains still. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Success Measure and Reward Function: To declare success, we want to ensure that the agent identifies the target room by its unique properties (e.g. presence of appropriate objects in the room such as pan and knives for kitchen and bed for bedroom) instead of merely reaching there by luck. An episode is considered successful if both of the following two criteria are satisfied: (1) the agent is located inside the target room; (2) the agent consecutively sees a designated object category associated with that target room type for at least 2 time steps. We assume that an agent sees an object if there are at least $4 \\%$ of pixels in $X _ { t }$ belonging to that object. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the reward function, ideally two signals suffice to reflect the task requirement: (1) a collision penalty when hitting obstacles; and (2) a success reward when completing the task. However, these basic signals make it too difficult for an RL agent to learn, as the positive reward is too sparse. To provide additional supervision during training, we resort to an informative reward shaping: we compute the approximate shortest distance from the target room to each location in the house and adopt the difference of shortest distances between the agent’s movement as an additional reward signal. Note that our ultimate goal is to learn a policy that could generalize to unseen houses. Our strong reward shaping supervises the agent at training and is not available to the agent at test time. We empirically observe that stronger reward shaping leads to better performances on both training and testing. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            279
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 GATED-ATTENTION NETWORKS FOR MULTI-TARGET LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            297,
+            741,
+            315
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The RoomNav task can be considered as a multi-target learning problem: the policy needs to condition on both the input $s _ { t }$ and the target concept $I$ . For policy representations which incorporate the target $I$ , we propose two baseline models with a gated-attention architecture, similar to Dhingra et al. (2016) and Chaplot et al. (2017): a gated-CNN network for continuous actions and a gatedLSTM network for discrete actions. We train the gated-CNN policy using the deep deterministic policy gradient (DDPG) (Lillicrap et al., 2015), while the gated-LSTM policy is trained using the asynchronous advantage actor-critic algorithm (A3C) (Mnih et al., 2016). ",
+        "bbox": [
+            173,
+            330,
+            825,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a75289ae7bf516017b287610ca208e9db5d32947bd34b698e6fa707f328db54e.jpg",
+        "image_caption": [
+            "Figure 2: Overview of our proposed models. Bottom part demonstrates the gated-LSTM model for discrete action while the top part shows the gated-CNN model for continuous action. The “Gated Fusion” module denotes the gated-attention architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            440,
+            723,
+            628
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 DDPG WITH GATED-CNN POLICY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            703,
+            452,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1.1 DEEP DETERMINISTIC POLICY GRADIENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            729,
+            513,
+            743
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Suppose we have a deterministic policy $\\mu ( s _ { t } | \\boldsymbol { \\theta } )$ (actor) and the Q-function $Q ( s _ { t } , a | \\theta )$ (critic) both parametrized by $\\theta$ . DDPG optimizes the policy $\\mu ( s _ { t } | \\boldsymbol { \\theta } )$ by maximizing $\\begin{array} { r l r } { L _ { \\mu } ( \\theta ) } & { { } = } & { \\bar { \\mathbb { E } _ { s _ { t } } } \\left[ Q ( s _ { t } , \\mu ( s _ { t } | \\theta ) | \\theta ) \\right] } \\end{array}$ , and updates the $\\mathrm { Q }$ -function by minimizing $\\begin{array} { r l } { L _ { Q } ( \\theta ) } & { { } = } \\end{array}$ $\\mathbb { E } \\left[ ( Q ( s _ { t } , a _ { t } | \\theta ) - \\gamma Q ( s _ { t + 1 } , \\mu ( s _ { t + 1 } | \\theta ) | \\theta ) - r _ { t } ) ^ { 2 } \\right]$ . ",
+        "bbox": [
+            174,
+            752,
+            825,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, we use a shared network for both actor and critic with the final loss function $L _ { \\mathrm { D D P G } } ( \\theta ) =$ $- L _ { \\mu } ( \\theta ) + \\alpha _ { \\mathrm { D D P G } } L _ { Q } ( \\theta )$ , where $\\alpha _ { \\mathrm { D D P G } }$ is a constant balancing the two objectives. ",
+        "bbox": [
+            173,
+            827,
+            823,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1.2 GATED-CNN FOR CONTINUOUS POLICY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            871,
+            504,
+            886
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "State Encoding: Given state $s _ { t }$ , we first stack the most recent $k$ frames $\\begin{array} { r l } { X } & { { } = } \\end{array}$ $[ X _ { t } , X _ { t - 1 } , \\ldots , X _ { t - k + 1 } ]$ channel-wise and apply a convolutional neural network to derive an image representation $x ~ = ~ f _ { \\mathrm { c n n } } ( X | \\theta ) ~ \\in ~ \\mathbb { R } ^ { d _ { X } }$ . We convert the target $I$ into an embedding vector $\\dot { y ^ { \\cdot } } = \\bar { f } _ { \\mathrm { e m b e d } } ( I | \\theta ) \\in \\mathbb { R } ^ { d _ { I } }$ . Subsequently, we apply a fusion module $M ( x , y | \\theta )$ to derive the final encoding $h _ { s } = M ( x , y | \\theta )$ . ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            102,
+            825,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Gated-Attention for Feature Fusion: For the fusion module $M ( x , y | \\theta )$ , the straightforward version is concatenation, namely $M _ { \\mathrm { c a t } } ( x , y | \\cdot ) = [ x , y ]$ . In our case, $x$ is always a high-dimensional feature vector (i.e., image feature) while $y$ is a simple low-dimensional conditioning vector (e.g., instruction). Thus, simple concatenation may result in optimization difficulties. For this reason, we propose to use a gated-attention mechanism. Suppose $x \\in \\mathbb { R } ^ { d _ { x } }$ and $\\boldsymbol { y } \\in \\mathbb { R } ^ { d _ { \\boldsymbol { y } } }$ where $d _ { y } ~ < ~ d _ { x }$ . First, we transform $y$ to $y ^ { \\prime } \\in \\mathbb { R } ^ { d _ { X } }$ via an MLP, namely $y ^ { \\prime } ~ = ~ f _ { \\mathrm { m l p } } ( y | \\theta )$ , and then perform a Hadamard (pointwise) product between $x$ and sigmoid $( y ^ { \\prime } )$ , which leads to our final gated fusion module $M ( x , y | \\theta ) = x \\odot$ sigmoid $\\left( f _ { \\mathrm { m l p } } ( y | \\theta ) \\right)$ . This gated fusion module could also be interpreted as an attention mechanism over the feature vector which could help better shape the feature representation. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            292
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Policy Representation: For the policy, we apply a MLP layer on the state representation $h _ { s }$ , followed by a softmax operator (for bounded velocity) to produce the continuous action. Moreover, in order to produce a stochastic policy for both better exploration and higher robustness, we apply the Gumbel-Softmax trick (Jang et al., 2016), resulting in the final policy $\\mu ( s _ { t } | \\theta ) =$ Gumbel-Softmax ${ \\bf \\zeta } ^ { \\prime } f _ { \\mathrm { m l p } } ( h _ { s } | \\boldsymbol { \\theta } ) )$ . Note that since we add randomness to $\\mu ( s _ { t } | \\boldsymbol { \\theta } )$ , our DDPG formulation can also be interpreted as the SVG(0) algorithm (Heess et al., 2015). ",
+        "bbox": [
+            173,
+            300,
+            825,
+            385
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Q-function: The Q-function $Q ( s , a )$ conditions on both state $s$ and action $a$ . We again apply a gated fusion module to the feature vector $x$ and the action vector $a$ to derive a hidden representation $h _ { Q } = M ( x , a | \\theta )$ . We eventually apply another MLP to $h _ { Q }$ to produce the final value $Q ( s , a )$ . ",
+        "bbox": [
+            174,
+            390,
+            821,
+            434
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A model demonstration is shown in the top part of Fig. 2, where each block has its own parameters. ",
+        "bbox": [
+            176,
+            439,
+            821,
+            455
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 A3C WITH GATED-LSTM POLICY ",
+        "bbox": [
+            176,
+            476,
+            449,
+            491
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2.1 ASYNCHRONOUS ADVANTAGE ACTOR-CRITIC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            503,
+            539,
+            518
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Suppose we have a discrete policy $\\pi ( \\boldsymbol { a } ; \\boldsymbol { s } | \\boldsymbol { \\theta } )$ and a value function $v ( s | \\theta )$ . A3C optimizes the policy by minimizing the loss function $\\begin{array} { r } { L _ { \\mathrm { p g } } ( \\theta ) = - \\mathbb { E } _ { s _ { t } , a _ { t } , r _ { t } } \\left[ \\sum _ { t = 1 } ^ { T } ( R _ { t } - v ( s _ { t } ) ) \\log \\pi ( a _ { t } ; s _ { t } | \\theta ) \\right] } \\end{array}$ , where $R _ { t }$ is the discounted accumulative reward defined by $\\begin{array} { r } { R _ { t } = \\sum _ { i = 0 } ^ { T - t } \\gamma ^ { i } r _ { t + i } + v ( s _ { T + 1 } ) } \\end{array}$ . The value function is updated by minimizing the loss $L _ { v } ( \\theta ) = \\mathbb { E } _ { s _ { t } , r _ { t } } [ ( R _ { t } - v ( s _ { t } ) ) ^ { 2 } ]$ . ",
+        "bbox": [
+            174,
+            529,
+            825,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally the overall loss function for A3C is $L _ { \\mathrm { A 3 C } } ( \\theta ) = L _ { \\mathrm { p g } } ( \\theta ) + \\alpha _ { \\mathrm { A 3 C } } L _ { v } ( \\theta )$ where $\\alpha _ { \\mathrm { A } 3 \\mathrm { C } }$ is a constant coefficient. ",
+        "bbox": [
+            174,
+            606,
+            821,
+            636
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2.2 GATED-LSTM NETWORK FOR DISCRETE POLICY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            655,
+            566,
+            670
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "State Encoding: Given state $s _ { t }$ , we first apply a CNN module to extract image feature $x _ { t }$ for each input frame $X _ { t }$ . For the target, we apply a gated fusion module to derive a state representation $h _ { t } = { \\bar { M } } ( x _ { t } , I | \\theta )$ at each time step $t$ . Then, we concatenate $h _ { t }$ with the target $I$ and the result is fed into the LSTM module (Hochreiter & Schmidhuber, 1997) to obtain a sequence of LSTM outputs $\\{ o _ { t } \\} _ { t }$ , so that the LSTM module has direct access to the target other than the attended visual feature. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            752
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Policy and Value Function: For each time step $t$ , we concatenate the state vector $h _ { t }$ with the output of the LSTM $o _ { t }$ to obtain a joint hidden vector $h _ { \\mathrm { j o i n t } } = [ h _ { t } , o _ { t } ]$ . Then we apply two MLPs to $h _ { \\mathrm { j o i n t } }$ to obtain the policy distribution $\\pi ( a ; s _ { t } | \\theta )$ as well as the value function $v ( s _ { t } | \\theta )$ . ",
+        "bbox": [
+            174,
+            758,
+            825,
+            801
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A visualization of the model is in the bottom part of Fig. 2. The parameters of CNN modules are shared across time. ",
+        "bbox": [
+            176,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            861,
+            418,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We report experimental results for our models on the task of RoomNav. We first compare models with discrete and continuous action spaces with different input modalities. Then we explain our observations and show that techniques targeting different levels of augmentation improve the success rate of navigation in the test set. Moreover, these techniques are complementary to each other. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Setup. We train our baseline models on multiple experimental settings. We use two training datasets. The small set $\\mathcal { E } _ { \\mathrm { s m a l l } }$ contains 20 houses and the large set $\\mathcal { E } _ { \\mathrm { l a r g e } }$ contains 200 houses. A held-out dataset ${ \\mathcal { E } } _ { \\mathrm { t e s t } }$ is used for test, which contains 50 houses. ",
+        "bbox": [
+            176,
+            138,
+            823,
+            180
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We mainly focus on success rate on the test set, i.e, how the agent generalizes. For reference, we also report the training performance. The agent fails if it failed to find the concept within 100 steps1. All success rate evaluations use a fixed random seed for a fair comparison. For each model, we run 2000 evaluation episodes on $\\mathcal { E } _ { \\mathrm { s m a l l } }$ and ${ \\mathcal { E } } _ { \\mathrm { t e s t } }$ , and 5000 evaluation episodes on $\\mathcal { E } _ { \\mathrm { l a r g e } }$ to measure overall success rates. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use gated-CNN and gated-LSTM to denote the networks with gated-attention, and concat-CNN and concat-LSTM for models with simple concatenation. We also experiment with different visual signals to the agents, including RGB image (RGB Only), RGB image with depth information $( \\mathrm { R G B + D e p t h } _ { \\it . }$ ) and semantics mask with depth information (Mask+Depth). The input image resolution is $1 2 0 \\times 9 0$ to preserve image details. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            334
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "During each simulated episode, we randomly select a house from the environment set and randomly pick an applicable target from the house to instruct the agent. During training, we add an entropy bonus term for both models2 in addition to the original loss function. For evaluation, we keep the final model for DDPG due to its stable learning curve, while for A3C, we take the model with the highest training success rate. We use Pytorch (Paszke et al., 2017) and Adam (Kingma & Ba, 2014). See Appendix for more experiment details. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            425
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a7e99e411b4b1ed123690d80271e22c9fd61e30671c238b5ca0408323ae7085.jpg",
+        "image_caption": [
+            "Figure 3: Overall performance of various models trained on (a) ${ \\mathcal { E } } _ { \\mathrm { s m a l l } }$ (20 houses) with different input signals: RGB Only, RGB $+$ Depth and Mask+Depth; (b) $\\mathcal { E } _ { \\mathrm { l a r g e } }$ (200 houses) with input signals: RGB $+$ Depth and Mask $^ +$ Depth. In each group, the bars from left to right correspond to gated-LSTM, concat-LSTM, gated-CNN, concat-CNN and random policy respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            446,
+            810,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/831f27bb070ec5c13732af2eab2e624097384a20c5e000ea1853f551e7d1aa7d.jpg",
+        "image_caption": [
+            "Figure 4: Pixel-level Augmentation: Test performances of various models trained with different input signals, including RGB $^ +$ Depth on $\\mathcal { E } _ { \\mathrm { s m a l l } }$ , RGB with Domain Randomization on ${ \\mathcal { E } } _ { \\mathrm { s m a l l } }$ , Mask+Depth on $\\mathcal { E } _ { \\mathrm { s m a l l } }$ , Mask $^ +$ Depth on $\\mathcal { E } _ { \\mathrm { l a r g e } }$ . In each group, the bars represent gated-LSTM, concat-LSTM, gated-CNN and concat-CNN from left to right. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            318,
+            103,
+            679,
+            260
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.1 BASELINES: MODELS WITH RGB SIGNALS ON $\\mathcal { E } _ { \\mathrm { S M A L L } }$ ",
+        "bbox": [
+            174,
+            363,
+            583,
+            378
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As shown in the bottom part of Fig. 3a, on $\\mathcal { E } _ { \\mathrm { s m a l l } }$ , the test success rate for models trained on RGB features is unsatisfactory. We observe obvious overfitting behavior: the test performance is drastically worse than training. In particular, the gated-LSTM models achieve even lower success rate than concat-LSTM models, despite the fact that they have much better training performance. In this case, the learning algorithm picks up spurious color patterns in the environments as the guidance towards the goal, which is inapplicable to unseen environments. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            476
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In both training and test, we find that depth information improves the performance thus we use it in the following experiments and omit Depth for conciseness. ",
+        "bbox": [
+            174,
+            483,
+            820,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 TECHNIQUES FOR DIFFERENT LEVELS OF AUGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            532,
+            620,
+            546
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Augmentation is a standard technique to improve generalization. However, for complicated tasks, augmentation needs to be taken care at different levels. In this section, we categorize augmentation techniques into 3 levels: (1) pixel-level augmentation: changing the colors and textures; (2) tasklevel augmentation: joint learning for multiple tasks; (3) scene-level augmentation: training on more environments. We analyze the generalization performance with all techniques and conclude that these techniques are complementary and that the best test performance is obtained by combining these techniques together. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pixel-level Augmentation: We use domain randomization (Tobin et al., 2017), by reassigning each object in the scene a random color but keeping the textures. This breaks the spurious color correlations and pushes the agent to learn a better representation. ",
+        "bbox": [
+            176,
+            665,
+            821,
+            707
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We explore domain randomization by generating an additional 180 houses with random object coloring from $\\mathcal { E } _ { \\mathrm { s m a l l } }$ , which leads to a total of 200 houses. We evaluate the test success rate of various models under different training settings, e.g., RGB, RGB with domain randomization (D.R.) or mask signal. The results are shown in Fig. 4. Interestingly, we noticed that domain randomization yields very similar performance as mask signal on $\\mathcal { E } _ { \\mathrm { s m a l l } }$ . ",
+        "bbox": [
+            174,
+            714,
+            823,
+            785
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One shortcoming of domain randomization is that it requires substantially more training samples and thus suffers from high sample complexity. Thanks to the rich labels in House3D, we instead could use segmentation mask as an input feature plane, which encodes semantic information and is independent of the object color. This helps train generalizable agent with much fewer training samples. On the other hand, an agent trained with domain randomization can operate with RGB input only, without segmentation mask output from a vision subsystem. In the current context, we simply assume adopting segmentation mask input as the technique for pixel-level augmentation. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Task-level Augmentation: We explore task-level augmentation by adding related auxiliary targets during training (Fig. 5). Specifically, in addition to the 5 room types as auxiliary targets, we selected ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/47a1cf4d0faa2df7ea6030a18f3c8112a74d0651fb7a73afe7ce8a6d479d18e6.jpg",
+        "image_caption": [
+            "Figure 5: Task-Level Augmentation: Test performances of LSTM models trained with and without auxiliary targets on both ${ \\mathcal { E } } _ { \\mathrm { s m a l l } }$ and $\\mathcal { E } _ { \\mathrm { l a r g e } }$ . In each group, the bars represent gated-LSTM $+ \\mathrm { \\ R G B }$ , concat-LSTM $^ +$ RGB, gated-LSTM $^ +$ Mask and concat-LSTM $^ +$ Mask from left to right. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            316,
+            102,
+            679,
+            263
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "15 object concepts (e.g., chair, table, cabinet, etc. See a full list of object concepts in appendix.).   \nWe train A3C agents with different input signals on ${ \\mathcal { E } } _ { \\mathrm { s m a l l } }$ and evaluate their test performances. ",
+        "bbox": [
+            174,
+            351,
+            823,
+            378
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We found that auxiliary targets significantly reduce overfitting and increases the generalizability of models with RGB inputs. Because of this effect, gated attention model, which has high model capacity, becomes much more effective on RGB signal when trained with more targets. On the other hand, with mask input, the agent does not need to learn to differentiate the objects, therefore auxiliary targets do not help that much for more complicated models like gated attention models. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            455
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scene-level Augmentation: We could further boost the generalization performance by augmenting the training set with more diverse set of houses, i.e, $\\mathcal { E } _ { \\mathrm { l a r g e } }$ that contain 200 different houses. This is also a benefit from House3D. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            505
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For visual signals, we focus on feature combinations like “RGB $^ +$ Depth” and “M $\\mathrm { a s k + D e }$ pth”. Note that for training efficiency, segmentation mask is a surrogate feature to approximate ${ } ^ { 6 6 } { \\mathrm { R G B } } +$ domain randomization” as it shows similar results in the small set. Both train and test results are summarized in Fig. 3b. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "On a semantically diverse dataset $\\mathcal { E } _ { \\mathrm { l a r g e } }$ , the overfitting issue is largely resolved. We see drops in the training performance and improve on the generalization. After training on a large number of environments, every model now has a much smaller gap between its training and test performance. This is in particularly true for the models using RGB signal, which suffers from overfitting issues on ${ \\mathcal { E } } _ { \\mathrm { s m a l l } }$ . Notably, on large dataset, LSTM models generally perform better than CNN models due to its high model capacity. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            659
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In addition, similar behavior was also observed during our experiments with techniques for pixellevel augmentation (Fig. 4) and task-level augmentation (Fig. 5). In all the experiments, all the models consistently achieves better generalization performances when trained on $\\mathcal { E } _ { \\mathrm { l a r g e } }$ , which again emphasizes the benefits of House3D. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            720
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The overall best success rate is achieved by gated-attention architecture with semantic signals. It is better than both RGB channels by over $8 \\%$ and the counterpart trained on ${ \\mathcal { E } } _ { \\mathrm { s m a l l } }$ in terms of generalization metric. This means that pixel-level augmentation (e.g., domain randomization and/or segmentation mask) and scene-level augmentation (e.g., using diverse dataset) can improve the performance. Moreover, their effects are complementary. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A diverse environment like $\\mathcal { E } _ { \\mathrm { l a r g e } }$ also enables the model of larger capacity to work better. For example, LSTMs considerably outperform the simpler reactive models, i.e., CNNs with recent 5 frames as state input. We believe this is due to the larger scale and the high complexity of the training set, which makes it almost impossible for an agent to “remember” the optimal actions for every scenario. Instead, an agent needs to develop high-level abstractions (e.g., high-level exploration strategy, memory, etc). These are helpful induction biases that could lead to a more generalizable model. ",
+        "bbox": [
+            173,
+            805,
+            825,
+            901
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we also analyze the detailed success rate with respect to each target room in appendix. ",
+        "bbox": [
+            171,
+            909,
+            784,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new environment, House3D, which contains 45K houses with a diverse set of objects and natural layouts resembling the real-world. ",
+        "bbox": [
+            173,
+            133,
+            821,
+            161
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In House3D, we teach an agent to accomplish semantic goals. We define RoomNav, in which an agent needs to understand a given semantic concept, interpret the comprehensive visual signal, navigate to the target, and most importantly, succeed in a new unseen environment. We note that generalization to unseen environments was rarely studied in previous works. ",
+        "bbox": [
+            174,
+            169,
+            825,
+            224
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "To this end, we quantify the effect of various levels of augmentations, all facilitated by House3D by the means of domain randomization, multi-target training and the diversity of the environment. We resort to well established RL techniques equipped with gating to encode the task at hand. The final performance on unseen environments is much higher than baseline methods by over $8 \\%$ . We hope House3D as well as our training techniques can benefit the whole RL community for building generalizable agents. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            315
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            335,
+            285,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Andreas, Dan Klein, and Sergey Levine. Modular multitask reinforcement learning with policy sketches. arXiv preprint arXiv:1611.01796, 2016.   \nIro Armeni, Ozan Sener, Amir R. Zamir, Helen Jiang, Ioannis Brilakis, Martin Fischer, and Silvio Savarese. 3D semantic parsing of large-scale indoor spaces. CVPR, 2016.   \nCharles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler, Andrew ¨ Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, et al. Deepmind lab. ´ arXiv preprint arXiv:1612.03801, 2016.   \nMarc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 47:253–279, 2013.   \nGreg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. OpenAI gym. arXiv preprint arXiv:1606.01540, 2016.   \nSimon Brodeur, Ethan Perez, Ankesh Anand, Florian Golemo, Luca Celotti, Florian Strub Strub, Jean Rouat, Hugo Larochelle, and Aaron Courville Courville. HoME: a household multimodal environment. arXiv 1711.11017, 2017.   \nAngel Chang, Angela Dai, Thomas Funkhouser, Maciej Halber, Matthias Niessner, Manolis Savva, Shuran Song, Andy Zeng, and Yinda Zhang. Matterport3d: Learning from RGB-D data in indoor environments. International Conference on 3D Vision (3DV), 2017.   \nDevendra Singh Chaplot, Kanthashree Mysore Sathyendra, Rama Kumar Pasumarthi, Dheeraj Rajagopal, and Ruslan Salakhutdinov. Gated-attention architectures for task-oriented language grounding. arXiv preprint arXiv:1706.07230, 2017.   \nPaul Christiano, Zain Shah, Igor Mordatch, Jonas Schneider, Trevor Blackwell, Joshua Tobin, Pieter Abbeel, and Wojciech Zaremba. Transfer from simulation to real world through learning deep inverse dynamics model. arXiv preprint arXiv:1610.03518, 2016.   \nAbhishek Das, Samyak Datta, Georgia Gkioxari, Stefan Lee, Devi Parikh, and Dhruv Batra. Embodied Question Answering. arXiv preprint arXiv:1711.11543, 2017a.   \nAbhishek Das, Satwik Kottur, Stefan Lee, Jos M.F. Moura, and Dhruv Batra. Learning cooperative visual dialog agents with deep reinforcement learning. ICCV, 2017b.   \nBhuwan Dhingra, Hanxiao Liu, Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Gated-attention readers for text comprehension. arXiv preprint arXiv:1606.01549, 2016.   \nGandhi Dhiraj, Pinto Lerrel, and Gupta Abhinav. Learning to fly by crashing. IROS, 2017.   \nYan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel. RL2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016.   \nChelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. arXiv preprint arXiv:1703.03400, 2017a. ",
+        "bbox": [
+            171,
+            356,
+            826,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Tianhe Yu, Justin Fu, Pieter Abbeel, and Sergey Levine. Generalizing skills with semi-supervised reinforcement learning. ICLR, 2017b. ",
+        "bbox": [
+            173,
+            104,
+            823,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dieter Fox, Sebastian Thrun, and Wolfram Burgard. Probabilistic Robotics. MIT press, 2005. ",
+        "bbox": [
+            174,
+            138,
+            728,
+            155
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Saurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. CVPR, 2017. ",
+        "bbox": [
+            173,
+            162,
+            823,
+            189
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pp. 2944–2952, 2015. ",
+        "bbox": [
+            173,
+            199,
+            823,
+            238
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Arka Pal, Andrei A Rusu, Loic Matthey, Christopher P Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. arXiv preprint arXiv:1707.08475, 2017. ",
+        "bbox": [
+            173,
+            247,
+            823,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):1735–1780, 1997. ",
+        "bbox": [
+            171,
+            295,
+            823,
+            321
+        ],
+        "page_idx": 11
+    },
+    {
+        "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. arXiv preprint arXiv:1611.05397, 2016. ",
+        "bbox": [
+            171,
+            330,
+            823,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with Gumbel-Softmax. arXiv preprint arXiv:1611.01144, 2016. ",
+        "bbox": [
+            173,
+            378,
+            823,
+            406
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew Johnson, Katja Hofmann, Tim Hutton, and David Bignell. The Malmo platform for artificial intelligence experimentation. In IJCAI, pp. 4246–4247, 2016. ",
+        "bbox": [
+            173,
+            415,
+            823,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Simon Green Fumin Wang Ryan Faulkner Hubert Soyer David Szepesvari Wojciech Marian Czarnecki Max Jaderberg Denis Teplyashin Marcus Wainwright Chris Apps Demis Hassabis Karl Moritz Hermann, Felix Hill and PhilBlunsom. Grounded language learning in a simulated 3d world. In arXiv 1706.06551. 2017. ",
+        "bbox": [
+            173,
+            452,
+            825,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michał Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. Vizdoom: A ´ doom-based AI research platform for visual reinforcement learning. In Computational Intelligence and Games (CIG), 2016 IEEE Conference on, pp. 1–8. IEEE, 2016. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            551
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            560,
+            823,
+            587
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John J. Leonard and Hugh F. Durrant-Whyte. Directed Sonar Sensing for Mobile Robot Navigation. Kluwer Academic Publishers, Norwell, MA, USA, 1992. ISBN 0792392426. ",
+        "bbox": [
+            173,
+            595,
+            823,
+            623
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. JMLR, 2016. ",
+        "bbox": [
+            174,
+            632,
+            823,
+            659
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            173,
+            667,
+            823,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. arXiv preprint arXiv:1706.02275, 2017. ",
+        "bbox": [
+            171,
+            715,
+            823,
+            743
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John McCormac, Ankur Handa, Stefan Leutenegger, and Andrew J Davison. SceneNet RGB-D: Can 5m synthetic images beat generic ImageNet pre-training on indoor segmentation? In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2678–2687, 2017. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            791
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander H Miller, Will Feng, Adam Fisch, Jiasen Lu, Dhruv Batra, Antoine Bordes, Devi Parikh, and Jason Weston. Parlai: A dialog research software platform. arXiv preprint arXiv:1705.06476, 2017. ",
+        "bbox": [
+            173,
+            800,
+            823,
+            828
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andy Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, et al. Learning to navigate in complex environments. arXiv preprint arXiv:1611.03673, 2016. ",
+        "bbox": [
+            173,
+            837,
+            825,
+            876
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            174,
+            885,
+            825,
+            924
+        ],
+        "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 International Conference on Machine Learning, pp. 1928–1937, 2016.   \nKarthik Narasimhan, Regina Barzilay, and Tommi Jaakkola. Deep transfer in reinforcement learning by language grounding. arXiv preprint arXiv:1708.00133, 2017.   \nJunhyuk Oh, Satinder Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization with multi-task deep reinforcement learning. arXiv preprint arXiv:1706.05064, 2017.   \nEmilio Parisotto and Ruslan Salakhutdinov. Neural map: Structured memory for deep reinforcement learning. arXiv preprint arXiv:1702.08360, 2017.   \nAdam Paszke, Sam Gross, and Soumith Chintala. Pytorch, 2017. URL http://pytorch.org/.   \nDeepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by selfsupervised prediction. ICML, 2017.   \nAndrei A Rusu, Matej Vecerik, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell. Sim-to-real ¨ robot learning from pixels with progressive nets. arXiv preprint arXiv:1610.04286, 2016.   \nFereshteh Sadeghi and Sergey Levine. CAD2RL: Real single-image flight without a single real image. RSS, 2017.   \nManolis Savva, Angel X. Chang, Alexey Dosovitskiy, Thomas Funkhouser, and Vladlen Koltun. MINOS: Multimodal indoor simulator for navigation in complex environments. arXiv:1712.03931, 2017.   \nTianlin Shi, Andrej Karpathy, Linxi Fan, Jonathan Hernandez, and Percy Liang. World of Bits: An opendomain platform for web-based agents. In International Conference on Machine Learning, pp. 3135–3144, 2017.   \nDavid Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.   \nShuran Song, Fisher Yu, Andy Zeng, Angel X Chang, Manolis Savva, and Thomas Funkhouser. Semantic scene completion from a single depth image. CVPR, 2017.   \nGabriel Synnaeve, Nantas Nardelli, Alex Auvolat, Soumith Chintala, Timothee Lacroix, Zeming Lin, Florian ´ Richoux, and Nicolas Usunier. Torchcraft: a library for machine learning research on real-time strategy games. arXiv preprint arXiv:1611.00625, 2016.   \nLei Tai and Ming Liu. Towards cognitive exploration through deep reinforcement learning for mobile robots. arXiv preprint arXiv:1610.01733, 2016.   \nAviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. In Advances in Neural Information Processing Systems, pp. 2154–2162, 2016.   \nYuandong Tian, Qucheng Gong, Wenling Shang, Yuxin Wu, and Larry Zitnick. ELF: An extensive, lightweight and flexible research platform for real-time strategy games. arXiv preprint arXiv:1707.01067, 2017.   \nJosh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. arXiv preprint arXiv:1703.06907, 2017.   \nOriol Vinyals, Timo Ewalds, Sergey Bartunov, Petko Georgiev, Alexander Sasha Vezhnevets, Michelle Yeo, Alireza Makhzani, Heinrich Kuttler, John Agapiou, Julian Schrittwieser, et al. Starcraft ii: A new challenge ¨ for reinforcement learning. arXiv preprint arXiv:1708.04782, 2017.   \nYuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J Lim, Abhinav Gupta, Li Fei-Fei, and Ali Farhadi. Targetdriven visual navigation in indoor scenes using deep reinforcement learning. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 3357–3364. IEEE, 2017. ",
+        "bbox": [
+            169,
+            36,
+            828,
+            853
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/9fd2307c84ab94372a1826722d7aae2564763752b21e3a399ee2fb0285abbe82.jpg",
+        "table_caption": [
+            "Table 2: Statistics of the selected environment sets for RoomNav. RoomType% denotes the percentage of houses containing at least one target room of type RoomType. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>3</td><td>avg.#targets</td><td>kitchen%</td><td>dining room %</td><td> living room%</td><td>bedroom%</td><td>bathroom%</td></tr><tr><td>Esmall</td><td>20</td><td>3.9</td><td>0.95</td><td>0.60</td><td>0.60</td><td>0.95</td><td>0.80</td></tr><tr><td>Elarge</td><td>200</td><td>3.7</td><td>1.00</td><td>0.35</td><td>0.63</td><td>0.94</td><td>0.80</td></tr><tr><td>Etest</td><td>50</td><td>3.7</td><td>1.00</td><td>0.48</td><td>0.58</td><td>0.94</td><td>0.70</td></tr></table>",
+        "bbox": [
+            174,
+            101,
+            821,
+            159
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/309cdf910eb252ffc75515ac3c2106a6fc7046292cc730d4a1a67601bccbda28.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>test succ.</td><td>kitchen%</td><td>dining room %</td><td>living room%</td><td>bedroom%</td><td>bathroom%</td></tr><tr><td> gated-LSTM</td><td>35.8</td><td>37.9</td><td>50.4</td><td>48.0</td><td>33.5</td><td>21.2</td></tr><tr><td>gated-CNN</td><td>29.7</td><td>31.6</td><td>42.5</td><td>54.3</td><td>27.6</td><td>17.4</td></tr></table>",
+        "bbox": [
+            178,
+            214,
+            813,
+            258
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Detailed test success rates for gated-CNN model and gated-LSTM model with “Mask+Depth” as input signal across different instruction concepts. ",
+        "bbox": [
+            173,
+            268,
+            821,
+            297
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A ROOMNAV TASK DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            325,
+            428,
+            342
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 STATISTICS OF SELECTED HOUSE SETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            358,
+            491,
+            372
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We show the statistics of the selected three set of houses in Table 2. ",
+        "bbox": [
+            174,
+            383,
+            571,
+            397
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In addition to these 5 houses, we also pick another 15 object concepts in our mid-level generalization experiment as auxiliary targets. The object concepts are: shower, sofa, toilet, bed, plant, television, table-and-chair, chair, table, kitchen-set, bathtub, vehicle, pool, kitchen-cabinet, curtain. ",
+        "bbox": [
+            174,
+            404,
+            823,
+            444
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Detailed Specifications: The location information of an agent can be represented by 4 real numbers: the 3D location $( x , y , z )$ and the rotation degree $\\rho$ of its first person view sensor, which indicates the front direction of the agent. Note that in RoomNav, the agent is not allowed to change its height $z$ , hence the overall degree of freedom is 3. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            501
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "An action can be in the form of a triple $\\boldsymbol { a } = ( \\delta _ { x } , \\delta _ { y } , \\delta _ { \\rho } )$ . After taking the action $a$ , the agent will move to a new 3D location $( x + \\delta _ { x } , y + \\delta _ { y } , z )$ with a new rotation $\\rho + \\delta _ { \\rho }$ . The physics in House3D will detect collisions with objects under action $a$ and in RoomNav, the agent will remain still in case of a collision. We also restrict the velocity of the agent such that $| \\delta _ { x } | , | \\delta _ { y } | \\leq 0 . 5$ and $| \\delta _ { \\rho } | \\leq 3 0$ to ensure a smooth movement. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            559
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Continuous Action: A continuous action $a$ consists of two parts $a = [ m , r ]$ where $m = ( m _ { 1 } , \\dots , m _ { 4 } )$ is for movement and $r = ( r _ { 1 } , r _ { 2 } )$ is for rotation. Since the velocity of the agent should be bounded, we require $m$ , $r$ to be a valid probability distribution. Suppose the original location of robot is $( x , y , z )$ and the angle of camera is $\\rho$ , then after executing $a$ , the new 3D location will be $( x + ( m _ { 1 } - m _ { 2 } ) * 0 . 5 , y + ( m _ { 3 } - m _ { 4 } ) * 0 . 5 , z )$ and the new angle is $\\rho + \\left( r _ { 1 } - r _ { 2 } \\right) * 3 0$ . ",
+        "bbox": [
+            174,
+            565,
+            825,
+            630
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Discrete Action: We define 12 different action triples in the form of $a _ { i } = ( \\delta _ { x } , \\delta _ { y } , \\delta _ { \\rho } )$ satisfying the velocity constraints. There are 8 actions for movement: left, forward, right with two scales and two diagonal directions; and 4 actions for rotation: clockwise and counter-clockwise with two scales. In the discrete action setting, we do not allow the agent to move and rotate simultaneously. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            688
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Reward Details: In addition to the reward shaping of difference of shortest distances, we have the following rewards. When hitting an obstacle, the agent receives a penalty of 0.3. In the case of success, the winning reward is $+ 1 0$ . In order to encourage exploration (or to prevent eternal rotation), we add a time penalty of 0.1 to the agent for each time step outside the target room. Note that since we restrict the velocity of the agent, the difference of shortest path after an action will be no more than $0 . 5 \\times \\sqrt { 2 } \\approx 0 . 7$ . ",
+        "bbox": [
+            173,
+            694,
+            825,
+            760
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            781,
+            398,
+            797
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B.1 NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            411,
+            828
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We apply a batch normalization layer after each layer in the CNN module. The activation function used is ReLU. The embedding dimension of concept instruction is 25. ",
+        "bbox": [
+            173,
+            839,
+            823,
+            866
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Gated-CNN: In the CNN part, we have 4 convolution layers of 64, 64, 128, 128 channels perspective and with kernel size 5 and stride 2, as well as a fully-connected layer of 512 units. We use a linear layer to transform the concept embedding to a 512-dimension vector for gated fusion. The MLP for policy has two hidden layers of 128 and 64 units, and the MLP for Q-function has a single hidden layer of 64 units. ",
+        "bbox": [
+            174,
+            872,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Gated-LSTM: In the CNN module, we have 4 convolution layers of 64, 64, 128, 128 channels each and with kernel size 5 and stride 2, as well as a fully-connected layer of 256 units. We use a linear layer to convert the concept embedding to a 256-dimension vector. The LSTM module has 256 hidden dimensions. The MLP module for policy contains two layers of 128 and 64 hidden units, and the MLP for value function has two hidden layers of 64 and 32 units. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            167
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.2 TRAINING PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            184,
+            387,
+            199
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We normalize each channel of the input frame to $[ 0 , 1 ]$ before feeding it into the neural network. Each of the training procedures includes a weight decay of $1 0 ^ { \\div 5 }$ and a discounted factor $\\gamma = 0 . 9 5$ . ",
+        "bbox": [
+            176,
+            209,
+            821,
+            236
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "DDPG: We stack $k = 5$ recent frames and use learning rate $1 0 ^ { 4 }$ with batch size 128. We choose $\\alpha _ { \\mathrm { D D P G } } = 1 0 0$ for all the settings except for the case with input signal of $\\mathrm { \\mathrm { } ^ { 6 6 } R G B + I }$ Depth” on $\\mathcal { E } _ { \\mathrm { l a r g e } }$ , where we choose $\\alpha _ { \\mathrm { D D P G } } =$ 10. We use an entropy bonus term with coefficient 0.001 on $\\mathcal { E } _ { \\mathrm { s m a l l } }$ and 0.01 on $\\mathcal { E } _ { \\mathrm { l a r g e } }$ . We use exponential average to update the target network with rate 0.001. A training update is performed every 10 time steps. The replay buffer size is $7 \\times \\mathrm { \\overline { { 1 0 } } ^ { 5 } }$ . We run training for 80000 episodes in all. We use a linear exploration strategy in the first 30000 episodes. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            319
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A3C: We clip the reward to the range $[ - 1 , 1 ]$ and use a learning rate $1 e - 3$ with batch size 64. We launch 120 processes on ${ \\mathcal { E } } _ { \\mathrm { s m a l l } }$ and 200 on $\\mathcal { E } _ { \\mathrm { l a r g e } }$ . During training we estimate the discounted accumulative rewards and back-propagate through time for every 30 time steps unrolled. We perform a gradient clipping of 1.0 and decay the learning rate by a factor of 1.5 when the difference of KL-divergence becomes larger than 0.01. For training on $\\mathcal { E } _ { \\mathrm { s m a l l } }$ , we use a entropy bonus term with coefficient 0.1; while on $\\mathcal { E } _ { \\mathrm { l a r g e } }$ , the coefficient is 0.05. αA3C is 1.0. We perform $1 0 ^ { 5 }$ training updates and keep the best model with the highest training success rate. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            401
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.3 GENERALIZATION OVER DIFFERENT CONCEPTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            417,
+            544,
+            431
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We illustrate in Table 3 the detailed test success rates of our models trained on ${ \\mathcal { E } } _ { \\operatorname { t r a i n } }$ with respect to each of the 5 concepts. Note that both models have similar behaviour across concepts. In particular, “dining room” and “living room” are the easiest while “bathroom” is the hardest. We suspect that this is because dining room and living room are often with large room space and have the best connectivity to other places. By contrast, bathroom is often very small and harder to find in big houses. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            507
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we also experiment with adding auxiliary tasks of predicting the current room type during training. We found this does not help the training performance nor the test performance. We believe it is because our reward shaping has already provided strong supervision signals. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            553
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.4 AVERAGE STEPS TOWARDS SUCCESS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            569,
+            468,
+            582
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We also measure the number of steps required for an agent in RoomNav. For all the successful episodes, we evaluate the averaged number of steps towards the final target. The numbers are shown in Table 4. A random agent can only succeed when it’s initially spawned very close to the target, and therefore have very small number of steps towards target. Our trained agents, on the other hand, can explore in the environment and reach the target after resonable number of steps. Generally, our DDPG models takes fewer steps than our A3C models thanks to their continuous action space. But in all the settings, the number of steps required for a success is still far less than 100, namely the horizon length. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            683
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/d10b8d70ce3ff58461a346f6bbf3f74029f456edca8ddc8f88623c5ccc7cac13.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>random</td><td>concat-LSTM</td><td>gated-LSTM</td><td>concat-CNN</td><td>gated-CNN</td></tr><tr><td colspan=\"6\">Avg. #steps towards targets on &amp;small with different input signals</td></tr><tr><td>RGB+Depth (train)</td><td>14.2</td><td>35.9</td><td>41.0</td><td>31.7</td><td>33.8</td></tr><tr><td>RGB+Depth (test)</td><td>13.3</td><td>27.1</td><td>29.8</td><td>26.1</td><td>25.3</td></tr><tr><td>Mask+Depth (train)</td><td>14.2</td><td>38.4</td><td>40.9</td><td>34.9</td><td>36.6</td></tr><tr><td>Mask+Depth (test)</td><td>13.3</td><td>31.9</td><td>34.3</td><td>26.2</td><td>30.4</td></tr><tr><td colspan=\"6\">Avg. #steps towards targets on Elarge with different input signals</td></tr><tr><td>RGB+Depth (train)</td><td>16.0</td><td>36.4</td><td>35.6</td><td>31.0</td><td>32.4</td></tr><tr><td>RGB+Depth (test)</td><td>13.3</td><td>34.0</td><td>33.8</td><td>24.4</td><td>25.7</td></tr><tr><td>Mask+Depth (train)</td><td>16.0</td><td>40.1</td><td>38.8</td><td>34.6</td><td>36.2</td></tr><tr><td>Mask+Depth (test)</td><td>13.3</td><td>34.8</td><td>34.3</td><td>30.6</td><td>30.9</td></tr></table>",
+        "bbox": [
+            181,
+            694,
+            816,
+            857
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Averaged number of steps towards the target in all success trials for all the evaluated models with various input signals and different environments. ",
+        "bbox": [
+            169,
+            867,
+            825,
+            895
+        ],
+        "page_idx": 14
+    }
+]

parse/train/s95BePNvykX/s95BePNvykX.md

@@ -0,0 +1,255 @@
+# Video Instance Segmentation using Inter-Frame Communication Transformers
+
+Sukjun Hwang1 Miran Heo1 Seoung Wug Oh2 Seon Joo Kim1 1Yonsei University 2Adobe Research {sj.hwang, miran, seonjookim}@yonsei.ac.kr seoh@adobe.com
+
+# Abstract
+
+We propose a novel end-to-end solution for video instance segmentation (VIS) based on transformers. Recently, the per-clip pipeline shows superior performance over per-frame methods leveraging richer information from multiple frames. However, previous per-clip models require heavy computation and memory usage to achieve frame-to-frame communications, limiting practicality. In this work, we propose Inter-frame Communication Transformers (IFC), which significantly reduces the overhead for information-passing between frames by efficiently encoding the context within the input clip. Specifically, we propose to utilize concise memory tokens as a means of conveying information as well as summarizing each frame scene. The features of each frame are enriched and correlated with other frames through exchange of information between the precisely encoded memory tokens. We validate our method on the latest benchmark sets and achieved state-of-the-art performance (AP 42.6 on YouTube-VIS 2019 val set using the offline inference) while having a considerably fast runtime (89.4 FPS). Our method can also be applied to near-online inference for processing a video in real-time with only a small delay. The code is available at https://github.com/sukjunhwang/IFC.
+
+# 1 Introduction
+
+With the growing interest toward the video domain in computer vision, the task of video instance segmentation (VIS) is emerging [1]. Most of the current approaches [1, 2, 3, 4] extend image instance segmentation models [5, 6, 7, 8] and take frame-wise inputs. These per-frame methods extend the concept of temporal tracking by matching frame-wise predictions of high similarities. The models can be easily customized to real-world applications as they run in an online [9] fashion, but they show limitations in dealing with occlusions and motion blur that are common in videos.
+
+On the contrary, per-clip models are designed to overcome such challenges by incorporating multiple frames while sacrificing the efficiency. Previous per-clip approaches [10, 11, 12] aggregate information within a clip to generate instance-specific features. As the features are generated per instance, the number of instances in addition to the number of frames has a significant impact on the overall computation. Recently proposed VisTR [11] adapted DETR [13] to the VIS task and reduced the inference time by inserting the entire video, not a clip, to its offline end-to-end network. However, its full self-attention transformers [14] over the space-time inputs involve explosive computations and memories. In this work, we raise the following question: can a per-clip method be efficient while attaining great accuracy?
+
+To achieve our goal, we introduce Inter-frame Communication Transformers (IFC) to greatly reduce the computations of the full space-time transformers. Similar to recent works [15, 16, 17] that alleviate the explosive computational growth inherent in attention-based models [14, 18], IFC takes a decomposition strategy utilizing two transformers. The first transformer (Encode-Receive, $\mathcal { E }$ ) encodes each frame independently. To exchange the information between frames, the second transformer (Gather-Communicate, $\mathcal { G }$ ) executes attention between a small number of memory tokens that hold concise information of the clip. The memory tokens are utilized to store the overall context of the clip, for example “a hand over a lizard” in Fig. 1. The concise information assists detecting the lizard that is largely occluded by the hand in the first frame, without employing an expensive pixel-level attention over space and time. The memory tokens are only in charge of the communications between frames, and the features of each frame are enriched and correlated through the memory tokens.
+
+We further reduce overheads while taking advantage of per-clip pipelines by concisely representing each instance with a unique convolutional weight [7]. Despite the changes of appearances at different frames, the instances of the same identity share commonalities because the frames originated from the same source video. Therefore, we can effectively capture instance-specific characteristics in a clip with dynamically generated convolutional weights. In companion with the segmentation, we track instances by uniformly applying the weights to all frames in a clip. Moreover, all executions of our spatial decoder are instance-agnostic except for the final layer which applies instance-specific weights. Accordingly, our model is highly efficient and also suitable for scenes with numerous instances.
+
+In addition to the efficient modeling, we provide optimizations and an instance tracking algorithm that are designed to be VIS-centric. By the definition of $\mathsf { A P } ^ { \mathtt { V I S } }$ , the VIS task [1] aims to maximize the objective similarity: space-time mask IoU. Inspired by previous works [13, 19, 20], our model is optimized to maximize the similarity between bipartitely matched pairs of ground truth masks and predicted masks. Furthermore, we again adopt the similarity maximization for tracking instances of same identities, which effectively links predicted space-time masks using bipartite matching. As both of our training and inference algorithms are fundamentally designed to address the key challenge of VIS task, our method attains an outstanding accuracy.
+
+From these improvements, IFC sets the new state-of-the-art: $4 2 . 6 \%$ AP and more surprisingly, in 89.4 fps. Furthermore, our model also shows great speed-accuracy balance under near-online settings, which leads to a huge practicality. We believe that our model can be a powerful baseline for video instance segmentation approaches that follow the per-clip execution.
+
+# 2 Related Work
+
+Video instance segmentation The VIS task [1] extends the concept of tracking to the image instance segmentation task. The early solutions [1, 2] follow the per-frame pipeline, which utilize additional tracking head to the models that are mainly designed to solve image instance segmentation. More advanced algorithms that are recently proposed [3, 4] take video characteristics into consideration, which result in improved performance.
+
+Per-clip models [10, 11, 12] dedicate computations to extract information from multiple frames for higher accuracy. By exploiting multiple frames, per-clip models can effectively handle typical challenges in video, i.e., motion blurs and occlusions. Our model is designed to be highly efficient while following the per-clip pipeline, which leads to fast and accurate predictions.
+
+Transformers Recently, transformers [14] are greatly impacting many tasks in computer vision. After the huge success of DETR [13], which has brought a new paradigm to the object detection task, numerous vision tasks are incorporating transformers [21, 22] in place of CNNs. For classification tasks in both NLP and computer vision, many adopt an extra classification token to the input of transformers [21, 23]. All the input tokens affect each other as the encoders are mainly composed of the self-attention, thus the classification token can be used to determine the class of the overall input. Similarly, DeiT [24] inserts an additional distillation token to transformers, and the novel usage leads to a higher data efficiency. MaX-DeepLab [20] adopted the concept of memory and proposed a novel dual-path transformer for the panoptic segmentation task [25]. By making use of numerous memory tokens to convey information, MaX-DeepLab integrates the transformer and the CNN by making both feedback itself and the other.
+
+We further utilize the concept of the memory tokens to the videos. Using Inter-frame Communication Transformers, each frame runs independently while sharing their information with interim communications. The communications lead to higher accuracy while the execution independence between frames accelerates the inference.
+
+![](images/38190ff2e29f8cfb09f1e13cb0bf969f482baa8226d8a40c6907883122649d66.jpg)  
+Figure 1: Overview of IFC framework. Our transformer encoder block has two components: 1) Encode-Receive $( \mathcal { E } )$ simultaneously encodes frame tokens and memory tokens. 2) Only memory tokens pass Gather-Communicate $( { \mathcal { G } } )$ to perform communications between frames. The output from the stack of $N _ { E }$ encoder blocks goes into two modules, spatial decoder and transformer decoder, to generate segmentation masks.
+
+# 3 Method
+
+The proposed method follows a per-clip pipeline which takes a video clip as input and outputs clip-level results. We also introduce Inter-frame Communication Transformers, which can effectively share frame-wise information within a clip with a high efficiency.
+
+# 3.1 Model architecture
+
+Inspired by DETR [13], our network consists of a CNN backbone and transformer encoder-decoder layers (Fig. 1). The input clip is first independently embedded into a feature map through the backbone. Then, the embedded clip passes through our inter-frame communication encoder blocks that enrich the feature map by allowing information exchange between frames. Next, a set of transformer decoder layers that take the encoder outputs and object queries as inputs predict unique convolutional weights for each instance in the clip. Finally, the masks for each instance across the clip are computed in one shot by convolving the encoded feature map with the unique convolutional weight.
+
+Backbone Given an input clip $\{ x _ { i } \} _ { i = 1 } ^ { T } \ \in \ \mathbb { R } ^ { T \times H _ { 0 } \times W _ { 0 } \times 3 }$ , composed of $T$ frames with 3 color channels, the CNN backbone processes the input clip frame-by-frame. As the result, the clip is encoded into a set of low-resolution features, $\bar { \{ f _ { i } ^ { 0 } \} _ { i = 1 } ^ { T } } \in \mathbb { R } ^ { T \times H \times W \times C }$ , where $C$ is the number of channels and $\begin{array} { r } { H , W = \frac { H _ { 0 } } { 3 2 } , \frac { W _ { 0 } } { 3 2 } } \end{array}$ .
+
+Inter-Frame Communication Encoder Given an image, humans can effortlessly summarize the scene with only a few words. Also, frames from a same video share a lot of commonalities, the difference between them is sufficiently summarized and communicated even with a small bandwidth. Based on this hypothesis, we propose an inter-frame communication encoder to make the computation to be mostly frame-wise independent with some communications between frames. Specifically, we adopt memory tokens for both summarizing per-frame scenes and the means of communications.
+
+Our encoder blocks are composed of two phases of separate transformers: Encode-Receive $( \mathcal { E } )$ and Gather-Communicate $( { \mathcal { G } } )$ . Both Encode-Receive and Gather-Communicate follow the typical transformer encoder architecture [14], which consists of an addition of fixed positional encoding, a multi-head self-attention module, and a feed forward network.
+
+Encode-Receive operates in a per-frame manner, taking a frame-level feature map and corresponding memory tokens. Passing through Encode-Receive, we expect two functionalities: (1) image features encode per-frame information to the memory tokens, and (2) image features receive information of different frames that are gathered in the memory tokens. Gather-Communicate operates across frames to form a clip-level knowledge. It takes the memory tokens from each frame as inputs and performs communications between frames. Alternating two phases through multiple layers, the encoder can efficiently learn consensus representations across frames.
+
+Table 1: Complexity comparison. Various transformer encoders for space-time input. As the overall FLOPs can vary by the number of detected instances, listed values are measured only at the encoders.   
+
+<table><tr><td rowspan="3">Communication Type</td><td rowspan="3">Complexity per Layer</td><td colspan="4">FLOPs (G)1</td></tr><tr><td></td><td>360 × 640</td><td></td><td>720×1280</td></tr><tr><td>T=5</td><td>T=36</td><td>T=5</td><td>T=36</td></tr><tr><td>No Comm</td><td>O(C²THW + CT(HW)2)</td><td>5.17</td><td>37.23</td><td>24.62</td><td>177.29</td></tr><tr><td>Full THW</td><td>O(C²THW + C(THW)2)</td><td>6.94</td><td>148.70</td><td>50.63</td><td>1815.38</td></tr><tr><td>Decompose T-HW</td><td>O(C²THW + CT(HW)² + CT²HW)</td><td>8.33</td><td>60.24</td><td>36.73</td><td>265.50</td></tr><tr><td>IFC (M = 8)</td><td>O(C²THW +CT(HW)2)</td><td>5.52</td><td>39.73</td><td>25.05</td><td>180.39</td></tr></table>
+
+In more detail, given the frame embedding $\{ f _ { i } ^ { 0 } \} _ { i = 1 } ^ { T }$ , we spatially flatten each feature $\mathbb { R } ^ { H \times W \times C } $ $\mathbb { R } ^ { H W \times C }$ . The initial memory tokens $m ^ { 0 }$ of size $M$ are copied per frame and concatenated to each frame feature as follows:
+
+$$
+[ f _ { t } ^ { 0 } , m _ { t } ^ { 0 } ] \in \mathbb { R } ^ { ( H W + M ) \times C } , \qquad t \in \{ 1 , 2 , \cdots , T \} ,
+$$
+
+where $[ \cdot , \cdot ]$ indicates a concatenation of two feature vectors. Note that the initial memory tokens $m ^ { 0 }$ are trainable parameters learnt during training.
+
+The first phase of IFC is Encode-Receive, which processes frames individually as follows:
+
+$$
+[ f _ { t } ^ { l } , \widehat { m } _ { t } ^ { l } ] = \mathcal { E } ^ { l } ( [ f _ { t } ^ { l - 1 } , m _ { t } ^ { l - 1 } ] ) ,
+$$
+
+where ${ \mathcal { E } } ^ { l }$ denotes the $l$ -th Encode-Receive layer. With a self-attention computed over the frame pixel locations and the memory tokens, the information of each frame can be passed to the memory tokens and vise-versa.
+
+The outputs of Encode-Receive are grouped by memory indices and formulate the inputs for GatherCommunicate layer. The grouping can be understood as a decomposition of memory tokens, and becomes computationally beneficial when the total size of gathered memory tokens increases.
+
+$$
+\begin{array} { r l } & { [ m _ { 1 } ^ { l } ( i ) , m _ { 2 } ^ { l } ( i ) , \cdots , m _ { T } ^ { l } ( i ) ] = \mathcal { G } ^ { l } ( [ \widehat { m } _ { 1 } ^ { l } ( i ) , \widehat { m } _ { 2 } ^ { l } ( i ) , \cdots , \widehat { m } _ { T } ^ { l } ( i ) ] ) , \qquad i \in \{ 1 , 2 , \cdots , M \} , } \end{array}
+$$
+
+where $\mathcal { G } ^ { l }$ denotes the $l$ -th Gather-Communicate layer. The processed outputs are redistributed to the originated frame and get concatenated as $m _ { t } \overset { \cdot } { = } \left[ m _ { t } ( 1 ) , \overset { \cdot } { m } _ { t } ( 2 ) , \cdot \cdot \cdot , \overset { \cdot } { m } _ { t } ( M ) \right]$ . Unlike EncodeReceive, Gather-Communicate utilizes the attention mechanism to convey the information from different frames over the input clip.
+
+Defining the $l$ -th inter-frame encoder block $( \mathrm { I F C } ^ { l } )$ as ${ \mathcal { E } } ^ { l }$ followed by $\mathcal { G } ^ { l }$ , the stack of $N _ { E }$ encoder blocks can be inductively formulated as:
+
+$$
+[ f _ { t } ^ { l } , m _ { t } ^ { l } ] = \mathrm { I F C } ^ { l } ( [ f _ { t } ^ { l - 1 } , m _ { t } ^ { l - 1 } ] ) , \qquad 1 \leq l \leq N _ { E } ,
+$$
+
+where $\left[ f _ { t } ^ { N _ { E } } , m _ { t } ^ { N _ { E } } \right]$ is the final result. The stacking of multiple encoder layers brings communications between frames, thus each frame can have coincidence to the other, specifying the identities of instances in a given clip.
+
+Complexity comparison In Table 1, we analyze the computational complexity of transformer encoder variants applied for video input in terms of the Big-O complexity and FLOPs. The complexity of the original transformer encoder layer [14] is $\mathcal { O } ( C ^ { 2 } N ^ { ' } { + } C N ^ { 2 } )$ , where $N$ is the number of inputs. Without any communication between frames, No Comm, it shows the smallest amount of computation $( { \mathcal O } ( C ^ { 2 } T \dot { H W } + C T ( H W ) ^ { 2 } ) )$ ). As indicated as Full THW in Table 1, the complexity of VisTR [11] that performs a full space-time self-attention is $\mathcal { O } ( C ^ { 2 } ( T H W ) + C ( T H W ) ^ { 2 } )$ thus either a higher resolution or an increase of number of input frames leads to a massive increase in computations. VisTR bypasses the problem by highly reducing the input resolution and utilizing GPUs with tremendous memory capacity. However, as such solutions cannot resolve the fundamental issues, it is impractical to real-world videos. Moreover, VisTR remains as a complete offline strategy because it takes the entire video as an input.
+
+An intriguing improvement for the naïve full self-attention would be the decomposition of the attention into space and time axis [16, 17, 26]. In Decompose T-HW, we decompose attention computation into spatial and temporal attention. The complexity of the separation of space-time leads to the sum of the two transformer encoder: $\mathcal { O } ( T ( C ^ { 2 } ( H \bar { W } ) + \bar { C } ( H W ) ^ { 2 } ) )$ and $\mathcal { O } ( H \bar { W } ( C ^ { 2 } T + C T ^ { 2 } ) )$ . In comparison to the full self-attention, the decomposition lowers the computational growth relative to the number of frames.
+
+Our encoder, IFC, that communicates between frames using the memory tokens leads to a huge benefit to the total computations adding only a small amount of computation over No Comm while providing sufficient channels for communication. The complexity of each phase in our proposed encoder is: $\mathcal { O } ( C ^ { 2 } T ( H W + M ) + C T ( H W + M ) ^ { 2 } )$ for Encode-Receive and $\mathcal { O } ( C ^ { 2 } T M + \bar { C } \bar { T } ^ { 2 } M )$ for Gather-Communicate respectively. Assuming that $M$ is kept small (e.g., 8), the computation needed for Gather-Communicate can be neglected, while the complexity of Encode-Receive can be approximated to $\mathcal { O } ( C ^ { 2 } T H W + C T ( H W ) ^ { 2 } )$ as shown in Table 1. Finally, with respect to the number of frames of the input, we can expect approximate linear increase rather than the high increase of computation occurred in VisTR.
+
+Decoders and output heads As depicted in Fig. 1, the transformer decoder of our model is stacked with $N _ { D }$ layers [14]. Contrary to VisTR, where the number of object queries increases proportionally to the number of frames, our model receives learnt encodings of fixed size $N _ { q }$ for object queries. Also, by utilizing these encodings throughout the entire frames, our model can effectively deal with clips of various lengths. A set of projection matrices are applied to $\{ f _ { t } ^ { N _ { E } } , m _ { t } ^ { N _ { E } } \} _ { t = 1 } ^ { T }$ for the generation of keys and values. The object queries turn into output embeddings by the transformer decoder, and the embeddings are eventually used as an input to the output heads.
+
+There are two output heads on top of the transformer decoder, a class head and a segmentation head, each composed of two fully-connected layers. The output embeddings from the transformer decoder are independently inserted to the heads, resulting in $N _ { q }$ predictions per a clip. The class head outputs a class probability distribution of instances $\hat { p } ( c ) \in \mathbb { R } ^ { N _ { q } \times | \mathbb { C } | }$ . Note that the possible classes $\mathbb { C } \ni c$ include no object $\mathcal { D }$ class in addition to the given classes of a dataset.
+
+The segmentation head generates $N _ { q }$ conditional convolutional weights $w \in \mathbb { R } ^ { N _ { q } \times C }$ in a manner similar to [7, 20]. For the conditional convolution, the output feature of the encoder reused by undoing the flatten operation. For the upsampling, the encoder feature pa $\{ f _ { t } ^ { N _ { E } } \} _ { t = 1 } ^ { T }$ isgh fpn-style [27] spatial decoder without temporal connections resulting in $T$ feature maps that are $1 / 8$ of the input resolution. Finally, the resulting feature maps $f ^ { \prime }$ are convolved with each convolutional weight to generate a segmentation mask as follows:
+
+$$
+\hat { s } _ { i } = \{ f _ { t } ^ { \prime } \circ w _ { i } \} _ { t = 1 } ^ { T } ,
+$$
+
+where $w _ { i }$ is $i$ -th convolutional weight, $\circ$ indicate $1 \times 1$ spatial convolution operation, and the result $\hat { s _ { i } }$ is a spatial-temporal object mask in shape of $\mathbb { R } ^ { T \times H ^ { \prime } \times W ^ { \prime } }$ where $\begin{array} { r } { H ^ { \prime } = \frac { H _ { 0 } } { 8 } } \end{array}$ , $\begin{array} { r } { W ^ { \prime } = \frac { W _ { 0 } } { 8 } } \\ { . } \end{array}$ . Note that, for an instance, a common weight is applied throughout the video clip. Our spatial decoder is an instanceagnostic design, which is much more efficient than instance-specific decoders [10, 11, 12, 13] as the number of detected instances increases. Meanwhile, thanks to our segmentation head which specifies and captures the characteristics of an instance, IFC can conduct both segmentation and tracking at once within a clip.
+
+# 3.2 Instance matching and loss
+
+To train our network, we first assign the ground truth for each instance estimation and then a set of loss function between each the ground truth and prediction pair. For a given input clip, our model generate a fixed-size set of class-labeled masks $\{ \hat { y } _ { i } \} _ { i = 1 } ^ { N _ { q } } = \{ ( \hat { p } _ { i } ( \boldsymbol { c } ) , \hat { s } _ { i } ) \} _ { i = 1 } ^ { N _ { q } }$ . The ground truth set of the clip can be represented as $y _ { i } = ( c _ { i } , s _ { i } )$ ; $c _ { i }$ is the target class label including $\mathcal { D }$ , and $s _ { i }$ is the target mask which is down-sampled to the size of the prediction masks for efficient similarity calculation. One-to-one bipartite matching between the prediction set $\{ \hat { y } _ { i } \} _ { i = 1 } ^ { N _ { q } }$ and the ground truth set $\{ y _ { i } \} _ { i = 1 } ^ { K }$ is performed to find the best assignment of a prediction to a ground truth. The objective can be formally
+
+described as:
+
+$$
+\hat { \sigma } = \underset { \sigma \in \mathfrak { S } _ { N _ { q } } } { \arg \operatorname* { m a x } } \sum _ { i = 1 } ^ { K } \sin ( y _ { i } , \hat { y } _ { \sigma ( i ) } ) ,
+$$
+
+where $\sin ( y _ { i } , \hat { y } _ { \sigma ( i ) } )$ refers a pair-wise similarity over a permutation of $\underset { \_ w } { \sigma } \in \mathfrak { S } _ { N _ { g } }$ . Following prior work [13, 20, 28], the bipartite matching is efficiently computed using Hungarian algorithm [19]. We find that box-based similarity measurement as used in DETR [13] shows weaknesses in matching instances in video clip due to the case of occlusion and disappear-and-reappear. Therefore, we define $\sin ( y _ { i } , \hat { y } _ { \sigma ( i ) } )$ to be mask-based term as $\mathbb { 1 } _ { \{ c _ { i } \neq \infty \} } [ \hat { p } _ { \sigma ( i ) } ( c _ { i } ) + \bar { \lambda } _ { 0 } \mathrm { D I C E } ( s _ { i } , \bar { \hat { s } } _ { \sigma ( i ) } ^ { - } ) ]$ , where DICE denotes dice coefficients [29].
+
+Given the optimal assignment $\hat { \sigma }$ , we refer to the $K$ matched predictions and $( N _ { q } - K )$ non-matched predictions as positive and negative pairs respectively. The positive pairs aim to predict the ground truth masks and classes while the negative pairs are optimized to predict the $\mathcal { D }$ class. The final loss is a sum of the losses from positive pairs and negative pairs where each can be computed as follows:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { p o s } = \displaystyle \sum _ { i = 1 } ^ { K } [ \underbrace { - \log \hat { p } _ { \hat { \sigma } ( i ) } ( c _ { i } ) } _ { \mathrm { C r o s s - e n t r o p y ~ l o s s } } + \lambda _ { 1 } ( \underbrace { 1 - \operatorname { D I C E } \bigl ( s _ { i } , \hat { s } _ { \hat { \sigma } ( i ) } \bigr ) } _ { \mathrm { D i c e ~ l o s s ~ } [ 2 9 ] } ) + \lambda _ { 2 } \underbrace { \operatorname { F O C A L } \bigl ( s _ { i } , \hat { s } _ { \hat { \sigma } ( i ) } \bigr ) } _ { \mathrm { S i g m o i d - f o c a l ~ l o s s ~ } [ 3 0 ] } ] , } \\ & { \quad \quad \quad \quad \quad \quad \mathcal { L } _ { n e g } = \displaystyle \sum _ { i = k + 1 } ^ { N _ { q } } [ - \log \hat { p } _ { \hat { \sigma } ( i ) } ( \emptyset ) ] . } \end{array}
+$$
+
+As $( N _ { q } - K )$ is likely to be much greater than $K$ , we down-weight $\mathcal { L } _ { n e g }$ by a factor of 10 to resolve the imbalance, following prior work [13]. The goal of video instance segmentation [1] is to maximize the space-time IoU between a prediction and a ground truth mask. Therefore, our mask-related losses (Dice loss and Sigmoid-focal loss) are spatio-temporally calculated over an entire clip, rather than averaging the losses that are accumulated frame-by-frame.
+
+# 3.3 Clip-level instance tracking
+
+To infer a video input that is longer than the clip length, we match instances using the predicted masks of overlapping frames. Let $\mathcal { V } _ { I }$ and ${ \mathcal { V } } _ { A }$ be the result sets of clip $I$ and $A$ excluding the $\mathcal { D }$ class. The goal is to perform matching of same identities between pre-collected instance set $\mathcal { V } _ { I }$ and $\mathcal { V } _ { A }$ . We first calculate the matching scores which are space-time soft IoU at intersecting frames between $\mathcal { V } _ { I }$ and $\mathcal { V } _ { A }$ . Then, we find optimal paired indices $\hat { \sigma } _ { S }$ using Hungarian algorithm [19] to the gathered matching score $\mathcal { S } \in [ 0 , \bar { 1 ] } ^ { | \mathcal { N } _ { I } | \times | \bar { \mathcal { V } } _ { A } | }$ . We update $\mathscr { D } _ { I } ( i )$ by concatenating $\mathcal { V } _ { A } ( \hat { \sigma } _ { S } ( i ) )$ if $\bar { \cal S } ( i , \bar { \sigma } s ( i ) )$ is above a certain threshold, and add non-matched prediction sets to $\mathcal { V } _ { I }$ as new instances. Note that a previous per-clip model (MaskProp [10]) also utilizes soft IoU for tracking instances, but the matching scores are computed per-frame and averaged for intersecting frames. Different from MaskProp, using space-time soft IoU leads to an accurate tracking as it can better represent the definition of mask similarities between clips which brings at most $2 \%$ AP increase. The overall tracking pipeline can be effectively implemented in a GPU-friendly manner.
+
+# 4 Experiments
+
+In this section, we evaluate the proposed method using YouTube-VIS 2019 and 2021 [1]. For every listed score, we report the mean of five runs as the results may vary by each run due to the insufficient number of training and testing set of YouTube-VIS dataset. We demonstrate the effectiveness of our model regarding both accuracy and speed. We further examine how different settings affect the overall performance and efficiency of IFC encoder. Unless specified, all models for measurements used $\bar { N _ { E } } = 3 , \bar { N _ { D } } = 3$ , stride of 1, and ResNet-50.
+
+# 4.1 Implementation Details
+
+We used detectron2 [33] for our code basis, and hyper-parameters mostly follow the settings of DETR [13] unless specified. We used AdamW [34] optimizer with initial learning rate of $1 0 ^ { - 4 }$ for transformers, and $1 \bar { 0 } ^ { - 5 }$ for backbone. We first pre-train the model for image instance segmentation on COCO [35] by setting our model to $T = 1$ . The pre-train procedure follows the shortened training schedule of DETR [13], which runs 300 epochs with a decay of the learning rate by a factor of 10 at 200 epochs. Using the pre-trained weights, the models are trained on a targeted dataset using the batch size of 16, each clip composed of $T = 5$ frames downscaled to either $3 6 0 \mathrm { p }$ or $4 8 0 \mathrm { p }$ . For the sampling of each clip, a reference frame index $t$ is randomly chosen. The remaining $T - 1$ frame indices are then sampled within an interval of 20. The models are trained for 8 epochs, and decays the learning rate by 10 at 5th epoch.
+
+Table 2: Evaluations on various settings.   
+(a) AP and FPS on YouTube-VIS 2019 val set. For fairness, FPS is measured on a same machine, using a single RTX 2080Ti GPU. We used the official codes and checkpoints provided by the authors for the measurements. We report the clip settings of [10, 11]. T : window size.   
+(b) Accuracy on YTVIS 2021 val set   
+(d) Effect of strides   
+
+<table><tr><td colspan="3">Method (Settings)</td><td>Backbone [31]</td><td>FPS²</td><td>AP</td><td>AP50</td><td>AP75</td><td>AR1</td><td>AR10</td></tr><tr><td rowspan="9">prij.ite</td><td colspan="2">MaskTrack R-CNN[1]</td><td>ResNet-50</td><td>26.1</td><td>30.3</td><td>51.1</td><td>32.6</td><td>31.0</td><td>35.5</td></tr><tr><td colspan="2">MaskTrack R-CNN[1]</td><td>ResNet-101</td><td>=</td><td>31.8</td><td>53.0</td><td>33.6</td><td>33.2</td><td>37.6</td></tr><tr><td colspan="2">SipMask [2]</td><td>ResNet-50</td><td>35.5</td><td>33.7</td><td>54.1</td><td>35.8</td><td>35.4</td><td>40.1</td></tr><tr><td colspan="2">SG-Net [4]</td><td>ResNet-50</td><td>1</td><td>34.8</td><td>56.1</td><td>36.8</td><td>35.8</td><td>40.8</td></tr><tr><td colspan="2">SG-Net [4]</td><td>ResNet-101</td><td>1</td><td>36.3</td><td>57.1</td><td>39.6</td><td>35.9</td><td>43.0</td></tr><tr><td colspan="2">Cross VIS [3]</td><td>ResNet-50</td><td>=</td><td>36.3</td><td>56.8</td><td>38.9</td><td>35.6</td><td>40.7</td></tr><tr><td colspan="2">Cross VIS [3]</td><td>ResNet-101</td><td>1</td><td>36.6</td><td>57.3</td><td>39.7</td><td>36.0</td><td>42.0</td></tr><tr><td colspan="2">STEm-Seg [32]</td><td>ResNet-101</td><td>3.0</td><td>34.6</td><td>55.8</td><td>37.9</td><td>34.4</td><td>41.6</td></tr><tr><td rowspan="7">VisTR[11]</td><td>VisTR[11]</td><td>(T=36)</td><td>ResNet-50</td><td>51.1</td><td>35.6</td><td>56.8</td><td>37.0</td><td>35.2</td><td>40.2</td></tr><tr><td></td><td>(T=36)</td><td>ResNet-101</td><td>43.5</td><td>38.6</td><td>61.3</td><td>42.3</td><td>37.6</td><td>44.2</td></tr><tr><td>MaskProp[10]</td><td>(T=13)</td><td>ResNet-50</td><td>1</td><td>40.0</td><td>1</td><td>42.9</td><td>1</td><td>-</td></tr><tr><td>MaskProp [10]</td><td>(T=13)</td><td>ResNet-101</td><td>1</td><td>42.5</td><td>1</td><td>45.6</td><td>1</td><td>1</td></tr><tr><td>OurSnear-online</td><td>(T=5)</td><td>ResNet-50</td><td>46.5</td><td>39.0</td><td>60.4</td><td>42.7</td><td>41.7</td><td>51.6</td></tr><tr><td>OurSoffline</td><td>(T=36)</td><td>ResNet-50</td><td>107.1</td><td>41.2</td><td>65.1</td><td>44.6</td><td>42.3</td><td>49.6</td></tr><tr><td>OurSoffline</td><td>(T=36)</td><td>ResNet-101</td><td>89.4</td><td>42.6</td><td>66.6</td><td>46.3</td><td>43.5</td><td>51.4</td></tr></table>
+
+(c) Bipartite matching   
+
+<table><tr><td></td><td>AP</td></tr><tr><td>Box-based</td><td>37.5</td></tr><tr><td>Mask-based</td><td>39.6</td></tr></table>
+
+<table><tr><td></td><td>AP</td><td>AP50</td><td>AP75</td></tr><tr><td>MaskTrack-RCNN</td><td>28.6</td><td>48.9</td><td>29.6</td></tr><tr><td>SipMask</td><td>31.7</td><td>52.5</td><td>34.0</td></tr><tr><td>CrossVIS</td><td>34.2</td><td>54.4</td><td>37.9</td></tr><tr><td>Ours</td><td>35.2</td><td>57.2</td><td>37.5</td></tr></table>
+
+<table><tr><td></td><td>AP</td><td>AP75</td><td>FPS</td></tr><tr><td>T=5</td><td>S=3 S=5</td><td>38.7 42.1</td><td>72.7</td></tr><tr><td>T=10</td><td>39.5</td><td>42.8</td><td>83.0</td></tr><tr><td>T=15 S=8</td><td>39.7</td><td>43.0</td><td>92.5</td></tr><tr><td>T=20 S=10</td><td>40.4</td><td>43.3</td><td>95.7</td></tr></table>
+
+During inference, our model takes inputs as follows. Let an input video has $V$ frames, $T$ is the number of frames per clip and $S$ is the stride of clips. We start from inserting a clip of frame indices $[ 1 , T ]$ and sequentially insert clips of $[ 1 + S , T + \bar { S } ] , [ 1 + 2 S , T + 2 S ] , \therefore , [ 1 + n S , T + n S ]$ . It repeats until the end frame index $T + n S$ is equal to or greater than $V$ . If the end frame index of the last clip $T + n S$ is greater than $V$ , we change the frame indices of the last clip to $[ V - T + 1 , V ]$ . The resolution of input videos are downscaled to $3 6 0 \mathrm { p }$ , which follows MaskTrack R-CNN [1].
+
+# 4.2 Main Results
+
+YouTube-VIS 2019 evaluation results We compare our proposed IFC to the state-of-the-art models in the video instance segmentation task on YouTube-VIS $2 0 1 9 \ \mathtt { v a l }$ in Table 2 (a). We measure the accuracy by AP and our model sets the highest score among all online, near-online, and offline models while presenting the fastest runtime. As mentioned earlier, IFC is highly efficient during the inference thanks to three advantages: (1) memory token-based decomposition for transformer encoder (2) instance-agnostic spatial decoder (3) GPU-friendly instance matching. Moreover, our model does not make use of any heavy modules such as deformable convolutions [36] or cascading networks [37]. Thanks to these advantages, IFC achieves an outstanding runtime, which is faster speed than online models [1, 2].
+
+During the inference, our method is able to freely adjust the length of the clip $( T )$ as needed. If the input clip length is set to contain entire video frames, our method becomes an offline method (like
+
+![](images/670bbd204f67e3d539074c5cfb25f24385665e804acb9763ac21417ab8d1c742.jpg)  
+Figure 2: Visualization of predictions from VisTR and our model. Instances with the same identity are displayed in the same color.
+
+VisTR [11]) that processes the entire video in one shot. As the offline inference can skip matching between clips and maximize the GPU utilization, our method represents surprisingly fast runtime (107.1 FPS). On the other hand, if the application requires instant outputs given a video stream, we can reduce the clip length to make our method near-online. In the near-online scenario with $T = 5$ our system is still able to process a video in real-time (46.5 FPS) with only a small delay.
+
+YouTube-VIS 2021 evaluation results The recently introduced dataset YouTube-VIS 2021 is an improved version of YouTube-VIS 2019. The newly added videos in the dataset include higher number of instances and frames. For the new dataset, we use 32 memory tokens. In Table 2 (b), we refer the results reported in [3], which evaluated [1, 2] using official implementations. Again, our model achieves the best performance.
+
+Qualitative result comparison We compare some qualitative results predicted by our model and VisTR [11] in Fig. 2. In terms of both tracking accuracy and segmentation quality, IFC yields better results than VisTR.
+
+# 4.3 Ablation Study
+
+In this section, we provide ablation studies and discuss how different settings impact the overall performance. The experiments are conducted using YouTube-VIS 2019 val set.
+
+Box-based and mask-based bipartite matching We observe how the different policies for bipartite matching affect the performance. As our model does is a box-free method, we adjust our model to predict bounding boxes similar to VisTR [11] and conduct bipartite matching [13, 19] using the predicted boxes. The change of optimization from mask-based to box-based brings a noticeable performance drop as shown in Table 2 (c). With the VIS-centric design, the mask-based optimization shows more robustness than box-based optimizations under typical video circumstances such as instances with heavy overlaps and partial occlusions.
+
+Differing window strides In addition to the clip length $T$ , we further optimize our runtime placing a stride $S$ between clips, as shown in Table 2 (d). IFC can be used in a near-online manner, which takes clips that are consecutively extracted from a video. The placement of a larger stride reduces temporal intersections, which lessens computational overheads but also causes difficulty in matching instances. By enlarging the stride from $S = 1$ to $S = 3$ , IFC accomplishes approximately $150 \%$ speed improvement with only $0 . 1 \%$ AP drop. The tendency of high speed gain and low accuracy drop persists under various conditions. Therefore, our model can be applied to conditions where the enlargement of strides is necessary, i.e., using devices that are not powerful enough but has to maintain high inference speed.
+
+Table 3: Encoder variations. We show how different encoders affect the overall performance.   
+(a) Various encoders taking clips of different lengths (see Table 1)   
+
+<table><tr><td></td><td colspan="3">T=5</td><td colspan="3">T=10</td><td colspan="3">T=15</td><td colspan="3">T=20</td></tr><tr><td></td><td>AP</td><td>AP75</td><td>FPS</td><td>AP</td><td>AP75</td><td>FPS</td><td>AP</td><td>AP75</td><td>FPS</td><td>AP</td><td>AP75</td><td>FPS</td></tr><tr><td>No Comm</td><td>37.4</td><td>39.9</td><td>38.1</td><td>38.8</td><td>41.6</td><td>40.8</td><td>39.3</td><td>41.7</td><td>46.7</td><td>39.6</td><td>41.9</td><td>52.9</td></tr><tr><td>Full THW</td><td>37.2</td><td>40.0</td><td>37.6</td><td>38.8</td><td>41.2</td><td>35.5</td><td>39.8</td><td>42.6</td><td>32.9</td><td>39.7</td><td>42.8</td><td>34.8</td></tr><tr><td>Decomp T-HW</td><td>37.2</td><td>39.8</td><td>35.7</td><td>38.3</td><td>40.9</td><td>37.9</td><td>38.5</td><td>41.5</td><td>42.6</td><td>39.0</td><td>41.9</td><td>49.4</td></tr><tr><td>IFC</td><td>39.0</td><td>42.7</td><td>36.3</td><td>39.6</td><td>43.0</td><td>38.9</td><td>39.8</td><td>43.0</td><td>43.7</td><td>40.4</td><td>43.4</td><td>50.2</td></tr></table>
+
+(b) Image instance segmentation on COCO val set   
+(c) Number of memory tokens (AP)   
+(d) Index-wise memory decomposition   
+
+<table><tr><td></td><td>T=5</td><td>T=10</td><td>T=15</td><td>T=20</td></tr><tr><td>M=1</td><td>37.6</td><td>39.2</td><td>39.4</td><td>39.4</td></tr><tr><td>M=2</td><td>37.9</td><td>39.2</td><td>39.6</td><td>39.8</td></tr><tr><td>M=4</td><td>38.0</td><td>39.5</td><td>39.7</td><td>39.9</td></tr><tr><td>M=8</td><td>39.0</td><td>39.6</td><td>39.8</td><td>40.4</td></tr><tr><td>M=16</td><td>38.1</td><td>39.1</td><td>39.7</td><td>39.9</td></tr></table>
+
+<table><tr><td></td><td>APCOcO</td><td>APOC</td></tr><tr><td>w/o mem</td><td>35.0</td><td>56.6</td></tr><tr><td>w/mem</td><td>35.1</td><td>56.5</td></tr></table>
+
+<table><tr><td></td><td>T=5</td><td>T=10</td><td>T=15</td><td>T=20</td></tr><tr><td>Unified</td><td>38.1</td><td>38.9</td><td>39.7</td><td>39.9</td></tr><tr><td>Decomp</td><td>39.0</td><td>39.6</td><td>39.8</td><td>40.4</td></tr></table>
+
+Various decomposition strategies of encoders In Table 1, we observed the computational gaps derived from the decomposition of the encoder layers. Extending Table 1, we now investigate the how the decomposition strategies affect the accuracy in Table 3.
+
+The models are evaluated with variety of window sizes $( T = 5 , 1 0 , 1 5 , 2 0 )$ as an increase of window size $T$ has pros and cons. When matching predictions from different clips, greater $T$ is advantageous due to an enlargement of temporal intersections between clips. On the contrary, frames in longer clips are likely to be composed of diverse appearances, which disrupt tracking and segmenting instances within a clip. Therefore, the key to the performance enhancement is to cope with the appearance changes by precisely encoding and correlating space-time inputs.
+
+As shown in Table 3 (a), the full self-attention [11] surpasses the encoder without communications as the length of clips increase. However, the enlargement of the window size highly slows down the inference speed, and the improvements are marginal that the tremendous computation and memory usage cannot be compensated. The decomposition of space-time maintains comparable speed even if the window is large, but fails to achieve high accuracy.
+
+Our model shows fast inference as the only additional computations of IFC are from utilizing a small number of memory tokens. Furthermore, by effectively encoding the space-time inputs with the communications between frames, IFC can take advantages of enlarging the window size, and surpasses other encoders.
+
+Memory tokens We also study the effects of utilizing memory tokens. As mentioned, the motivation of using the memory tokens is to build communications between frames. Different from the video instance segmentation task, the image segmentation task is consisted of a single frame. Therefore, the use of the memory tokens does not lead to improvements to the image instance segmentation task as mutual communications cannot be solely made (see Table 3 (b)). Meanwhile, the utilization of the memory tokens achieves great improvements by effectively passing the information between frames. Results in Table 3 (a, c) demonstrate that the use of memory tokens achieves higher accuracy than the encoder without any communications (No comm), which emphasizes the importance of the communications. We evaluate how the size of the memory tokens affect the overall accuracy in Table 3 (c) and set the default size of the tokens $M$ to be 8.
+
+In Section 3.1, we demonstrated the formulation of the inputs for Gather-Communicate layer, which groups the outputs of Encode-Receive by memory indices. As aforementioned, the formulation can be considered as a decomposition of memory tokens: insertion to the Gather-Communicate layer by separate $M$ groups each consisting of $T$ tokens. In Table 3 (d), we investigate the impact of inserting the unified $M T$ tokens as a whole. Compared to the unified insertion, the decomposition brings better accuracy as the memories of same indices have more correspondences, which ease the encoders to build attentions in between.
+
+![](images/4b931f85da0d48797b1b4c756cba7dd5676ea7a6fc6286067da15b0c72e1db60.jpg)  
+Figure 3: Visualizations of results and attention maps of memory tokens.
+
+We choose a memory index attending foreground instances and visualize the attention map in Fig. 3. As shown in the results of the upper clip, we find that the memory token has more interests to instances that are relatively difficult to detect; it more attends the heavily occluded car at the rear. The clip at the bottom is composed of frames with huge motion blurs and appearance changes. With the communications of memory tokens, IFC successfully tracks and segments the rabbit.
+
+# 5 Conclusion
+
+In this paper, we have proposed a novel video instance segmentation network using Inter-frame Communication Transformers (IFC), which alleviates full space-time attention and successfully builds communications between frames. Finally, our network presents a rapid inference and sets the new state-of-the-art on the YouTube-VIS dataset. For the future work, we plan to integrate temporal information, which indeed would take a step further to the human video understanding.
+
+# Acknowledgments
+
+This research was grant funded by the Artificial Intelligence Graduate School Program of Yonsei University, under Grant 2020-0-01361, Korea Evaluation Institute of Industrial Technology (KEIT) funded by the Ministry of Trade, Industry and Energy (10073129), and also supported by the Advanced Robotics Laboratory, part of the Future Technology Center at LG Electronics.
+
+# References
+
+[2] Cao, J., R. M. Anwer, H. Cholakkal, et al. Sipmask: Spatial information preservation for fast image and video instance segmentation. In ECCV. 2020.   
+[3] Yang, S., Y. Fang, X. Wang, et al. Crossover learning for fast online video instance segmentation. In ICCV. 2021.   
+[4] Liu, D., Y. Cui, W. Tan, et al. Sg-net: Spatial granularity network for one-stage video instance segmentation. In CVPR. 2021.   
+[5] He, K., G. Gkioxari, P. Dollar, et al. Mask r-cnn. In ICCV. 2017.   
+[6] Bolya, D., C. Zhou, F. Xiao, et al. Yolact: Real-time instance segmentation. In ICCV. 2019.   
+[7] Tian, Z., C. Shen, H. Chen. Conditional convolutions for instance segmentation. In ECCV. 2020.   
+[8] Chen, H., K. Sun, Z. Tian, et al. Blendmask: Top-down meets bottom-up for instance segmentation. In CVPR. 2020.   
+[9] Luo, W., J. Xing, A. Milan, et al. Multiple object tracking: A literature review. Artificial Intelligence, 2020.   
+[10] Bertasius, G., L. Torresani. Classifying, segmenting, and tracking object instances in video with mask propagation. In CVPR. 2020.   
+[11] Wang, Y., Z. Xu, X. Wang, et al. End-to-end video instance segmentation with transformers. In CVPR. 2020.   
+[12] Lin, H., R. Wu, S. Liu, et al. Video instance segmentation with a propose-reduce paradigm. In ICCV. 2021.   
+[13] Carion, N., F. Massa, G. Synnaeve, et al. End-to-end object detection with transformers. In ECCV. 2020.   
+[14] Vaswani, A., N. Shazeer, N. Parmar, et al. Attention is all you need. In NeurIPS. 2017.   
+[15] Wang, H., Y. Zhu, B. Green, et al. Axial-deeplab: Stand-alone axial-attention for panoptic segmentation. In ECCV. 2020.   
+[16] Bertasius, G., H. Wang, L. Torresani. Is space-time attention all you need for video understanding? In ICML. 2021.   
+[17] Arnab, A., M. Dehghani, G. Heigold, et al. Vivit: A video vision transformer. arXiv preprint arXiv:2103.15691, 2021.   
+[18] Wang, X., R. Girshick, A. Gupta, et al. Non-local neural networks. In CVPR. 2018.   
+[19] Kuhn, H. W. The hungarian method for the assignment problem. In Naval research logistics quarterly. 1955.   
+[20] Wang, H., Y. Zhu, H. Adam, et al. Max-deeplab: End-to-end panoptic segmentation with mask transformers. In CVPR. 2021.   
+[21] Dosovitskiy, A., L. Beyer, A. Kolesnikov, et al. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR. 2021.   
+[22] Ranftl, R., A. Bochkovskiy, V. Koltun. Vision transformers for dense prediction. In ICCV. 2021.   
+[23] Devlin, J., M.-W. Chang, K. Lee, et al. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL. 2019.   
+[24] Touvron, H., M. Cord, M. Douze, et al. Training data-efficient image transformers & distillation through attention. In ICML. 2021.   
+[25] Kirillov, A., K. He, R. Girshick, et al. Panoptic segmentation. In CVPR. 2019.   
+[26] Tran, D., H. Wang, L. Torresani, et al. A closer look at spatiotemporal convolutions for action recognition. In CVPR. 2018.   
+[27] Lin, T.-Y., P. Dollar, R. Girshick, et al. Feature pyramid networks for object detection. In CVPR. 2017.   
+[28] Stewart, R., M. Andriluka, A. Y. Ng. End-to-end people detection in crowded scenes. In CVPR. 2016.   
+[29] Milletari, F., N. Navab, S.-A. Ahmadi. V-net: Fully convolutional neural networks for volumetric medical image segmentation. In 3DV. 2016.   
+[30] Lin, T.-Y., P. Goyal, R. Girshick, et al. Focal loss for dense object detection. In ICCV. 2017.   
+[31] He, K., X. Zhang, S. Ren, et al. Deep residual learning for image recognition. In CVPR. 2016.   
+[32] Athar, A., S. Mahadevan, A. Ošep, et al. Stem-seg: Spatio-temporal embeddings for instance segmentation in videos. In ECCV. 2020.   
+[33] Wu, Y., A. Kirillov, F. Massa, et al. Detectron2. https://github.com/facebookresearch/ detectron2, 2019.   
+[34] Loshchilov, I., F. Hutter. Decoupled weight decay regularization. In ICLR. 2019.   
+[35] Lin, T.-Y., M. Maire, S. Belongie, et al. Microsoft coco: Common objects in context. In ECCV. 2014.   
+[36] Dai, J., H. Qi, Y. Xiong, et al. Deformable convolutional networks. In ICCV. 2017.   
+[37] Cai, Z., N. Vasconcelos. Cascade r-cnn: Delving into high quality object detection. In CVPR. 2018.

parse/train/s95BePNvykX/s95BePNvykX_content_list.json

@@ -0,0 +1,1197 @@
+[
+    {
+        "type": "text",
+        "text": "Video Instance Segmentation using Inter-Frame Communication Transformers ",
+        "text_level": 1,
+        "bbox": [
+            235,
+            122,
+            758,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sukjun Hwang1 Miran Heo1 Seoung Wug Oh2 Seon Joo Kim1 1Yonsei University 2Adobe Research {sj.hwang, miran, seonjookim}@yonsei.ac.kr seoh@adobe.com ",
+        "bbox": [
+            233,
+            220,
+            761,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            310,
+            535,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel end-to-end solution for video instance segmentation (VIS) based on transformers. Recently, the per-clip pipeline shows superior performance over per-frame methods leveraging richer information from multiple frames. However, previous per-clip models require heavy computation and memory usage to achieve frame-to-frame communications, limiting practicality. In this work, we propose Inter-frame Communication Transformers (IFC), which significantly reduces the overhead for information-passing between frames by efficiently encoding the context within the input clip. Specifically, we propose to utilize concise memory tokens as a means of conveying information as well as summarizing each frame scene. The features of each frame are enriched and correlated with other frames through exchange of information between the precisely encoded memory tokens. We validate our method on the latest benchmark sets and achieved state-of-the-art performance (AP 42.6 on YouTube-VIS 2019 val set using the offline inference) while having a considerably fast runtime (89.4 FPS). Our method can also be applied to near-online inference for processing a video in real-time with only a small delay. The code is available at https://github.com/sukjunhwang/IFC. ",
+        "bbox": [
+            233,
+            343,
+            766,
+            565
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            310,
+            608
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With the growing interest toward the video domain in computer vision, the task of video instance segmentation (VIS) is emerging [1]. Most of the current approaches [1, 2, 3, 4] extend image instance segmentation models [5, 6, 7, 8] and take frame-wise inputs. These per-frame methods extend the concept of temporal tracking by matching frame-wise predictions of high similarities. The models can be easily customized to real-world applications as they run in an online [9] fashion, but they show limitations in dealing with occlusions and motion blur that are common in videos. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "On the contrary, per-clip models are designed to overcome such challenges by incorporating multiple frames while sacrificing the efficiency. Previous per-clip approaches [10, 11, 12] aggregate information within a clip to generate instance-specific features. As the features are generated per instance, the number of instances in addition to the number of frames has a significant impact on the overall computation. Recently proposed VisTR [11] adapted DETR [13] to the VIS task and reduced the inference time by inserting the entire video, not a clip, to its offline end-to-end network. However, its full self-attention transformers [14] over the space-time inputs involve explosive computations and memories. In this work, we raise the following question: can a per-clip method be efficient while attaining great accuracy? ",
+        "bbox": [
+            174,
+            713,
+            825,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To achieve our goal, we introduce Inter-frame Communication Transformers (IFC) to greatly reduce the computations of the full space-time transformers. Similar to recent works [15, 16, 17] that alleviate the explosive computational growth inherent in attention-based models [14, 18], IFC takes a decomposition strategy utilizing two transformers. The first transformer (Encode-Receive, $\\mathcal { E }$ ) encodes each frame independently. To exchange the information between frames, the second transformer (Gather-Communicate, $\\mathcal { G }$ ) executes attention between a small number of memory tokens that hold concise information of the clip. The memory tokens are utilized to store the overall context of the clip, for example “a hand over a lizard�� in Fig. 1. The concise information assists detecting the lizard that is largely occluded by the hand in the first frame, without employing an expensive pixel-level attention over space and time. The memory tokens are only in charge of the communications between frames, and the features of each frame are enriched and correlated through the memory tokens. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We further reduce overheads while taking advantage of per-clip pipelines by concisely representing each instance with a unique convolutional weight [7]. Despite the changes of appearances at different frames, the instances of the same identity share commonalities because the frames originated from the same source video. Therefore, we can effectively capture instance-specific characteristics in a clip with dynamically generated convolutional weights. In companion with the segmentation, we track instances by uniformly applying the weights to all frames in a clip. Moreover, all executions of our spatial decoder are instance-agnostic except for the final layer which applies instance-specific weights. Accordingly, our model is highly efficient and also suitable for scenes with numerous instances. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition to the efficient modeling, we provide optimizations and an instance tracking algorithm that are designed to be VIS-centric. By the definition of $\\mathsf { A P } ^ { \\mathtt { V I S } }$ , the VIS task [1] aims to maximize the objective similarity: space-time mask IoU. Inspired by previous works [13, 19, 20], our model is optimized to maximize the similarity between bipartitely matched pairs of ground truth masks and predicted masks. Furthermore, we again adopt the similarity maximization for tracking instances of same identities, which effectively links predicted space-time masks using bipartite matching. As both of our training and inference algorithms are fundamentally designed to address the key challenge of VIS task, our method attains an outstanding accuracy. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "From these improvements, IFC sets the new state-of-the-art: $4 2 . 6 \\%$ AP and more surprisingly, in 89.4 fps. Furthermore, our model also shows great speed-accuracy balance under near-online settings, which leads to a huge practicality. We believe that our model can be a powerful baseline for video instance segmentation approaches that follow the per-clip execution. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            484
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            508,
+            321,
+            526
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Video instance segmentation The VIS task [1] extends the concept of tracking to the image instance segmentation task. The early solutions [1, 2] follow the per-frame pipeline, which utilize additional tracking head to the models that are mainly designed to solve image instance segmentation. More advanced algorithms that are recently proposed [3, 4] take video characteristics into consideration, which result in improved performance. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            614
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Per-clip models [10, 11, 12] dedicate computations to extract information from multiple frames for higher accuracy. By exploiting multiple frames, per-clip models can effectively handle typical challenges in video, i.e., motion blurs and occlusions. Our model is designed to be highly efficient while following the per-clip pipeline, which leads to fast and accurate predictions. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Transformers Recently, transformers [14] are greatly impacting many tasks in computer vision. After the huge success of DETR [13], which has brought a new paradigm to the object detection task, numerous vision tasks are incorporating transformers [21, 22] in place of CNNs. For classification tasks in both NLP and computer vision, many adopt an extra classification token to the input of transformers [21, 23]. All the input tokens affect each other as the encoders are mainly composed of the self-attention, thus the classification token can be used to determine the class of the overall input. Similarly, DeiT [24] inserts an additional distillation token to transformers, and the novel usage leads to a higher data efficiency. MaX-DeepLab [20] adopted the concept of memory and proposed a novel dual-path transformer for the panoptic segmentation task [25]. By making use of numerous memory tokens to convey information, MaX-DeepLab integrates the transformer and the CNN by making both feedback itself and the other. ",
+        "bbox": [
+            174,
+            696,
+            826,
+            849
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We further utilize the concept of the memory tokens to the videos. Using Inter-frame Communication Transformers, each frame runs independently while sharing their information with interim communications. The communications lead to higher accuracy while the execution independence between frames accelerates the inference. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/38190ff2e29f8cfb09f1e13cb0bf969f482baa8226d8a40c6907883122649d66.jpg",
+        "image_caption": [
+            "Figure 1: Overview of IFC framework. Our transformer encoder block has two components: 1) Encode-Receive $( \\mathcal { E } )$ simultaneously encodes frame tokens and memory tokens. 2) Only memory tokens pass Gather-Communicate $( { \\mathcal { G } } )$ to perform communications between frames. The output from the stack of $N _ { E }$ encoder blocks goes into two modules, spatial decoder and transformer decoder, to generate segmentation masks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            825,
+            306
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            406,
+            271,
+            422
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The proposed method follows a per-clip pipeline which takes a video clip as input and outputs clip-level results. We also introduce Inter-frame Communication Transformers, which can effectively share frame-wise information within a clip with a high efficiency. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Model architecture ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            494,
+            346,
+            510
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inspired by DETR [13], our network consists of a CNN backbone and transformer encoder-decoder layers (Fig. 1). The input clip is first independently embedded into a feature map through the backbone. Then, the embedded clip passes through our inter-frame communication encoder blocks that enrich the feature map by allowing information exchange between frames. Next, a set of transformer decoder layers that take the encoder outputs and object queries as inputs predict unique convolutional weights for each instance in the clip. Finally, the masks for each instance across the clip are computed in one shot by convolving the encoded feature map with the unique convolutional weight. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            617
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Backbone Given an input clip $\\{ x _ { i } \\} _ { i = 1 } ^ { T } \\ \\in \\ \\mathbb { R } ^ { T \\times H _ { 0 } \\times W _ { 0 } \\times 3 }$ , composed of $T$ frames with 3 color channels, the CNN backbone processes the input clip frame-by-frame. As the result, the clip is encoded into a set of low-resolution features, $\\bar { \\{ f _ { i } ^ { 0 } \\} _ { i = 1 } ^ { T } } \\in \\mathbb { R } ^ { T \\times H \\times W \\times C }$ , where $C$ is the number of channels and $\\begin{array} { r } { H , W = \\frac { H _ { 0 } } { 3 2 } , \\frac { W _ { 0 } } { 3 2 } } \\end{array}$ . ",
+        "bbox": [
+            174,
+            630,
+            825,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inter-Frame Communication Encoder Given an image, humans can effortlessly summarize the scene with only a few words. Also, frames from a same video share a lot of commonalities, the difference between them is sufficiently summarized and communicated even with a small bandwidth. Based on this hypothesis, we propose an inter-frame communication encoder to make the computation to be mostly frame-wise independent with some communications between frames. Specifically, we adopt memory tokens for both summarizing per-frame scenes and the means of communications. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our encoder blocks are composed of two phases of separate transformers: Encode-Receive $( \\mathcal { E } )$ and Gather-Communicate $( { \\mathcal { G } } )$ . Both Encode-Receive and Gather-Communicate follow the typical transformer encoder architecture [14], which consists of an addition of fixed positional encoding, a multi-head self-attention module, and a feed forward network. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Encode-Receive operates in a per-frame manner, taking a frame-level feature map and corresponding memory tokens. Passing through Encode-Receive, we expect two functionalities: (1) image features encode per-frame information to the memory tokens, and (2) image features receive information of different frames that are gathered in the memory tokens. Gather-Communicate operates across frames to form a clip-level knowledge. It takes the memory tokens from each frame as inputs and performs communications between frames. Alternating two phases through multiple layers, the encoder can efficiently learn consensus representations across frames. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/2778f3271558aa37551fff29a82d9708bb645857c02dc5d266ffa8b91f63e862.jpg",
+        "table_caption": [
+            "Table 1: Complexity comparison. Various transformer encoders for space-time input. As the overall FLOPs can vary by the number of detected instances, listed values are measured only at the encoders. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Communication Type</td><td rowspan=\"3\">Complexity per Layer</td><td colspan=\"4\">FLOPs (G)1</td></tr><tr><td></td><td>360 × 640</td><td></td><td>720×1280</td></tr><tr><td>T=5</td><td>T=36</td><td>T=5</td><td>T=36</td></tr><tr><td>No Comm</td><td>O(C²THW + CT(HW)2)</td><td>5.17</td><td>37.23</td><td>24.62</td><td>177.29</td></tr><tr><td>Full THW</td><td>O(C²THW + C(THW)2)</td><td>6.94</td><td>148.70</td><td>50.63</td><td>1815.38</td></tr><tr><td>Decompose T-HW</td><td>O(C²THW + CT(HW)² + CT²HW)</td><td>8.33</td><td>60.24</td><td>36.73</td><td>265.50</td></tr><tr><td>IFC (M = 8)</td><td>O(C²THW +CT(HW)2)</td><td>5.52</td><td>39.73</td><td>25.05</td><td>180.39</td></tr></table>",
+        "bbox": [
+            173,
+            126,
+            821,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            261,
+            825,
+            304
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In more detail, given the frame embedding $\\{ f _ { i } ^ { 0 } \\} _ { i = 1 } ^ { T }$ , we spatially flatten each feature $\\mathbb { R } ^ { H \\times W \\times C } $ $\\mathbb { R } ^ { H W \\times C }$ . The initial memory tokens $m ^ { 0 }$ of size $M$ are copied per frame and concatenated to each frame feature as follows: ",
+        "bbox": [
+            173,
+            308,
+            825,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e4b554f7c3b51d417e4fa32104b4e1afaf99cea19f48f18c3f542f26fc18db65.jpg",
+        "text": "$$\n[ f _ { t } ^ { 0 } , m _ { t } ^ { 0 } ] \\in \\mathbb { R } ^ { ( H W + M ) \\times C } , \\qquad t \\in \\{ 1 , 2 , \\cdots , T \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            358,
+            663,
+            377
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $[ \\cdot , \\cdot ]$ indicates a concatenation of two feature vectors. Note that the initial memory tokens $m ^ { 0 }$ are trainable parameters learnt during training. ",
+        "bbox": [
+            173,
+            383,
+            823,
+            414
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The first phase of IFC is Encode-Receive, which processes frames individually as follows: ",
+        "bbox": [
+            171,
+            417,
+            764,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/83fbfa4a19e414b3cff0aa02cd7f01046ec0f97e1c0c8e04bed22a54a7f98810.jpg",
+        "text": "$$\n[ f _ { t } ^ { l } , \\widehat { m } _ { t } ^ { l } ] = \\mathcal { E } ^ { l } ( [ f _ { t } ^ { l - 1 } , m _ { t } ^ { l - 1 } ] ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            440,
+            594,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\mathcal { E } } ^ { l }$ denotes the $l$ -th Encode-Receive layer. With a self-attention computed over the frame pixel locations and the memory tokens, the information of each frame can be passed to the memory tokens and vise-versa. ",
+        "bbox": [
+            176,
+            467,
+            826,
+            510
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The outputs of Encode-Receive are grouped by memory indices and formulate the inputs for GatherCommunicate layer. The grouping can be understood as a decomposition of memory tokens, and becomes computationally beneficial when the total size of gathered memory tokens increases. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/826462796f0e0ff15e14208c5e355a04a4b54bcc9c8e69822d8f63c911cb9cb9.jpg",
+        "text": "$$\n\\begin{array} { r l } & { [ m _ { 1 } ^ { l } ( i ) , m _ { 2 } ^ { l } ( i ) , \\cdots , m _ { T } ^ { l } ( i ) ] = \\mathcal { G } ^ { l } ( [ \\widehat { m } _ { 1 } ^ { l } ( i ) , \\widehat { m } _ { 2 } ^ { l } ( i ) , \\cdots , \\widehat { m } _ { T } ^ { l } ( i ) ] ) , \\qquad i \\in \\{ 1 , 2 , \\cdots , M \\} , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            564,
+            781,
+            584
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { G } ^ { l }$ denotes the $l$ -th Gather-Communicate layer. The processed outputs are redistributed to the originated frame and get concatenated as $m _ { t } \\overset { \\cdot } { = } \\left[ m _ { t } ( 1 ) , \\overset { \\cdot } { m } _ { t } ( 2 ) , \\cdot \\cdot \\cdot , \\overset { \\cdot } { m } _ { t } ( M ) \\right]$ . Unlike EncodeReceive, Gather-Communicate utilizes the attention mechanism to convey the information from different frames over the input clip. ",
+        "bbox": [
+            173,
+            590,
+            826,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Defining the $l$ -th inter-frame encoder block $( \\mathrm { I F C } ^ { l } )$ as ${ \\mathcal { E } } ^ { l }$ followed by $\\mathcal { G } ^ { l }$ , the stack of $N _ { E }$ encoder blocks can be inductively formulated as: ",
+        "bbox": [
+            174,
+            654,
+            823,
+            684
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/12201cbca6981cd6046b05a17f902beadf6a56e673115e912cbb891df68857c4.jpg",
+        "text": "$$\n[ f _ { t } ^ { l } , m _ { t } ^ { l } ] = \\mathrm { I F C } ^ { l } ( [ f _ { t } ^ { l - 1 } , m _ { t } ^ { l - 1 } ] ) , \\qquad 1 \\leq l \\leq N _ { E } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            690,
+            665,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\left[ f _ { t } ^ { N _ { E } } , m _ { t } ^ { N _ { E } } \\right]$ is the final result. The stacking of multiple encoder layers brings communications between frames, thus each frame can have coincidence to the other, specifying the identities of instances in a given clip. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Complexity comparison In Table 1, we analyze the computational complexity of transformer encoder variants applied for video input in terms of the Big-O complexity and FLOPs. The complexity of the original transformer encoder layer [14] is $\\mathcal { O } ( C ^ { 2 } N ^ { ' } { + } C N ^ { 2 } )$ , where $N$ is the number of inputs. Without any communication between frames, No Comm, it shows the smallest amount of computation $( { \\mathcal O } ( C ^ { 2 } T \\dot { H W } + C T ( H W ) ^ { 2 } ) )$ ). As indicated as Full THW in Table 1, the complexity of VisTR [11] that performs a full space-time self-attention is $\\mathcal { O } ( C ^ { 2 } ( T H W ) + C ( T H W ) ^ { 2 } )$ thus either a higher resolution or an increase of number of input frames leads to a massive increase in computations. VisTR bypasses the problem by highly reducing the input resolution and utilizing GPUs with tremendous memory capacity. However, as such solutions cannot resolve the fundamental issues, it is impractical to real-world videos. Moreover, VisTR remains as a complete offline strategy because it takes the entire video as an input. ",
+        "bbox": [
+            173,
+            775,
+            826,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An intriguing improvement for the naïve full self-attention would be the decomposition of the attention into space and time axis [16, 17, 26]. In Decompose T-HW, we decompose attention computation into spatial and temporal attention. The complexity of the separation of space-time leads to the sum of the two transformer encoder: $\\mathcal { O } ( T ( C ^ { 2 } ( H \\bar { W } ) + \\bar { C } ( H W ) ^ { 2 } ) )$ and $\\mathcal { O } ( H \\bar { W } ( C ^ { 2 } T + C T ^ { 2 } ) )$ . In comparison to the full self-attention, the decomposition lowers the computational growth relative to the number of frames. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our encoder, IFC, that communicates between frames using the memory tokens leads to a huge benefit to the total computations adding only a small amount of computation over No Comm while providing sufficient channels for communication. The complexity of each phase in our proposed encoder is: $\\mathcal { O } ( C ^ { 2 } T ( H W + M ) + C T ( H W + M ) ^ { 2 } )$ for Encode-Receive and $\\mathcal { O } ( C ^ { 2 } T M + \\bar { C } \\bar { T } ^ { 2 } M )$ for Gather-Communicate respectively. Assuming that $M$ is kept small (e.g., 8), the computation needed for Gather-Communicate can be neglected, while the complexity of Encode-Receive can be approximated to $\\mathcal { O } ( C ^ { 2 } T H W + C T ( H W ) ^ { 2 } )$ as shown in Table 1. Finally, with respect to the number of frames of the input, we can expect approximate linear increase rather than the high increase of computation occurred in VisTR. ",
+        "bbox": [
+            173,
+            228,
+            825,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Decoders and output heads As depicted in Fig. 1, the transformer decoder of our model is stacked with $N _ { D }$ layers [14]. Contrary to VisTR, where the number of object queries increases proportionally to the number of frames, our model receives learnt encodings of fixed size $N _ { q }$ for object queries. Also, by utilizing these encodings throughout the entire frames, our model can effectively deal with clips of various lengths. A set of projection matrices are applied to $\\{ f _ { t } ^ { N _ { E } } , m _ { t } ^ { N _ { E } } \\} _ { t = 1 } ^ { T }$ for the generation of keys and values. The object queries turn into output embeddings by the transformer decoder, and the embeddings are eventually used as an input to the output heads. ",
+        "bbox": [
+            173,
+            367,
+            825,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There are two output heads on top of the transformer decoder, a class head and a segmentation head, each composed of two fully-connected layers. The output embeddings from the transformer decoder are independently inserted to the heads, resulting in $N _ { q }$ predictions per a clip. The class head outputs a class probability distribution of instances $\\hat { p } ( c ) \\in \\mathbb { R } ^ { N _ { q } \\times | \\mathbb { C } | }$ . Note that the possible classes $\\mathbb { C } \\ni c$ include no object $\\mathcal { D }$ class in addition to the given classes of a dataset. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The segmentation head generates $N _ { q }$ conditional convolutional weights $w \\in \\mathbb { R } ^ { N _ { q } \\times C }$ in a manner similar to [7, 20]. For the conditional convolution, the output feature of the encoder reused by undoing the flatten operation. For the upsampling, the encoder feature pa $\\{ f _ { t } ^ { N _ { E } } \\} _ { t = 1 } ^ { T }$ isgh fpn-style [27] spatial decoder without temporal connections resulting in $T$ feature maps that are $1 / 8$ of the input resolution. Finally, the resulting feature maps $f ^ { \\prime }$ are convolved with each convolutional weight to generate a segmentation mask as follows: ",
+        "bbox": [
+            173,
+            550,
+            825,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f866c1f8d7c32e015f24637c2e527d6695ac75ee24e332d9eb40e370b70203ec.jpg",
+        "text": "$$\n\\hat { s } _ { i } = \\{ f _ { t } ^ { \\prime } \\circ w _ { i } \\} _ { t = 1 } ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            643,
+            562,
+            662
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $w _ { i }$ is $i$ -th convolutional weight, $\\circ$ indicate $1 \\times 1$ spatial convolution operation, and the result $\\hat { s _ { i } }$ is a spatial-temporal object mask in shape of $\\mathbb { R } ^ { T \\times H ^ { \\prime } \\times W ^ { \\prime } }$ where $\\begin{array} { r } { H ^ { \\prime } = \\frac { H _ { 0 } } { 8 } } \\end{array}$ , $\\begin{array} { r } { W ^ { \\prime } = \\frac { W _ { 0 } } { 8 } } \\\\ { . } \\end{array}$ . Note that, for an instance, a common weight is applied throughout the video clip. Our spatial decoder is an instanceagnostic design, which is much more efficient than instance-specific decoders [10, 11, 12, 13] as the number of detected instances increases. Meanwhile, thanks to our segmentation head which specifies and captures the characteristics of an instance, IFC can conduct both segmentation and tracking at once within a clip. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Instance matching and loss ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            782,
+            400,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To train our network, we first assign the ground truth for each instance estimation and then a set of loss function between each the ground truth and prediction pair. For a given input clip, our model generate a fixed-size set of class-labeled masks $\\{ \\hat { y } _ { i } \\} _ { i = 1 } ^ { N _ { q } } = \\{ ( \\hat { p } _ { i } ( \\boldsymbol { c } ) , \\hat { s } _ { i } ) \\} _ { i = 1 } ^ { N _ { q } }$ . The ground truth set of the clip can be represented as $y _ { i } = ( c _ { i } , s _ { i } )$ ; $c _ { i }$ is the target class label including $\\mathcal { D }$ , and $s _ { i }$ is the target mask which is down-sampled to the size of the prediction masks for efficient similarity calculation. One-to-one bipartite matching between the prediction set $\\{ \\hat { y } _ { i } \\} _ { i = 1 } ^ { N _ { q } }$ and the ground truth set $\\{ y _ { i } \\} _ { i = 1 } ^ { K }$ is performed to find the best assignment of a prediction to a ground truth. The objective can be formally ",
+        "bbox": [
+            173,
+            808,
+            826,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "described as: ",
+        "bbox": [
+            173,
+            92,
+            259,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb019df8ddd4dd097b5a31d29542133f0c5bd974273ae59f3e201ecf228fb3e4.jpg",
+        "text": "$$\n\\hat { \\sigma } = \\underset { \\sigma \\in \\mathfrak { S } _ { N _ { q } } } { \\arg \\operatorname* { m a x } } \\sum _ { i = 1 } ^ { K } \\sin ( y _ { i } , \\hat { y } _ { \\sigma ( i ) } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            102,
+            604,
+            145
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\sin ( y _ { i } , \\hat { y } _ { \\sigma ( i ) } )$ refers a pair-wise similarity over a permutation of $\\underset { \\_ w } { \\sigma } \\in \\mathfrak { S } _ { N _ { g } }$ . Following prior work [13, 20, 28], the bipartite matching is efficiently computed using Hungarian algorithm [19]. We find that box-based similarity measurement as used in DETR [13] shows weaknesses in matching instances in video clip due to the case of occlusion and disappear-and-reappear. Therefore, we define $\\sin ( y _ { i } , \\hat { y } _ { \\sigma ( i ) } )$ to be mask-based term as $\\mathbb { 1 } _ { \\{ c _ { i } \\neq \\infty \\} } [ \\hat { p } _ { \\sigma ( i ) } ( c _ { i } ) + \\bar { \\lambda } _ { 0 } \\mathrm { D I C E } ( s _ { i } , \\bar { \\hat { s } } _ { \\sigma ( i ) } ^ { - } ) ]$ , where DICE denotes dice coefficients [29]. ",
+        "bbox": [
+            173,
+            146,
+            825,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given the optimal assignment $\\hat { \\sigma }$ , we refer to the $K$ matched predictions and $( N _ { q } - K )$ non-matched predictions as positive and negative pairs respectively. The positive pairs aim to predict the ground truth masks and classes while the negative pairs are optimized to predict the $\\mathcal { D }$ class. The final loss is a sum of the losses from positive pairs and negative pairs where each can be computed as follows: ",
+        "bbox": [
+            176,
+            236,
+            825,
+            292
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9b23e415d7a2efc89846c697f04f297d9fc9948c5400dcc957d4d7992db68d04.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { p o s } = \\displaystyle \\sum _ { i = 1 } ^ { K } [ \\underbrace { - \\log \\hat { p } _ { \\hat { \\sigma } ( i ) } ( c _ { i } ) } _ { \\mathrm { C r o s s - e n t r o p y ~ l o s s } } + \\lambda _ { 1 } ( \\underbrace { 1 - \\operatorname { D I C E } \\bigl ( s _ { i } , \\hat { s } _ { \\hat { \\sigma } ( i ) } \\bigr ) } _ { \\mathrm { D i c e ~ l o s s ~ } [ 2 9 ] } ) + \\lambda _ { 2 } \\underbrace { \\operatorname { F O C A L } \\bigl ( s _ { i } , \\hat { s } _ { \\hat { \\sigma } ( i ) } \\bigr ) } _ { \\mathrm { S i g m o i d - f o c a l ~ l o s s ~ } [ 3 0 ] } ] , } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\mathcal { L } _ { n e g } = \\displaystyle \\sum _ { i = k + 1 } ^ { N _ { q } } [ - \\log \\hat { p } _ { \\hat { \\sigma } ( i ) } ( \\emptyset ) ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            297,
+            754,
+            397
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As $( N _ { q } - K )$ is likely to be much greater than $K$ , we down-weight $\\mathcal { L } _ { n e g }$ by a factor of 10 to resolve the imbalance, following prior work [13]. The goal of video instance segmentation [1] is to maximize the space-time IoU between a prediction and a ground truth mask. Therefore, our mask-related losses (Dice loss and Sigmoid-focal loss) are spatio-temporally calculated over an entire clip, rather than averaging the losses that are accumulated frame-by-frame. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 Clip-level instance tracking ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            403,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To infer a video input that is longer than the clip length, we match instances using the predicted masks of overlapping frames. Let $\\mathcal { V } _ { I }$ and ${ \\mathcal { V } } _ { A }$ be the result sets of clip $I$ and $A$ excluding the $\\mathcal { D }$ class. The goal is to perform matching of same identities between pre-collected instance set $\\mathcal { V } _ { I }$ and $\\mathcal { V } _ { A }$ . We first calculate the matching scores which are space-time soft IoU at intersecting frames between $\\mathcal { V } _ { I }$ and $\\mathcal { V } _ { A }$ . Then, we find optimal paired indices $\\hat { \\sigma } _ { S }$ using Hungarian algorithm [19] to the gathered matching score $\\mathcal { S } \\in [ 0 , \\bar { 1 ] } ^ { | \\mathcal { N } _ { I } | \\times | \\bar { \\mathcal { V } } _ { A } | }$ . We update $\\mathscr { D } _ { I } ( i )$ by concatenating $\\mathcal { V } _ { A } ( \\hat { \\sigma } _ { S } ( i ) )$ if $\\bar { \\cal S } ( i , \\bar { \\sigma } s ( i ) )$ is above a certain threshold, and add non-matched prediction sets to $\\mathcal { V } _ { I }$ as new instances. Note that a previous per-clip model (MaskProp [10]) also utilizes soft IoU for tracking instances, but the matching scores are computed per-frame and averaged for intersecting frames. Different from MaskProp, using space-time soft IoU leads to an accurate tracking as it can better represent the definition of mask similarities between clips which brings at most $2 \\%$ AP increase. The overall tracking pipeline can be effectively implemented in a GPU-friendly manner. ",
+        "bbox": [
+            173,
+            512,
+            826,
+            680
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            699,
+            312,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the proposed method using YouTube-VIS 2019 and 2021 [1]. For every listed score, we report the mean of five runs as the results may vary by each run due to the insufficient number of training and testing set of YouTube-VIS dataset. We demonstrate the effectiveness of our model regarding both accuracy and speed. We further examine how different settings affect the overall performance and efficiency of IFC encoder. Unless specified, all models for measurements used $\\bar { N _ { E } } = 3 , \\bar { N _ { D } } = 3$ , stride of 1, and ResNet-50. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            830,
+            377,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We used detectron2 [33] for our code basis, and hyper-parameters mostly follow the settings of DETR [13] unless specified. We used AdamW [34] optimizer with initial learning rate of $1 0 ^ { - 4 }$ for transformers, and $1 \\bar { 0 } ^ { - 5 }$ for backbone. We first pre-train the model for image instance segmentation on COCO [35] by setting our model to $T = 1$ . The pre-train procedure follows the shortened training schedule of DETR [13], which runs 300 epochs with a decay of the learning rate by a factor of 10 at 200 epochs. Using the pre-trained weights, the models are trained on a targeted dataset using the batch size of 16, each clip composed of $T = 5$ frames downscaled to either $3 6 0 \\mathrm { p }$ or $4 8 0 \\mathrm { p }$ . For the sampling of each clip, a reference frame index $t$ is randomly chosen. The remaining $T - 1$ frame indices are then sampled within an interval of 20. The models are trained for 8 epochs, and decays the learning rate by 10 at 5th epoch. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8117fe1192cb18961b36b519cc6594c8dcf53d69eaf7891be356bd1f19b81efb.jpg",
+        "table_caption": [
+            "Table 2: Evaluations on various settings. ",
+            "(a) AP and FPS on YouTube-VIS 2019 val set. For fairness, FPS is measured on a same machine, using a single RTX 2080Ti GPU. We used the official codes and checkpoints provided by the authors for the measurements. We report the clip settings of [10, 11]. T : window size. ",
+            "(b) Accuracy on YTVIS 2021 val set ",
+            "(d) Effect of strides "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Method (Settings)</td><td>Backbone [31]</td><td>FPS²</td><td>AP</td><td>AP50</td><td>AP75</td><td>AR1</td><td>AR10</td></tr><tr><td rowspan=\"9\">prij.ite</td><td colspan=\"2\">MaskTrack R-CNN[1]</td><td>ResNet-50</td><td>26.1</td><td>30.3</td><td>51.1</td><td>32.6</td><td>31.0</td><td>35.5</td></tr><tr><td colspan=\"2\">MaskTrack R-CNN[1]</td><td>ResNet-101</td><td>=</td><td>31.8</td><td>53.0</td><td>33.6</td><td>33.2</td><td>37.6</td></tr><tr><td colspan=\"2\">SipMask [2]</td><td>ResNet-50</td><td>35.5</td><td>33.7</td><td>54.1</td><td>35.8</td><td>35.4</td><td>40.1</td></tr><tr><td colspan=\"2\">SG-Net [4]</td><td>ResNet-50</td><td>1</td><td>34.8</td><td>56.1</td><td>36.8</td><td>35.8</td><td>40.8</td></tr><tr><td colspan=\"2\">SG-Net [4]</td><td>ResNet-101</td><td>1</td><td>36.3</td><td>57.1</td><td>39.6</td><td>35.9</td><td>43.0</td></tr><tr><td colspan=\"2\">Cross VIS [3]</td><td>ResNet-50</td><td>=</td><td>36.3</td><td>56.8</td><td>38.9</td><td>35.6</td><td>40.7</td></tr><tr><td colspan=\"2\">Cross VIS [3]</td><td>ResNet-101</td><td>1</td><td>36.6</td><td>57.3</td><td>39.7</td><td>36.0</td><td>42.0</td></tr><tr><td colspan=\"2\">STEm-Seg [32]</td><td>ResNet-101</td><td>3.0</td><td>34.6</td><td>55.8</td><td>37.9</td><td>34.4</td><td>41.6</td></tr><tr><td rowspan=\"7\">VisTR[11]</td><td>VisTR[11]</td><td>(T=36)</td><td>ResNet-50</td><td>51.1</td><td>35.6</td><td>56.8</td><td>37.0</td><td>35.2</td><td>40.2</td></tr><tr><td></td><td>(T=36)</td><td>ResNet-101</td><td>43.5</td><td>38.6</td><td>61.3</td><td>42.3</td><td>37.6</td><td>44.2</td></tr><tr><td>MaskProp[10]</td><td>(T=13)</td><td>ResNet-50</td><td>1</td><td>40.0</td><td>1</td><td>42.9</td><td>1</td><td>-</td></tr><tr><td>MaskProp [10]</td><td>(T=13)</td><td>ResNet-101</td><td>1</td><td>42.5</td><td>1</td><td>45.6</td><td>1</td><td>1</td></tr><tr><td>OurSnear-online</td><td>(T=5)</td><td>ResNet-50</td><td>46.5</td><td>39.0</td><td>60.4</td><td>42.7</td><td>41.7</td><td>51.6</td></tr><tr><td>OurSoffline</td><td>(T=36)</td><td>ResNet-50</td><td>107.1</td><td>41.2</td><td>65.1</td><td>44.6</td><td>42.3</td><td>49.6</td></tr><tr><td>OurSoffline</td><td>(T=36)</td><td>ResNet-101</td><td>89.4</td><td>42.6</td><td>66.6</td><td>46.3</td><td>43.5</td><td>51.4</td></tr></table>",
+        "bbox": [
+            191,
+            164,
+            805,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/5ab3ca7c1737bd925d9ae4b548b92d8d15eff27f8f43313d185e2057fbaaf5f4.jpg",
+        "table_caption": [
+            "(c) Bipartite matching "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>AP</td></tr><tr><td>Box-based</td><td>37.5</td></tr><tr><td>Mask-based</td><td>39.6</td></tr></table>",
+        "bbox": [
+            434,
+            435,
+            555,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/02d3486867af5ac7a6130285042039e6ba267181f9277cc547809b1ae852f288.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>AP</td><td>AP50</td><td>AP75</td></tr><tr><td>MaskTrack-RCNN</td><td>28.6</td><td>48.9</td><td>29.6</td></tr><tr><td>SipMask</td><td>31.7</td><td>52.5</td><td>34.0</td></tr><tr><td>CrossVIS</td><td>34.2</td><td>54.4</td><td>37.9</td></tr><tr><td>Ours</td><td>35.2</td><td>57.2</td><td>37.5</td></tr></table>",
+        "bbox": [
+            174,
+            426,
+            416,
+            492
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ac98e7dbd4939eaaab0aeaf8797477a7278c98fd33b3f68dcef33538aa21f86f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>AP</td><td>AP75</td><td>FPS</td></tr><tr><td>T=5</td><td>S=3 S=5</td><td>38.7 42.1</td><td>72.7</td></tr><tr><td>T=10</td><td>39.5</td><td>42.8</td><td>83.0</td></tr><tr><td>T=15 S=8</td><td>39.7</td><td>43.0</td><td>92.5</td></tr><tr><td>T=20 S=10</td><td>40.4</td><td>43.3</td><td>95.7</td></tr></table>",
+        "bbox": [
+            584,
+            426,
+            813,
+            492
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            512,
+            825,
+            595
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "During inference, our model takes inputs as follows. Let an input video has $V$ frames, $T$ is the number of frames per clip and $S$ is the stride of clips. We start from inserting a clip of frame indices $[ 1 , T ]$ and sequentially insert clips of $[ 1 + S , T + \\bar { S } ] , [ 1 + 2 S , T + 2 S ] , \\therefore , [ 1 + n S , T + n S ]$ . It repeats until the end frame index $T + n S$ is equal to or greater than $V$ . If the end frame index of the last clip $T + n S$ is greater than $V$ , we change the frame indices of the last clip to $[ V - T + 1 , V ]$ . The resolution of input videos are downscaled to $3 6 0 \\mathrm { p }$ , which follows MaskTrack R-CNN [1]. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            685
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Main Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            702,
+            305,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "YouTube-VIS 2019 evaluation results We compare our proposed IFC to the state-of-the-art models in the video instance segmentation task on YouTube-VIS $2 0 1 9 \\ \\mathtt { v a l }$ in Table 2 (a). We measure the accuracy by AP and our model sets the highest score among all online, near-online, and offline models while presenting the fastest runtime. As mentioned earlier, IFC is highly efficient during the inference thanks to three advantages: (1) memory token-based decomposition for transformer encoder (2) instance-agnostic spatial decoder (3) GPU-friendly instance matching. Moreover, our model does not make use of any heavy modules such as deformable convolutions [36] or cascading networks [37]. Thanks to these advantages, IFC achieves an outstanding runtime, which is faster speed than online models [1, 2]. ",
+        "bbox": [
+            173,
+            727,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "During the inference, our method is able to freely adjust the length of the clip $( T )$ as needed. If the input clip length is set to contain entire video frames, our method becomes an offline method (like ",
+        "bbox": [
+            176,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/670bbd204f67e3d539074c5cfb25f24385665e804acb9763ac21417ab8d1c742.jpg",
+        "image_caption": [
+            "Figure 2: Visualization of predictions from VisTR and our model. Instances with the same identity are displayed in the same color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            88,
+            823,
+            396
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "VisTR [11]) that processes the entire video in one shot. As the offline inference can skip matching between clips and maximize the GPU utilization, our method represents surprisingly fast runtime (107.1 FPS). On the other hand, if the application requires instant outputs given a video stream, we can reduce the clip length to make our method near-online. In the near-online scenario with $T = 5$ our system is still able to process a video in real-time (46.5 FPS) with only a small delay. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            517
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "YouTube-VIS 2021 evaluation results The recently introduced dataset YouTube-VIS 2021 is an improved version of YouTube-VIS 2019. The newly added videos in the dataset include higher number of instances and frames. For the new dataset, we use 32 memory tokens. In Table 2 (b), we refer the results reported in [3], which evaluated [1, 2] using official implementations. Again, our model achieves the best performance. ",
+        "bbox": [
+            174,
+            532,
+            823,
+            603
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Qualitative result comparison We compare some qualitative results predicted by our model and VisTR [11] in Fig. 2. In terms of both tracking accuracy and segmentation quality, IFC yields better results than VisTR. ",
+        "bbox": [
+            174,
+            617,
+            823,
+            659
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Ablation Study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            675,
+            316,
+            690
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide ablation studies and discuss how different settings impact the overall performance. The experiments are conducted using YouTube-VIS 2019 val set. ",
+        "bbox": [
+            174,
+            700,
+            823,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Box-based and mask-based bipartite matching We observe how the different policies for bipartite matching affect the performance. As our model does is a box-free method, we adjust our model to predict bounding boxes similar to VisTR [11] and conduct bipartite matching [13, 19] using the predicted boxes. The change of optimization from mask-based to box-based brings a noticeable performance drop as shown in Table 2 (c). With the VIS-centric design, the mask-based optimization shows more robustness than box-based optimizations under typical video circumstances such as instances with heavy overlaps and partial occlusions. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            840
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Differing window strides In addition to the clip length $T$ , we further optimize our runtime placing a stride $S$ between clips, as shown in Table 2 (d). IFC can be used in a near-online manner, which takes clips that are consecutively extracted from a video. The placement of a larger stride reduces temporal intersections, which lessens computational overheads but also causes difficulty in matching instances. By enlarging the stride from $S = 1$ to $S = 3$ , IFC accomplishes approximately $150 \\%$ speed improvement with only $0 . 1 \\%$ AP drop. The tendency of high speed gain and low accuracy drop persists under various conditions. Therefore, our model can be applied to conditions where the enlargement of strides is necessary, i.e., using devices that are not powerful enough but has to maintain high inference speed. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/88c13316f2d0a9844c2c8e721ac46405845d71124807c943ba03f119e9f6101d.jpg",
+        "table_caption": [
+            "Table 3: Encoder variations. We show how different encoders affect the overall performance. ",
+            "(a) Various encoders taking clips of different lengths (see Table 1) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">T=5</td><td colspan=\"3\">T=10</td><td colspan=\"3\">T=15</td><td colspan=\"3\">T=20</td></tr><tr><td></td><td>AP</td><td>AP75</td><td>FPS</td><td>AP</td><td>AP75</td><td>FPS</td><td>AP</td><td>AP75</td><td>FPS</td><td>AP</td><td>AP75</td><td>FPS</td></tr><tr><td>No Comm</td><td>37.4</td><td>39.9</td><td>38.1</td><td>38.8</td><td>41.6</td><td>40.8</td><td>39.3</td><td>41.7</td><td>46.7</td><td>39.6</td><td>41.9</td><td>52.9</td></tr><tr><td>Full THW</td><td>37.2</td><td>40.0</td><td>37.6</td><td>38.8</td><td>41.2</td><td>35.5</td><td>39.8</td><td>42.6</td><td>32.9</td><td>39.7</td><td>42.8</td><td>34.8</td></tr><tr><td>Decomp T-HW</td><td>37.2</td><td>39.8</td><td>35.7</td><td>38.3</td><td>40.9</td><td>37.9</td><td>38.5</td><td>41.5</td><td>42.6</td><td>39.0</td><td>41.9</td><td>49.4</td></tr><tr><td>IFC</td><td>39.0</td><td>42.7</td><td>36.3</td><td>39.6</td><td>43.0</td><td>38.9</td><td>39.8</td><td>43.0</td><td>43.7</td><td>40.4</td><td>43.4</td><td>50.2</td></tr></table>",
+        "bbox": [
+            200,
+            140,
+            795,
+            223
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/debc584ae906fc54321b5664cf7d19a77a9a1664305f2a25e5ab8dde23604c8c.jpg",
+        "table_caption": [
+            "(b) Image instance segmentation on COCO val set ",
+            "(c) Number of memory tokens (AP) ",
+            "(d) Index-wise memory decomposition "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>T=5</td><td>T=10</td><td>T=15</td><td>T=20</td></tr><tr><td>M=1</td><td>37.6</td><td>39.2</td><td>39.4</td><td>39.4</td></tr><tr><td>M=2</td><td>37.9</td><td>39.2</td><td>39.6</td><td>39.8</td></tr><tr><td>M=4</td><td>38.0</td><td>39.5</td><td>39.7</td><td>39.9</td></tr><tr><td>M=8</td><td>39.0</td><td>39.6</td><td>39.8</td><td>40.4</td></tr><tr><td>M=16</td><td>38.1</td><td>39.1</td><td>39.7</td><td>39.9</td></tr></table>",
+        "bbox": [
+            356,
+            252,
+            576,
+            328
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/90345da31da3a96282ed6643f7f1dd5778c6427b3195e3ddd5654470ce88a6f0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>APCOcO</td><td>APOC</td></tr><tr><td>w/o mem</td><td>35.0</td><td>56.6</td></tr><tr><td>w/mem</td><td>35.1</td><td>56.5</td></tr></table>",
+        "bbox": [
+            176,
+            273,
+            346,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1234d522c58cf56d442e84da24a4460290fd027ec461ccc29f23126f2b2fdeb1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>T=5</td><td>T=10</td><td>T=15</td><td>T=20</td></tr><tr><td>Unified</td><td>38.1</td><td>38.9</td><td>39.7</td><td>39.9</td></tr><tr><td>Decomp</td><td>39.0</td><td>39.6</td><td>39.8</td><td>40.4</td></tr></table>",
+        "bbox": [
+            583,
+            267,
+            818,
+            314
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            342,
+            825,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Various decomposition strategies of encoders In Table 1, we observed the computational gaps derived from the decomposition of the encoder layers. Extending Table 1, we now investigate the how the decomposition strategies affect the accuracy in Table 3. ",
+        "bbox": [
+            174,
+            426,
+            820,
+            469
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The models are evaluated with variety of window sizes $( T = 5 , 1 0 , 1 5 , 2 0 )$ as an increase of window size $T$ has pros and cons. When matching predictions from different clips, greater $T$ is advantageous due to an enlargement of temporal intersections between clips. On the contrary, frames in longer clips are likely to be composed of diverse appearances, which disrupt tracking and segmenting instances within a clip. Therefore, the key to the performance enhancement is to cope with the appearance changes by precisely encoding and correlating space-time inputs. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            559
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 3 (a), the full self-attention [11] surpasses the encoder without communications as the length of clips increase. However, the enlargement of the window size highly slows down the inference speed, and the improvements are marginal that the tremendous computation and memory usage cannot be compensated. The decomposition of space-time maintains comparable speed even if the window is large, but fails to achieve high accuracy. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            635
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our model shows fast inference as the only additional computations of IFC are from utilizing a small number of memory tokens. Furthermore, by effectively encoding the space-time inputs with the communications between frames, IFC can take advantages of enlarging the window size, and surpasses other encoders. ",
+        "bbox": [
+            173,
+            640,
+            825,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Memory tokens We also study the effects of utilizing memory tokens. As mentioned, the motivation of using the memory tokens is to build communications between frames. Different from the video instance segmentation task, the image segmentation task is consisted of a single frame. Therefore, the use of the memory tokens does not lead to improvements to the image instance segmentation task as mutual communications cannot be solely made (see Table 3 (b)). Meanwhile, the utilization of the memory tokens achieves great improvements by effectively passing the information between frames. Results in Table 3 (a, c) demonstrate that the use of memory tokens achieves higher accuracy than the encoder without any communications (No comm), which emphasizes the importance of the communications. We evaluate how the size of the memory tokens affect the overall accuracy in Table 3 (c) and set the default size of the tokens $M$ to be 8. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Section 3.1, we demonstrated the formulation of the inputs for Gather-Communicate layer, which groups the outputs of Encode-Receive by memory indices. As aforementioned, the formulation can be considered as a decomposition of memory tokens: insertion to the Gather-Communicate layer by separate $M$ groups each consisting of $T$ tokens. In Table 3 (d), we investigate the impact of inserting the unified $M T$ tokens as a whole. Compared to the unified insertion, the decomposition brings better accuracy as the memories of same indices have more correspondences, which ease the encoders to build attentions in between. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b931f85da0d48797b1b4c756cba7dd5676ea7a6fc6286067da15b0c72e1db60.jpg",
+        "image_caption": [
+            "Figure 3: Visualizations of results and attention maps of memory tokens. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            823,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            353,
+            823,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We choose a memory index attending foreground instances and visualize the attention map in Fig. 3. As shown in the results of the upper clip, we find that the memory token has more interests to instances that are relatively difficult to detect; it more attends the heavily occluded car at the rear. The clip at the bottom is composed of frames with huge motion blurs and appearance changes. With the communications of memory tokens, IFC successfully tracks and segments the rabbit. ",
+        "bbox": [
+            174,
+            401,
+            825,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            299,
+            507
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have proposed a novel video instance segmentation network using Inter-frame Communication Transformers (IFC), which alleviates full space-time attention and successfully builds communications between frames. Finally, our network presents a rapid inference and sets the new state-of-the-art on the YouTube-VIS dataset. For the future work, we plan to integrate temporal information, which indeed would take a step further to the human video understanding. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            611,
+            328,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research was grant funded by the Artificial Intelligence Graduate School Program of Yonsei University, under Grant 2020-0-01361, Korea Evaluation Institute of Industrial Technology (KEIT) funded by the Ministry of Trade, Industry and Energy (10073129), and also supported by the Advanced Robotics Laboratory, part of the Future Technology Center at LG Electronics. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            698
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[2] Cao, J., R. M. Anwer, H. Cholakkal, et al. Sipmask: Spatial information preservation for fast image and video instance segmentation. In ECCV. 2020.   \n[3] Yang, S., Y. Fang, X. Wang, et al. Crossover learning for fast online video instance segmentation. In ICCV. 2021.   \n[4] Liu, D., Y. Cui, W. Tan, et al. Sg-net: Spatial granularity network for one-stage video instance segmentation. In CVPR. 2021.   \n[5] He, K., G. Gkioxari, P. Dollar, et al. Mask r-cnn. In ICCV. 2017.   \n[6] Bolya, D., C. Zhou, F. Xiao, et al. Yolact: Real-time instance segmentation. In ICCV. 2019.   \n[7] Tian, Z., C. Shen, H. Chen. Conditional convolutions for instance segmentation. In ECCV. 2020.   \n[8] Chen, H., K. Sun, Z. Tian, et al. Blendmask: Top-down meets bottom-up for instance segmentation. In CVPR. 2020.   \n[9] Luo, W., J. Xing, A. Milan, et al. Multiple object tracking: A literature review. Artificial Intelligence, 2020.   \n[10] Bertasius, G., L. Torresani. Classifying, segmenting, and tracking object instances in video with mask propagation. In CVPR. 2020.   \n[11] Wang, Y., Z. Xu, X. Wang, et al. End-to-end video instance segmentation with transformers. In CVPR. 2020.   \n[12] Lin, H., R. Wu, S. Liu, et al. Video instance segmentation with a propose-reduce paradigm. In ICCV. 2021.   \n[13] Carion, N., F. Massa, G. Synnaeve, et al. End-to-end object detection with transformers. In ECCV. 2020.   \n[14] Vaswani, A., N. Shazeer, N. Parmar, et al. Attention is all you need. In NeurIPS. 2017.   \n[15] Wang, H., Y. Zhu, B. Green, et al. Axial-deeplab: Stand-alone axial-attention for panoptic segmentation. In ECCV. 2020.   \n[16] Bertasius, G., H. Wang, L. Torresani. Is space-time attention all you need for video understanding? In ICML. 2021.   \n[17] Arnab, A., M. Dehghani, G. Heigold, et al. Vivit: A video vision transformer. arXiv preprint arXiv:2103.15691, 2021.   \n[18] Wang, X., R. Girshick, A. Gupta, et al. Non-local neural networks. In CVPR. 2018.   \n[19] Kuhn, H. W. The hungarian method for the assignment problem. In Naval research logistics quarterly. 1955.   \n[20] Wang, H., Y. Zhu, H. Adam, et al. Max-deeplab: End-to-end panoptic segmentation with mask transformers. In CVPR. 2021.   \n[21] Dosovitskiy, A., L. Beyer, A. Kolesnikov, et al. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR. 2021.   \n[22] Ranftl, R., A. Bochkovskiy, V. Koltun. Vision transformers for dense prediction. In ICCV. 2021.   \n[23] Devlin, J., M.-W. Chang, K. Lee, et al. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL. 2019.   \n[24] Touvron, H., M. Cord, M. Douze, et al. Training data-efficient image transformers & distillation through attention. In ICML. 2021.   \n[25] Kirillov, A., K. He, R. Girshick, et al. Panoptic segmentation. In CVPR. 2019.   \n[26] Tran, D., H. Wang, L. Torresani, et al. A closer look at spatiotemporal convolutions for action recognition. In CVPR. 2018.   \n[27] Lin, T.-Y., P. Dollar, R. Girshick, et al. Feature pyramid networks for object detection. In CVPR. 2017.   \n[28] Stewart, R., M. Andriluka, A. Y. Ng. End-to-end people detection in crowded scenes. In CVPR. 2016.   \n[29] Milletari, F., N. Navab, S.-A. Ahmadi. V-net: Fully convolutional neural networks for volumetric medical image segmentation. In 3DV. 2016.   \n[30] Lin, T.-Y., P. Goyal, R. Girshick, et al. Focal loss for dense object detection. In ICCV. 2017.   \n[31] He, K., X. Zhang, S. Ren, et al. Deep residual learning for image recognition. In CVPR. 2016.   \n[32] Athar, A., S. Mahadevan, A. Ošep, et al. Stem-seg: Spatio-temporal embeddings for instance segmentation in videos. In ECCV. 2020.   \n[33] Wu, Y., A. Kirillov, F. Massa, et al. Detectron2. https://github.com/facebookresearch/ detectron2, 2019.   \n[34] Loshchilov, I., F. Hutter. Decoupled weight decay regularization. In ICLR. 2019.   \n[35] Lin, T.-Y., M. Maire, S. Belongie, et al. Microsoft coco: Common objects in context. In ECCV. 2014.   \n[36] Dai, J., H. Qi, Y. Xiong, et al. Deformable convolutional networks. In ICCV. 2017.   \n[37] Cai, Z., N. Vasconcelos. Cascade r-cnn: Delving into high quality object detection. In CVPR. 2018. ",
+        "bbox": [
+            171,
+            136,
+            828,
+            910
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            830,
+            359
+        ],
+        "page_idx": 11
+    }
+]