Add files using upload-large-folder tool

parse/train/ByxtC2VtPB/ByxtC2VtPB.md

@@ -0,0 +1,409 @@
+# MIXUP INFERENCE: BETTER EXPLOITING MIXUP TO DEFEND ADVERSARIAL ATTACKS
+
+Tianyu Pang∗, Kun $\mathbf { X } \mathbf { u } ^ { * }$ , $\mathbf { J u n \ : Z h u } ^ { \dagger }$ Dept. of Comp. Sci. & Tech., BNRist Center, Institute for AI, Tsinghua University; RealAI $\{ { \tt p t y 1 7 } , { \tt x u - k 1 6 } \}$ @mails.tsinghua.edu.cn, dcszj@tsinghua.edu.cn
+
+# ABSTRACT
+
+It has been widely recognized that adversarial examples can be easily crafted to fool deep networks, which mainly root from the locally unreasonable behavior nearby input examples. Applying mixup in training provides an effective mechanism to improve generalization performance and model robustness against adversarial perturbations, which introduces the globally linear behavior in-between training examples. However, in previous work, the mixup-trained models only passively defend adversarial attacks in inference by directly classifying the inputs, where the induced global linearity is not well exploited. Namely, since the locality of the adversarial perturbations, it would be more efficient to actively break the locality via the globality of the model predictions. Inspired by simple geometric intuition, we develop an inference principle, named mixup inference (MI), for mixup-trained models. MI mixups the input with other random clean samples, which can shrink and transfer the equivalent perturbation if the input is adversarial. Our experiments on CIFAR-10 and CIFAR-100 demonstrate that MI can further improve the adversarial robustness for the models trained by mixup and its variants.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNNs) have achieved state-of-the-art performance on various tasks (Goodfellow et al., 2016). However, counter-intuitive adversarial examples generally exist in different domains, including computer vision (Szegedy et al., 2014), natural language processing (Jin et al., 2019), reinforcement learning (Huang et al., 2017), speech (Carlini & Wagner, 2018) and graph data (Dai et al., 2018). As DNNs are being widely deployed, it is imperative to improve model robustness and defend adversarial attacks, especially in safety-critical cases. Previous work shows that adversarial examples mainly root from the locally unstable behavior of classifiers on the data manifolds (Goodfellow et al., 2015; Fawzi et al., 2016; 2018; Pang et al., 2018b), where a small adversarial perturbation in the input space can lead to an unreasonable shift in the feature space.
+
+On the one hand, many previous methods try to solve this problem in the inference phase, by introducing transformations on the input images. These attempts include performing local linear transformation like adding Gaussian noise (Tabacof & Valle, 2016), where the processed inputs are kept nearby the original ones, such that the classifiers can maintain high performance on the clean inputs. However, as shown in Fig. 1(a), the equivalent perturbation, i.e., the crafted adversarial perturbation, is still $\delta$ and this strategy is easy to be adaptively evaded since the randomness of $\overline { { x } } _ { 0 }$ w.r.t $x _ { 0 }$ is local (Athalye et al., 2018). Another category of these attempts is to apply various non-linear transformations, e.g., different operations of image processing (Guo et al., 2018; Xie et al., 2018; Raff et al., 2019). They are usually off-the-shelf for different classifiers, and generally aim to disturb the adversarial perturbations, as shown in Fig. 1(b). Yet these methods are not quite reliable since there is no illustration or guarantee on to what extent they can work.
+
+On the other hand, many efforts have been devoted to improving adversarial robustness in the training phase. For examples, the adversarial training (AT) methods (Madry et al., 2018; Zhang et al., 2019; Shafahi et al., 2019) induce locally stable behavior via data augmentation on adversarial examples. However, AT methods are usually computationally expensive, and will often degenerate model performance on the clean inputs or under general-purpose transformations like rotation (Engstrom et al., 2019). In contrast, the mixup training method (Zhang et al., 2018) introduces globally linear behavior in-between the data manifolds, which can also improve adversarial robustness (Zhang et al., 2018; Verma et al., 2019a). Although this improvement is usually less significant than it resulted by AT methods, mixup-trained models can keep state-of-the-art performance on the clean inputs; meanwhile, the mixup training is computationally more efficient than AT. The interpolated AT method (Lamb et al., 2019) also shows that the mixup mechanism can further benefit the AT methods.
+
+![](images/013f06454d81dc2d0bb4afea6a087651a6f9632dfac778edf8d77e9b51209e19.jpg)  
+Figure 1: Intuitive mechanisms in the input space of different input-processing based defenses. $_ x$ is the crafted adversarial example, $x _ { 0 }$ is the original clean example, which is virtual and unknown for the classifiers. $\delta$ is the adversarial perturbation.
+
+However, most of the previous work only focuses on embedding the mixup mechanism in the training phase, while the induced global linearity of the model predictions is not well exploited in the inference phase. Compared to passive defense by directly classifying the inputs (Zhang et al., 2018; Lamb et al., 2019), it would be more effective to actively defend adversarial attacks by breaking their locality via the globally linear behavior of the mixup-trained models. In this paper, we develop an inference principle for mixup-trained models, named mixup inference (MI). In each execution, MI performs a global linear transformation on the inputs, which mixups the input $x$ with a sampled clean example $x _ { s }$ , i.e., $\tilde { x } = \lambda x + ( 1 - \lambda ) x _ { s }$ (detailed in Alg. 1), and feed $\tilde { x }$ into the classifier as the processed input.
+
+There are two basic mechanisms for robustness improving under the MI operation (detailed in Sec. 3.2.1), which can be illustrated by simple geometric intuition in Fig. 1(c). One is perturbation shrinkage: if the input is adversarial, i.e., $x = x _ { 0 } + \delta$ , the perturbation $\delta$ will shrink by a factor $\lambda$ after performing MI, which is exactly the mixup ratio of MI according to the similarity between triangles. Another one is input transfer: after the MI operation, the reduced perturbation $\lambda \delta$ acts on random $\tilde { x } _ { 0 }$ . Comparing to the spatially or semantically local randomness introduced by Gaussian noise or image processing, $\tilde { x } _ { 0 }$ introduces spatially global and semantically diverse randomness w.r.t $x _ { 0 }$ . This makes it less effective to perform adaptive attacks against MI (Athalye et al., 2018). Furthermore, the global linearity of the mixup-trained models ensures that the information of $x _ { 0 }$ remained in $\tilde { x } _ { 0 }$ is proportional to $\lambda$ , such that the identity of $x _ { 0 }$ can be recovered from the statistics of $\tilde { x } _ { 0 }$ .
+
+In experiments, we evaluate MI on CIFAR-10 and CIFAR-100 (Krizhevsky & Hinton, 2009) under the oblivious attacks (Carlini & Wagner, 2017) and the adaptive attacks (Athalye et al., 2018). The results demonstrate that our MI method is efficient in defending adversarial attacks in inference, and is also compatible with other variants of mixup, e.g., the interpolated AT method (Lamb et al., 2019). Note that Shimada et al. (2019) also propose to mixup the input points in the test phase, but they do not consider their method from the aspect of adversarial robustness.
+
+# 2 PRELIMINARIES
+
+In this section, we first introduce the notations applied in this paper, then we provide the formula of mixup in training. We introduce the adversarial attacks and threat models in Appendix A.1.
+
+# 2.1 NOTATIONS
+
+Given an input-label pair $( x , y )$ , a classifier $F$ returns the softmax prediction vector $F ( x )$ and the predicted label ${ \hat { y } } = \arg \operatorname* { m a x } _ { j \in [ L ] } F _ { j } ( x )$ , where $L$ is the number of classes and $[ L ] = \{ 1 , \cdots , L \}$ The classifier $F$ makes a correct prediction on $x$ if $y = \hat { y }$ . In the adversarial setting, we augment the
+
+data pair $( x , y )$ to a triplet $( x , y , z )$ with an extra binary variable $z$ , i.e.,
+
+$$
+z = { \left\{ \begin{array} { l l } { 1 , } & { { \mathrm { i f ~ } } x { \mathrm { ~ i s ~ a d v e r s a r i a l , } } } \\ { 0 , } & { { \mathrm { i f ~ } } x { \mathrm { ~ i s ~ c l e a n . } } } \end{array} \right. }
+$$
+
+The variable $z$ is usually considered as hidden in the inference phase, so an input $x$ (either clean or adversarially corrupted) can be generally denoted as $x = x _ { 0 } + \delta \cdot \mathbf { 1 } _ { z = 1 }$ . Here $x _ { 0 }$ is a clean sample from the data manifold $p ( x )$ with label $y _ { 0 }$ , $\mathbf { 1 } _ { z = 1 }$ is the indicator function, and $\delta$ is a potential perturbation crafted by adversaries. It is worthy to note that the perturbation $\delta$ should not change the true label of the input, i.e., $y = y _ { 0 }$ . For $\ell _ { p }$ -norm adversarial attacks (Kurakin et al., 2017; Madry et al., 2018), we have $\| \delta \| _ { p } \leq \epsilon$ , where $\epsilon$ is a preset threshold. Based on the assumption that adversarial examples are off the data manifolds, we formally have $x _ { 0 } + \delta \not \in \operatorname { s u p p } ( p ( x ) )$ (Pang et al., 2018a).
+
+# 2.2 MIXUP IN TRAINING
+
+In supervised learning, the most commonly used training mechanism is the empirical risk minimization (ERM) principle (Vapnik, 2013), which minimizes $\begin{array} { r } { \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathcal { L } ( F ( x _ { i } ) , y _ { i } ) } \end{array}$ on the training dataset $\mathbfcal { D } = \{ ( x _ { i } , \bar { y _ { i } } ) \} _ { i = 1 } ^ { n }$ with the loss function $\mathcal { L }$ . While computationally efficient, ERM could lead to memorization of data (Zhang et al., 2017) and weak adversarial robustness (Szegedy et al., 2014).
+
+As an alternative, Zhang et al. (2018) introduce the mixup training mechanism, which minimizes 1m Pmj=1 L(F (˜xj ), y˜j ). Here x˜j = λxj0 + (1 − λ)xj1; y˜j = λyj0 + (1 − λ)yj1, the input-label pairs $( x _ { j 0 } , y _ { j 0 } )$ and $( x _ { j 1 } , y _ { j 1 } )$ are randomly sampled from the training dataset, $\lambda \sim \operatorname { B e t a } ( \alpha , \alpha )$ and $\alpha$ is a hyperparameter. Training by mixup will induce globally linear behavior of models in-between data manifolds, which can empirically improve generalization performance and adversarial robustness (Zhang et al., 2018; Tokozume et al., 2018a;b; Verma et al., 2019a;b). Compared to the adversarial training (AT) methods (Goodfellow et al., 2015; Madry et al., 2018), trained by mixup requires much less computation and can keep state-of-the-art performance on the clean inputs.
+
+# 3 METHODOLOGY
+
+Although the mixup mechanism has been widely shown to be effective in different domains (Berthelot et al., 2019; Beckham et al., 2019; Verma et al., 2019a;b), most of the previous work only focuses on embedding the mixup mechanism in the training phase, while in the inference phase the global linearity of the trained model is not well exploited. Compared to passively defending adversarial examples by directly classifying them, it would be more effective to actively utilize the globality of mixup-trained models in the inference phase to break the locality of adversarial perturbations.
+
+# 3.1 MIXUP INFERENCE
+
+The above insight inspires us to propose the mixup inference (MI) method, which is a specialized inference principle for the mixup-trained models. In the following, we apply colored $y ,$ and $y _ { s }$ to visually distinguish different notations. Consider an input triplet $( x , y , z )$ , where $z$ is unknown in advance. When directly feeding $x$ into the classifier $F$ , we can obtain the predicted label $\hat { y }$ . In the adversarial setting, we are only interested in the cases where $x$ is correctly classified by $F$ if it is clean, or wrongly classified if it is adversarial (Kurakin et al., 2018). This can be formally denoted as
+
+$$
+\mathbf { 1 } _ { y \neq } \ = \mathbf { 1 } _ { z = 1 } .
+$$
+
+The general mechanism of MI works as follows. Every time we execute MI, we first sample a label $y _ { s } \sim p _ { s } ( y )$ , then we sample $x _ { s }$ from $p _ { s } ( x | y _ { s } )$ and mixup it with $x$ as $\tilde { x } = \lambda x + ( 1 - \lambda ) x _ { s }$ . $p _ { s } ( x , y )$ denotes the sample distribution, which is constrained to be on the data manifold, i.e., $\operatorname { s u p p } ( p _ { s } ( x ) ) \subset$ supp $( p ( x ) )$ . In practice, we execute $\mathbf { M I }$ for $N$ times and average the output predictions to obtain $F _ { \mathrm { M I } } ( x )$ , as described in Alg. 1. Here we fix the mixup ratio $\lambda$ in MI as a hyperparameter, while similar properties hold if $\lambda$ comes from certain distribution.
+
+# 3.2 THEORETICAL ANALYSES
+
+Theoretically, with unlimited capability and sufficient clean samples, a well mixup-trained model $F$ can be denoted as a linear function $H$ on the convex combinations of clean examples (Hornik et al., 1989; Guo et al., 2019), i.e., $\forall x _ { i } , x _ { j } \sim p ( x )$ and $\lambda \in [ 0 , 1 ]$ , there is
+
+$$
+H ( \lambda x _ { i } + ( 1 - \lambda ) x _ { j } ) = \lambda H ( x _ { i } ) + ( 1 - \lambda ) H ( x _ { j } ) .
+$$
+
+Algorithm 1 Mixup Inference (MI)   
+
+<table><tr><td>Input: The mixup-trained classifier F; the input x. Hyperparameters: The sample distribution ps; the mixup ratio 入; the number of execution N.</td></tr><tr><td>Initialize FM1(x) = O; for k = 1 to N do</td></tr><tr><td>Sample ys,k ~ps(ys),xs,k ~ps(xslys,k);</td></tr><tr><td>Mixup x with xs,k as xk = x +(1-λ)xs,k;</td></tr><tr><td>Update Fm1(x) =FM(x)+F(xk);</td></tr><tr><td>end for</td></tr><tr><td>Return: The prediction FM1(x) of input x.</td></tr></table>
+
+Specially, we consider the case where the training objective $\mathcal { L }$ is the cross-entropy loss, then $H ( x _ { i } )$ should predict the one-hot vector of label $y _ { i }$ , i.e., $H _ { y } ( x _ { i } ) = \mathbf { 1 } _ { y = y _ { i } }$ . If the input $x = x _ { 0 } + \delta$ is adversarial, then there should be an extra non-linear part $G ( \delta ; x _ { 0 } )$ of $F$ , since $x$ is off the data manifolds. Thus for any input $x$ , the prediction vector can be compactly denoted as
+
+$$
+F ( x ) = F ( x _ { 0 } + \delta \cdot \mathbf { 1 } _ { z = 1 } ) = H ( x _ { 0 } ) + G ( \delta ; x _ { 0 } ) \cdot \mathbf { 1 } _ { z = 1 } .
+$$
+
+According to Eq. (3) and Eq. (4), the output of $\tilde { x }$ in MI is given by:
+
+$$
+\begin{array} { r l r } {  { F ( \tilde { x } ) = H ( \tilde { x } _ { 0 } ) + G ( \lambda \delta ; \tilde { x } _ { 0 } ) \cdot \mathbf { 1 } _ { z = 1 } } } \\ & { } & { ~ = \lambda H ( x _ { 0 } ) + ( 1 - \lambda ) H ( x _ { s } ) + G ( \lambda \delta ; \tilde { x } _ { 0 } ) \cdot \mathbf { 1 } _ { z = 1 } , } \end{array}
+$$
+
+where $\tilde { x } _ { 0 } = \lambda x _ { 0 } + ( 1 - \lambda ) x _ { s }$ is a virtual unperturbed counterpart of $\tilde { x }$ as shown in Fig. 1(c). Note that $F _ { \mathrm { M I } } ( x )$ in Alg. 1 is a Monte Carlo approximation of $\mathbb { E } _ { p _ { s } } [ \bar { F } ( \tilde { x } ) ]$ as
+
+$$
+F _ { \mathrm { M I } } ( { \boldsymbol { x } } ) = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } F ( \tilde { { \boldsymbol { x } } } _ { i } ) \xrightarrow { \infty } \mathbb { E } _ { p _ { s } } [ F ( \tilde { { \boldsymbol { x } } } ) ] ,
+$$
+
+where $\xrightarrow { \infty }$ represents the limitation when the execution times $N \to \infty$ . Now we separately investigate the $y \cdot$ -th and $\hat { y }$ -th (could be the same one) components of $F ( \tilde { x } )$ according to Eq. (5), and see how these two components differ from those of $F ( x )$ . These two components are critical because they decide whether we can correctly classify or detect adversarial examples (Goodfellow et al., 2016). Note that there is $H _ { y } ( x _ { 0 } ) = 1$ and $\textit { H } \left( x _ { s } \right) = 1$ , thus we have the $y$ -th components as
+
+$$
+\begin{array} { r l } & { F _ { y } ( x ) = 1 + G _ { y } ( \delta ; x _ { 0 } ) \cdot \mathbf { 1 } _ { z = 1 } ; } \\ & { F _ { y } ( \tilde { x } ) = \lambda + ( 1 - \lambda ) \cdot \mathbf { 1 } _ { y = y _ { s } } + G _ { y } ( \lambda \delta ; \tilde { x } _ { 0 } ) \cdot \mathbf { 1 } _ { z = 1 } . } \end{array}
+$$
+
+Furthermore, according to Eq. (2), there is $\mathbf { 1 } _ { y = } ~ = \mathbf { 1 } _ { z = 0 }$ . We can represent the $\hat { y }$ -th components as
+
+$$
+\begin{array} { r l } & { F _ { \hat { y } } ( x ) = \mathbf { 1 } _ { z = 0 } + G _ { \hat { y } } ( \delta ; x _ { 0 } ) \cdot \mathbf { 1 } _ { z = 1 } ; } \\ & { F _ { \hat { y } } ( \tilde { x } ) = \lambda \cdot \mathbf { 1 } _ { z = 0 } + ( 1 - \lambda ) \cdot \mathbf { 1 } _ { \hat { y } = y _ { s } } + G _ { \hat { y } } ( \lambda \delta ; \tilde { x } _ { 0 } ) \cdot \mathbf { 1 } _ { z = 1 } . } \end{array}
+$$
+
+From the above formulas we can find that, except for the hidden variable $z$ , the sampling label $\cdot$ is another variable which controls the MI output $F ( \tilde { x } )$ for each execution. Different distributions of sampling $\cdot$ result in different versions of MI. Here we consider two easy-to-implement cases:
+
+MI with predicted label (MI-PL): In this case, the sampling label $\cdot$ is the same as the predicted label $\hat { y }$ , i.e., $p _ { s } ( y ) = \mathbf { 1 } _ { y = }$ is a Dirac distribution on $\hat { y }$ .
+
+MI with other labels (MI-OL): In this case, the label $y _ { s }$ is uniformly sampled from the labels other than $\cdot$ , i.e., $p _ { s } ( y ) = \mathcal { U } \ ( y )$ is a discrete uniform distribution on the set $\{ y \in [ L ] | y \neq \hat { y } \}$ .
+
+We list the simplified formulas of Eq. (7) and Eq. (8) under different cases in Table 1 for clear representation. With the above formulas, we can evaluate how the model performance changes with and without MI by focusing on the formula of
+
+$$
+\Delta F ( x ; p _ { s } ) = F _ { \mathrm { M I } } ( x ) - F ( x ) \stackrel { \infty } { \longrightarrow } \mathbb { E } _ { p _ { s } } [ F ( \tilde { x } ) ] - F ( x ) .
+$$
+
+Specifically, in the general-purpose setting where we aim to correctly classify adversarial examples (Madry et al., 2018), we claim that the MI method improves the robustness if the prediction
+
+Table 1: The the simplified formulas of Eq. (7) and Eq. (8) in different versions of MI. Here MI-PL indicates mixup inference with predicted label; MI-OL indicates mixup inference with other labels.
+
+$$
+\boxed  \begin{array} { c c }  \boxed  \begin{array} { c c }  \boxed  \begin{array} { c c }  \boxed   \begin{array} { c c }  \boxed { { \begin{array} { c c c } { \boxed { { { \begin{array} n { c c c } } { \boxed { { { \begin{array} n { c c c } } { \boxed { { { \begin{array} n { c c c } } { \boxed { { { \begin{array} n { c c c } } } { \boxed { { { \begin{ c c c c } } } { \boxed { { { \begin{ c c c c } } } \end{array} } } } } } } } } } } } \\ { \end{ \boxed { { { { \begin{array} { c c c } { \boxed { { { F \begin{array} { c c c } } { \boxed { { { \begin{array} 1 c c } } { \boxed { { { 1 } } } } } } } } \end{array} } } } } } } \\ { \end{array} \boxed { { { 1 \begin{array} {array} { c c c } { \boxed { { { 1 } } } } } \end{array} } } } \end{array} } } } } } } } &  \boxed  \begin{array} { c c } { \boxed { { \begin{array} { c c } { \boxed { { \begin{array} { c c c } { \boxed { { { \begin{array} } { c c c } { \boxed { { { \begin{array} } { c c c } } { \boxed { { { \begin{ c c c } } } { \boxed { { { \begin{ c c } } { \boxplus } } } } } \\ { z } } \end{array} } } } } } } \\ { \end{array} \boxed {array} { \begin{array} { c c } { \boxed { { \begin{array} { c c c } { \boxed { { { 1 } } } } } \end{array} } } } } \end{array} } } } } } &  \boxed   \begin{array} { c c }  \boxed  { \begin{array} { c c } { \boxed { { \begin{array} { c c c } { \boxed { { \begin{array} { c c c } } { \boxed { { { \begin{ c c c } } } { \boxed { { { \begin{ c c } } { \boxed { { 1 } } } } } } \\ { \end{ \begin{ c } { 1 } } } \end{array} } } } } } \\ { \end{array} \boxed { { \begin{array} { c c } { \boxed { { 1 } } } } \end{array} } } } } } \\  \end{array} \begin{array} { c }  \boxed   F \begin{array} { c c }  \boxed { { \begin{array} { c c } { \boxed { { \begin{array} { c c c } } { \boxed { { \begin{ c c } } { \boxed { { \begin{ c c } } { 1 } } } \end{array} } } } } \\ { \boxed { { \begin{array} { c c } { \boxed { { 1 } } } \end{array} } } } } \end{array} } \end{array} \end{array} \end{array} \end{array} \end{array} \end{array} \end{array} \end{array} \end{array} \end{array} \end{array} \end{array} \end{array} \end{array}
+$$
+
+value on the true label $y$ increases while it on the adversarial label $\hat { y }$ decreases after performing MI when the input is adversarial $z = 1$ ). This can be formally denoted as
+
+$$
+\Delta F _ { y } ( x ; p _ { s } ) | _ { z = 1 } > 0 ; \Delta F _ { \hat { y } } ( x ; p _ { s } ) | _ { z = 1 } < 0 .
+$$
+
+We refer to this condition in Eq. (10) as robustness improving condition (RIC). Further, in the detection-purpose setting where we want to detect the hidden variable $z$ and filter out adversarial inputs, we can take the gap of the $\hat { y }$ -th component of predictions before and after the MI operation, i.e., $\Delta F _ { \hat { y } } ( x ; p _ { s } )$ as the detection metric (Pang et al., 2018a). To formally measure the detection ability on $z$ , we use the detection gap (DG), denoted as
+
+$$
+\mathbb { D } \mathbb { G } = \Delta F \left. \left( x ; p _ { s } \right) \right| _ { z = 1 } - \Delta F \left. \left( x ; p _ { s } \right) \right| _ { z = 0 } .
+$$
+
+A higher value of DG indicates that $\Delta F \left( x ; p _ { s } \right)$ is better as a detection metric. In the following sections, we specifically analyze the properties of different versions of MI according to Table 1, and we will see that the MI methods can be used and benefit in different defense strategies.
+
+# 3.2.1 MIXUP INFERENCE WITH PREDICTED LABEL
+
+In the MI-PL case, when the input is clean (i.e., $z = 0$ ), there is $F ( x ) = F ( \tilde { x } )$ , which means ideally the MI-PL operation does not influence the predictions on the clean inputs. When the input is adversarial (i.e., $z = 1$ ), MI-PL can be applied as a general-purpose defense or a detection-purpose defense, as we separately introduce below:
+
+General-purpose defense: If MI-PL can improve the general-purpose robustness, it should satisfy RIC in Eq. (10). By simple derivation and the results of Table 1, this means that
+
+$$
+\begin{array} { r } { \mathbb { E } _ { x _ { s } \sim p _ { s } ( x \mid \mathbf { \theta } ) } \left[ G _ { k } ( \delta ; x _ { 0 } ) - G _ { k } ( \lambda \delta ; \tilde { x } _ { 0 } ) \right] \left\{ \begin{array} { l l } { > 1 - \lambda , } & { \mathrm { i f } \ k = \mathbf { \sigma } , } \\ { < \lambda - 1 , } & { \mathrm { i f } \ k = y . } \end{array} \right. } \end{array}
+$$
+
+Since an adversarial perturbation usually suppress the predicted confidence on the true label and promote it on the target label (Goodfellow et al., 2015), there should be $G _ { \hat { y } } ( \delta ; \tilde { x } _ { 0 } ) > 0$ and $G _ { y } ( \delta ; \tilde { x } _ { 0 } ) \dot { < } 0$ Note that the left part of Eq. (12) can be decomposed into
+
+$$
+\underbrace { \mathbb { E } _ { x _ { s } \sim p _ { s } ( x | \mathit { \Delta } ) } \left[ G _ { k } ( \delta ; x _ { 0 } ) - G _ { k } ( \delta ; \tilde { x } _ { 0 } ) \right] } _ { \mathrm { i n p u t t r a n s f e r } } + \underbrace { \mathbb { E } _ { x _ { s } \sim p _ { s } ( x | \mathit { \Delta } ) } \left[ G _ { k } ( \delta ; \tilde { x } _ { 0 } ) - G _ { k } ( \lambda \delta ; \tilde { x } _ { 0 } ) \right] } _ { \mathrm { p e r t u r b a t i o n ~ s h r i n k a g e } } .
+$$
+
+Here Eq. (13) indicates the two basic mechanisms of the MI operations defending adversarial attacks, as shown in Fig. 1(c). The first mechanism is input transfer, i.e., the clean input that the adversarial perturbation acts on transfers from the deterministic $x _ { 0 }$ to stochastic $\tilde { x } _ { 0 }$ . Compared to the Gaussian noise or different image processing methods which introduce spatially or semantically local randomness, the stochastic $\tilde { x } _ { 0 }$ induces spatially global and semantically diverse randomness. This will make it harder to perform an adaptive attack in the white-box setting (Athalye et al., 2018).
+
+The second mechanism is perturbation shrinkage, where the original perturbation $\delta$ shrinks by a factor $\lambda$ . This equivalently shrinks the perturbation threshold since $\| \lambda \bar { \delta } \| _ { p } = \lambda \| \delta \| _ { p } \leq \lambda \epsilon$ , which means that MI generally imposes a tighter upper bound on the potential attack ability for a crafted perturbation. Besides, empirical results in previous work also show that a smaller perturbation threshold largely weakens the effect of attacks (Kurakin et al., 2018). Therefore, if an adversarial attack defended by these two mechanisms leads to a prediction degradation as in Eq. (12), then applying MI-PL would improve the robustness against this adversarial attack. Similar properties also hold for MI-OL as described in Sec. 3.2.2. In Fig. 2, we empirically demonstrate that most of the existing adversarial attacks, e.g., the PGD attack (Madry et al., 2018) satisfies these properties.
+
+![](images/8011d76f4fd07cde5f4ef8c925c8a8adcf55ffa04bf99546f8331fb9ebb07475.jpg)  
+Figure 2: The results are averaged on 100 randomly test clean samples of CIFAR-10. The adversarial attack is untargeted PGD-10. Note that the $\Delta G _ { y }$ calculated here is the minus value of it in Eq. (12) and Eq. (15).
+
+Detection-purpose defense: According to Eq. (11), the formula of DG for MI-PL is
+
+$$
+\begin{array} { r } { \mathbb { D } \mathbb { G } _ { \mathrm { M I - P L } } = \mathbb { E } _ { { x _ { s } } \sim p _ { s } ( x | \hat { y } ) } [ G _ { \hat { y } } ( \delta ; x _ { 0 } ) - G _ { \hat { y } } ( \lambda \delta ; \tilde { x } _ { 0 } ) ] - ( 1 - \lambda ) . } \end{array}
+$$
+
+By comparing Eq. (12) and Eq. (14), we can find that they are consistent with each other, which means that for a given adversarial attack, if MI-PL can better defend it in general-purpose, then ideally MI-PL can also better detect the crafted adversarial examples.
+
+# 3.2.2 MIXUP INFERENCE WITH OTHER LABELS
+
+As to MI-OL, when the input is clean $z = 0$ ), there would be a degeneration on the optimal clean prediction as $F _ { y } ( \tilde { x } ) = F _ { \hat { y } } ( \tilde { x } ) = \lambda$ , since the sampled $x _ { s }$ does not come from the true label $y$ . As compensation, MI-OL can better improve robustness compared to MI-PL when the input is adversarial $z = 1$ ), since the sampled $x _ { s }$ also does not come from the adversarial label $\cdot$ in this case.
+
+General-purpose defense: Note that in the MI-OL formulas of Table 1, there is a term of $\mathbf { 1 } _ { y = }$ Since we uniformly select $y _ { s }$ from the set $[ L ] \setminus \{ \begin{array} { r l } \end{array} \}$ , there is $\begin{array} { r } { \mathbb { E } ( \mathbf { 1 } _ { y = y _ { s } } ) = \frac { 1 } { L - 1 } } \end{array}$ s ) = 1L−1 . According to the RIC, MI-OL can improve robustness against the adversarial attacks if there satisfies
+
+$$
+\begin{array} { r l r } { \mathbb { E } } & { \sim \mathcal { U } \operatorname { \langle \mu \rangle } \mathbb { E } _ { x _ { s } \sim p _ { s } ( x | \mathrm {  ~ \Lambda ~ } ) } \left[ G _ { k } ( \delta ; x _ { 0 } ) - G _ { k } ( \lambda \delta ; \tilde { x } _ { 0 } ) \right] \left\{ \begin{array} { l l } { > 0 , } & { \mathrm { i f ~ } k = { \it \Delta \phi } , } \\ { < \frac { ( \lambda - 1 ) ( L - 2 ) } { L - 1 } , } & { \mathrm { i f ~ } k = y . } \end{array} \right. } \end{array}
+$$
+
+Note that the conditions in Eq. (15) is strictly looser than Eq. (12), which means MI-OL can defend broader range of attacks than MI-PL, as verified in Fig. 2.
+
+Detection-purpose defense: According to Eq. (11) and Table 1, the DG for MI-OL is
+
+$$
+\mathbb { D } \mathbb { G } _ { \mathrm { M I } \mathrm { - } \mathrm { O L } } = \mathbb { E } _ { y _ { s } \sim \mathcal { U } _ { \hat { y } } ( y ) } \mathbb { E } _ { x _ { s } \sim p _ { s } ( x | y _ { s } ) } [ G _ { \hat { y } } ( \delta ; x _ { 0 } ) - G _ { \hat { y } } ( \lambda \delta ; \tilde { x } _ { 0 } ) ] - ( 1 - \lambda ) .
+$$
+
+It is interesting to note that $\mathbb { D } \mathbb { G } _ { \mathrm { M I \mathrm { - } P L } } = \mathbb { D } \mathbb { G } _ { \mathrm { M I \mathrm { - } O L } }$ , thus the two variants of MI have the same theoretical performance in the detection-purpose defenses. However, in practice we find that MI-PL performs better than MI-OL in detection, since empirically mixup-trained models cannot induce ideal global linearity (cf. Fig. 2 in Zhang et al. (2018)). Besides, according to Eq. (6), to statistically make sure that the clean inputs will be correctly classified after MI-OL, there should be $\forall k \in [ L ] \setminus \{ y \}$ ,
+
+$$
+\mathbb { E } _ { y _ { s } \sim \mathcal { U } _ { \hat { y } } ( y ) } \mathbb { E } _ { x _ { s } \sim p _ { s } ( x \mid y _ { s } ) } [ F _ { y } - F _ { k } ] > 0 \Longrightarrow \lambda > L ^ { - 1 } .
+$$
+
+# 4 EXPERIMENTS
+
+In this section, we provide the experimental results on CIFAR-10 and CIFAR-100 (Krizhevsky & Hinton, 2009) to demonstrate the effectiveness of our MI methods on defending adversarial attacks. Our codes are available at https://github.com/P2333/Mixup-Inference.
+
+Table 2: Classification accuracy $( \% )$ on the oblivious adversarial examples crafted on 1,000 randomly sampled test points of CIFAR-10. Perturbation $\epsilon = 8 / 2 5 5$ with step size 2/255. The subscripts indicate the number of iteration steps when performing attacks. The notation $\leq 1$ represents accuracy less than $1 \%$ . The parameter settings for each method can be found in Table 4.   
+
+<table><tr><td rowspan="3">Methods</td><td rowspan="3">Cle.</td><td colspan="4">Untargeted Mode</td><td colspan="3">Targeted Mode</td></tr><tr><td rowspan="2"></td><td colspan="3">PGD50</td><td colspan="3"></td></tr><tr><td>PGD10</td><td>PGD200</td><td></td><td>PGD10</td><td>PGD50</td><td>PGD200</td></tr><tr><td>Mixup</td><td>93.8</td><td>3.6</td><td>3.2</td><td>3.1</td><td>≤1</td><td></td><td>≤1</td><td>&lt;1</td></tr><tr><td>Mixup + Gaussian noise</td><td>84.4</td><td>13.5</td><td>9.6</td><td>8.8</td><td>37.7</td><td></td><td>28.6</td><td>27.9</td></tr><tr><td>Mixup + Random rotation</td><td>82.0</td><td>21.8</td><td>18.7</td><td>18.2</td><td>38.9</td><td></td><td>32.5</td><td>26.5</td></tr><tr><td>Mixup + Xie et al. (2018)</td><td>82.1</td><td>23.0</td><td>19.6</td><td>19.1</td><td>38.4</td><td></td><td>31.1</td><td>25.2</td></tr><tr><td>Mixup + Guo et al. (2018)</td><td>83.3</td><td>31.2</td><td>28.8</td><td>28.3</td><td>57.8</td><td></td><td>49.1</td><td>48.9</td></tr><tr><td>ERM + MI-OL (ablation study)</td><td>81.6</td><td>7.4</td><td>6.4</td><td>6.1</td><td>33.0</td><td></td><td>26.7</td><td>23.2</td></tr><tr><td>Mixup + MI-OL</td><td>83.9</td><td>26.1</td><td>18.8</td><td>18.3</td><td>55.6</td><td></td><td>51.2</td><td>50.8</td></tr><tr><td>Mixup + MI-Combined</td><td>82.9</td><td>33.7</td><td>31.0</td><td>30.7</td><td>56.1</td><td></td><td>49.7</td><td>49.4</td></tr><tr><td>Interpolated AT</td><td>89.7</td><td>46.7</td><td>43.5</td><td>42.5</td><td>65.6</td><td></td><td>62.5</td><td>61.9</td></tr><tr><td>Interpolated AT + Gaussian noise</td><td>84.7</td><td>55.6</td><td>53.7</td><td>53.5</td><td>70.1</td><td></td><td>69.1</td><td>69.0</td></tr><tr><td>Interpolated AT + Random rotation</td><td>83.4</td><td>57.8</td><td>56.7</td><td>55.9</td><td>69.8</td><td></td><td>68.2</td><td>67.4</td></tr><tr><td>Interpolated AT + Xie et al. (2018)</td><td>82.1</td><td>59.7</td><td>58.4</td><td>57.9</td><td>71.1</td><td></td><td>69.7</td><td>69.3</td></tr><tr><td>Interpolated AT + Guo et al. (2018)</td><td>83.9</td><td>60.9</td><td>60.7</td><td>60.3</td><td>73.2</td><td></td><td>72.1</td><td>71.6</td></tr><tr><td>AT + MI-OL (ablation study)</td><td>81.2</td><td>56.2</td><td>55.8</td><td>55.1</td><td>67.7</td><td></td><td>67.2</td><td>66.4</td></tr><tr><td>Interpolated AT + MI-OL</td><td>84.2</td><td>64.5</td><td>63.8</td><td>63.3</td><td>75.3</td><td></td><td></td><td>74.7</td></tr><tr><td>1</td><td>0.88 0.84</td><td>50</td><td>mixup + Gaussian noise</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>0.9</td><td></td><td>yXesareeer reras 45</td><td>mixup + Rotation</td><td>mixup + Xie et al. (2018)</td><td></td><td></td><td></td><td></td></tr><tr><td>0.78 0.8 0.72 0.7</td><td></td><td>40</td><td>ERM + MI-OL</td><td>mixup + Guo et al. (2018)</td><td>★</td><td></td><td>★</td><td></td></tr><tr><td>0.6</td><td></td><td>X*★ 35 30</td><td>mixup + MI-OL</td><td>mixup + MI-Combined</td><td></td><td>米</td><td>：</td><td>米</td></tr><tr><td>Random guess 0.5 0.4</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>0.3 0.23</td><td>25</td><td></td><td></td><td>A</td><td></td><td>+</td><td>+</td><td></td></tr><tr><td>0.2</td><td>20</td><td></td><td></td><td></td><td></td><td></td><td></td><td>× ×</td></tr><tr><td>0.080.05 0.1 0.01 0</td><td>15 10</td><td></td><td></td><td></td><td></td><td></td><td></td><td>+</td></tr><tr><td>Mixup Mixup + MI-PL</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>5</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PGD-10 (untargeted) PGD-50 (untargeted) PGD-10 (targeted) ■PGD-50(targeted)</td><td>0 0</td><td>102030405060708</td><td></td><td></td><td></td><td></td><td></td><td>8090100</td></tr><tr><td>(a) AUC scores</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td colspan="3"></td><td colspan="4">Accuracy on clean examples (%) (b) Adversarial accuracy w.r.t clean accuracy</td><td></td><td></td></tr></table>
+
+Figure 3: Results on CIFAR-10. (a) AUC scores on 1,000 randomly selected test clean samples and 1,000 adversarial counterparts crafted on these clean samples. (b) The adversarial accuracy w.r.t clean accuracy on 1,000 randomly selected test samples. The adversarial attack is untargeted PGD-10, with $\epsilon = 8 / 2 5 5$ and step size 2/255. Each point for a certain method corresponds to a set of hyperparameters.
+
+# 4.1 SETUP
+
+In training, we use ResNet-50 (He et al., 2016) and apply the momentum SGD optimizer (Qian, 1999) on both CIFAR-10 and CIFAR-100. We run the training for 200 epochs with the batch size of 64. The initial learning rate is 0.01 for ERM, mixup and AT; 0.1 for interpolated AT (Lamb et al., 2019). The learning rate decays with a factor of 0.1 at 100 and 150 epochs. The attack method for AT and interpolated AT is untargeted PGD-10 with $\epsilon = 8 / 2 5 5$ and step size $2 / 2 5 5$ (Madry et al., 2018), and the ratio of the clean examples and the adversarial ones in each mini-batch is $1 : 1$ (Lamb et al., 2019). The hyperparameter $\alpha$ for mixup and interpolated AT is 1.0 (Zhang et al., 2018). All defenses with randomness are executed 30 times to obtain the averaged predictions (Xie et al., 2018).
+
+# 4.2 EMPIRICAL VERIFICATION OF THEORETICAL ANALYSES
+
+To verify and illustrate our theoretical analyses in Sec. 3, we provide the empirical relationship between the output predictions of MI and the hyperparameter $\lambda$ in Fig. 2. The notations and formulas annotated in Fig. 2 correspond to those introduced in Sec. 3. We can see that the results follow our theoretical conclusions under the assumption of ideal global linearity. Besides, both MI-PL and MI-OL empirically satisfy RIC in this case, which indicates that they can improve robustness under the untargeted PGD-10 attack on CIFAR-10, as quantitatively demonstrated in the following sections.
+
+Table 3: Classification accuracy $( \% )$ on the oblivious adversarial examples crafted on 1,000 randomly sampled test points of CIFAR-100. Perturbation $\epsilon = 8 / 2 5 5$ with step size 2/255. The subscripts indicate the number of iteration steps when performing attacks. The notation $\leq 1$ represents accuracy less than $1 \%$ . The parameter settings for each method can be found in Table 5.   
+
+<table><tr><td rowspan=2 colspan=1>Methods</td><td rowspan=2 colspan=1>Cle.</td><td rowspan=2 colspan=3>Untargeted ModePGD10 PGD50  PGD200</td><td rowspan=2 colspan=3>Targeted ModePGD10 PGD50  PGD200</td></tr><tr><td rowspan=1 colspan=1>PGD50</td><td rowspan=1 colspan=1>PGD200</td><td rowspan=1 colspan=1>PGD10</td><td rowspan=1 colspan=1>PGD50</td></tr><tr><td rowspan=5 colspan=1>MixupMixup + Gaussian noiseMixup + Random rotationMixup + Xie et al. (2018)Mixup + Guo et al. (2018)</td><td rowspan=1 colspan=1>74.2</td><td rowspan=1 colspan=1>5.5</td><td rowspan=1 colspan=1>5.3</td><td rowspan=1 colspan=1>5.2</td><td rowspan=1 colspan=1>≤1</td><td rowspan=1 colspan=1>≤1</td><td rowspan=2 colspan=1>≤14.1</td></tr><tr><td rowspan=1 colspan=1>65.0</td><td rowspan=1 colspan=1>5.5</td><td rowspan=1 colspan=1>5.3</td><td rowspan=1 colspan=1>5.3</td><td rowspan=1 colspan=1>10.0</td><td rowspan=1 colspan=1>4.3</td></tr><tr><td rowspan=1 colspan=1>66.2</td><td rowspan=1 colspan=1>7.8</td><td rowspan=1 colspan=1>6.7</td><td rowspan=1 colspan=1>6.3</td><td rowspan=1 colspan=1>21.4</td><td rowspan=1 colspan=1>15.5</td><td rowspan=1 colspan=1>15.2</td></tr><tr><td rowspan=1 colspan=1>66.3</td><td rowspan=1 colspan=1>9.6</td><td rowspan=1 colspan=1>7.6</td><td rowspan=1 colspan=1>7.4</td><td rowspan=1 colspan=1>30.2</td><td rowspan=1 colspan=1>22.5</td><td rowspan=1 colspan=1>22.3</td></tr><tr><td rowspan=1 colspan=1>66.1</td><td rowspan=1 colspan=1>13.1</td><td rowspan=1 colspan=1>10.8</td><td rowspan=1 colspan=1>10.5</td><td rowspan=1 colspan=1>33.3</td><td rowspan=1 colspan=1>26.3</td><td rowspan=1 colspan=1>26.1</td></tr><tr><td rowspan=2 colspan=1>Mixup + MI-OLMixup + MI-Combined</td><td rowspan=2 colspan=1>68.867.0</td><td rowspan=1 colspan=1>12.6</td><td rowspan=1 colspan=1>9.4</td><td rowspan=1 colspan=1>9.1</td><td rowspan=1 colspan=1>37.0</td><td rowspan=2 colspan=1>29.026.9</td><td rowspan=2 colspan=1>28.726.7</td></tr><tr><td rowspan=1 colspan=1>14.8</td><td rowspan=1 colspan=1>11.7</td><td rowspan=1 colspan=1>11.3</td><td rowspan=1 colspan=1>31.4</td></tr><tr><td rowspan=4 colspan=1>Interpolated ATInterpolated AT + Gaussian noiseInterpolated AT + Random rotationInterpolated AT + Xie et al. (2018)</td><td rowspan=1 colspan=1>64.7</td><td rowspan=1 colspan=1>26.6</td><td rowspan=1 colspan=1>24.1</td><td rowspan=1 colspan=1>24.0</td><td rowspan=1 colspan=1>52.0</td><td rowspan=1 colspan=1>50.1</td><td rowspan=1 colspan=1>49.8</td></tr><tr><td rowspan=1 colspan=1>60.4</td><td rowspan=1 colspan=1>32.6</td><td rowspan=1 colspan=1>31.6</td><td rowspan=1 colspan=1>31.4</td><td rowspan=1 colspan=1>50.1</td><td rowspan=1 colspan=1>50.0</td><td rowspan=1 colspan=1>49.6</td></tr><tr><td rowspan=1 colspan=1>62.6</td><td rowspan=1 colspan=1>34.5</td><td rowspan=1 colspan=1>32.4</td><td rowspan=1 colspan=1>32.1</td><td rowspan=1 colspan=1>51.0</td><td rowspan=1 colspan=1>49.9</td><td rowspan=1 colspan=1>49.7</td></tr><tr><td rowspan=1 colspan=1>62.1</td><td rowspan=1 colspan=1>42.2</td><td rowspan=1 colspan=1>41.5</td><td rowspan=1 colspan=1>41.3</td><td rowspan=1 colspan=1>57.1</td><td rowspan=1 colspan=1>56.3</td><td rowspan=1 colspan=1>55.8</td></tr><tr><td rowspan=1 colspan=1>Interpolated AT + Guo et al. (2018)</td><td rowspan=1 colspan=1>61.5</td><td rowspan=1 colspan=1>36.2</td><td rowspan=1 colspan=1>33.7</td><td rowspan=1 colspan=1>33.3</td><td rowspan=1 colspan=1>53.8</td><td rowspan=1 colspan=1>52.4</td><td rowspan=1 colspan=1>52.2</td></tr><tr><td rowspan=1 colspan=1>Interpolated AT + MI-OL</td><td rowspan=1 colspan=1>62.0</td><td rowspan=1 colspan=1>43.8</td><td rowspan=1 colspan=1>42.8</td><td rowspan=1 colspan=1>42.5</td><td rowspan=1 colspan=1>58.1</td><td rowspan=1 colspan=1>56.7</td><td rowspan=1 colspan=1>56.5</td></tr></table>
+
+# 4.3 PERFORMANCE UNDER OBLIVIOUS ATTACKS
+
+In this subsection, we evaluate the performance of our method under the oblivious-box attacks (Carlini & Wagner, 2017). The oblivious threat model assumes that the adversary is not aware of the existence of the defense mechanism, e.g., MI, and generate adversarial examples based on the unsecured classification model. We separately apply the model trained by mixup and interpolated AT as the classification model. The AUC scores for the detection-purpose defense are given in Fig. 3(a). The results show that applying MI-PL in inference can better detect adversarial attacks, while directly detecting by the returned confidence without MI-PL performs even worse than a random guess.
+
+We also compare MI with previous general-purpose defenses applied in the inference phase, e.g., adding Gaussian noise or random rotation (Tabacof & Valle, 2016); performing random padding or resizing after random cropping (Guo et al., 2018; Xie et al., 2018). The performance of our method and baselines on CIFAR-10 and CIFAR-100 are reported in Table 2 and Table 3, respectively. Since for each defense method, there is a trade-off between the accuracy on clean samples and adversarial samples depending on the hyperparameters, e.g., the standard deviation for Gaussian noise, we carefully select the hyperparameters to ensure both our method and baselines keep a similar performance on clean data for fair comparisons. The hyperparameters used in our method and baselines are reported in Table 4 and Table 5. In Fig. 3(b), we further explore this trade-off by grid searching the hyperparameter space for each defense to demonstrate the superiority of our method.
+
+As shown in these results, our MI method can significantly improve the robustness for the trained models with induced global linearity, and is compatible with training-phase defenses like the interpolated AT method. As a practical strategy, we also evaluate a variant of MI, called MI-Combined, which applies MI-OL if the input is detected as adversarial by MI-PL with a default detection threshold; otherwise returns the prediction on the original input. We also perform ablation studies of ERM $/ \mathrm { A T } +$ MI-OL in Table 2, where no global linearity is induced. The results verify that our MI methods indeed exploit the global linearity of the mixup-trained models, rather than simply introduce randomness.
+
+# 4.4 PERFORMANCE UNDER WHITE-BOX ADAPTIVE ATTACKS
+
+Following Athalye et al. (2018), we test our method under the white-box adaptive attacks (detailed in Appendix B.2). Since we mainly adopt the PGD attack framework, which synthesizes adversarial examples iteratively, the adversarial noise will be clipped to make the input image stay within the valid range. It results in the fact that with mixup on different training examples, the adversarial perturbation will be clipped differently. To address this issue, we average the generated perturbations over the adaptive samples as the final perturbation. The results of the adversarial accuracy w.r.t the number of adaptive samples are shown in Fig. 4. We can see that even under a strong adaptive attack, equipped with MI can still improve the robustness for the classification models.
+
+![](images/5355a529935b75776ed26e5ff17e1bb507fea86befa34df1a7d1782e1eeaec71.jpg)  
+Figure 4: Classification accuracy under the adaptive PGD attacks on CIFAR-10. The number of adaptive samples refers to the execution times of sampling $x _ { s }$ in each iteration step of adaptive PGD. The dash lines are the accuracy of trained models without MI-OL under PGD attacks.
+
+# 5 CONCLUSION
+
+In this paper, we propose the MI method, which is specialized for the trained models with globally linear behaviors induced by, e.g., mixup or interpolated AT. As analyzed in Sec. 3, MI can exploit this induced global linearity in the inference phase to shrink and transfer the adversarial perturbation, which breaks the locality of adversarial attacks and alleviate their aggressivity. In experiments, we empirically verify that applying MI can return more reliable predictions under different threat models.
+
+# ACKNOWLEDGEMENTS
+
+This work was supported by the National Key Research and Development Program of China (No. 2017YFA0700904), NSFC Projects (Nos. 61620106010, U19B2034, U1811461), Beijing NSF Project (No. L172037), Beijing Academy of Artificial Intelligence (BAAI), Tsinghua-Huawei Joint Research Program, a grant from Tsinghua Institute for Guo Qiang, Tiangong Institute for Intelligent Computing, the JP Morgan Faculty Research Program and the NVIDIA NVAIL Program with GPU/DGX Acceleration.
+
+# REFERENCES
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In International Conference on Machine Learning (ICML), 2018.
+
+Christopher Beckham, Sina Honari, Alex Lamb, Vikas Verma, Farnoosh Ghadiri, R Devon Hjelm, and Christopher Pal. Adversarial mixup resynthesizers. In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin Raffel. Mixmatch: A holistic approach to semi-supervised learning. In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In ACM Workshop on Artificial Intelligence and Security (AISec), 2017.
+
+Nicholas Carlini and David Wagner. Audio adversarial examples: Targeted attacks on speech-to-text. In 2018 IEEE Security and Privacy Workshops (SPW), pp. 1–7. IEEE, 2018.
+
+Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian Goodfellow, Aleksander Madry, and Alexey Kurakin. On evaluating adversarial robustness. arXiv preprint arXiv:1902.06705, 2019.
+
+Hanjun Dai, Hui Li, Tian Tian, Xin Huang, Lin Wang, Jun Zhu, and Le Song. Adversarial attack on graph structured data. In International Conference on Machine Learning (ICML), 2018.
+
+Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. In International Conference on Machine Learning (ICML), 2019.
+
+Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Robustness of classifiers: from adversarial to random noise. In Advances in Neural Information Processing Systems (NeurIPS), pp. 1632–1640, 2016.
+
+Alhussein Fawzi, Hamza Fawzi, and Omar Fawzi. Adversarial vulnerability for any classifier. In Advances in Neural Information Processing Systems (NeurIPS), 2018.
+
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations (ICLR), 2015.
+
+Chuan Guo, Mayank Rana, Moustapha Cisse, and Laurens Van Der Maaten. Countering adversarial images using input transformations. In International Conference on Learning Representations (ICLR), 2018.
+
+Hongyu Guo, Yongyi Mao, and Richong Zhang. Mixup as locally linear out-of-manifold regularization. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), volume 33, pp. 3714–3722, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision (ECCV), pp. 630–645. Springer, 2016.
+
+Kurt Hornik, Maxwell Stinchcombe, and Halbert White. Multilayer feedforward networks are universal approximators. Neural networks, 2(5):359–366, 1989.
+
+Sandy Huang, Nicolas Papernot, Ian Goodfellow, Yan Duan, and Pieter Abbeel. Adversarial attacks on neural network policies. arXiv preprint arXiv:1702.02284, 2017.
+
+Hiroshi Inoue. Data augmentation by pairing samples for images classification. arXiv preprint arXiv:1801.02929, 2018.
+
+Di Jin, Zhijing Jin, Tianyi Zhou, and Peter Szolovits. Is bert really robust? natural language attack on text classification and entailment. arXiv preprint arXiv:1907.11932, 2019.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. In The International Conference on Learning Representations (ICLR) Workshops, 2017.
+
+Alexey Kurakin, Ian Goodfellow, Samy Bengio, Yinpeng Dong, Fangzhou Liao, Ming Liang, Tianyu Pang, Jun Zhu, Xiaolin Hu, Cihang Xie, et al. Adversarial attacks and defences competition. arXiv preprint arXiv:1804.00097, 2018.
+
+Alex Lamb, Vikas Verma, Juho Kannala, and Yoshua Bengio. Interpolated adversarial training: Achieving robust neural networks without sacrificing accuracy. arXiv preprint arXiv:1906.06784, 2019.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations (ICLR), 2018.
+
+Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 427–436, 2015.
+
+Tianyu Pang, Chao Du, Yinpeng Dong, and Jun Zhu. Towards robust detection of adversarial examples. In Advances in Neural Information Processing Systems (NeurIPS), pp. 4579–4589, 2018a.
+
+Tianyu Pang, Chao Du, and Jun Zhu. Max-mahalanobis linear discriminant analysis networks. In International Conference on Machine Learning (ICML), 2018b.
+
+Ning Qian. On the momentum term in gradient descent learning algorithms. Neural networks, 12(1): 145–151, 1999.
+
+Edward Raff, Jared Sylvester, Steven Forsyth, and Mark McLean. Barrage of random transforms for adversarially robust defense. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 6528–6537, 2019.
+
+Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Takuya Shimada, Shoichiro Yamaguchi, Kohei Hayashi, and Sosuke Kobayashi. Data interpolating prediction: Alternative interpretation of mixup. arXiv preprint arXiv:1906.08412, 2019.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations (ICLR), 2014.
+
+Pedro Tabacof and Eduardo Valle. Exploring the space of adversarial images. In 2016 International Joint Conference on Neural Networks (IJCNN), pp. 426–433. IEEE, 2016.
+
+Yuji Tokozume, Yoshitaka Ushiku, and Tatsuya Harada. Learning from between-class examples for deep sound recognition. International Conference on Learning Representations (ICLR), 2018a.
+
+Yuji Tokozume, Yoshitaka Ushiku, and Tatsuya Harada. Between-class learning for image classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 5486–5494, 2018b.
+
+Vladimir Vapnik. The nature of statistical learning theory. Springer science & business media, 2013.
+
+Vikas Verma, Alex Lamb, Christopher Beckham, Aaron Courville, Ioannis Mitliagkis, and Yoshua Bengio. Manifold mixup: Encouraging meaningful on-manifold interpolation as a regularizer. In International Conference on Machine Learning (ICML), 2019a.
+
+Vikas Verma, Alex Lamb, Juho Kannala, Yoshua Bengio, and David Lopez-Paz. Interpolation consistency training for semi-supervised learning. arXiv preprint arXiv:1903.03825, 2019b.
+
+Cihang Xie, Jianyu Wang, Zhishuai Zhang, Zhou Ren, and Alan Yuille. Mitigating adversarial effects through randomization. In International Conference on Learning Representations (ICLR), 2018.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In International Conference on Learning Representations (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 International Conference on Machine Learning (ICML), 2019.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In International Conference on Learning Representations (ICLR), 2018.
+
+# A MORE BACKGROUNDS
+
+In this section, we provide more backgrounds which are related to our work in the main text.
+
+# A.1 ADVERSARIAL ATTACKS AND THREAT MODELS
+
+Adversarial attacks. Although deep learning methods have achieved substantial success in different domains (Goodfellow et al., 2016), human imperceptible adversarial perturbations can be easily crafted to fool high-performance models, e.g., deep neural networks (DNNs) (Nguyen et al., 2015).
+
+One of the most commonly studied adversarial attack is the projected gradient descent (PGD) method (Madry et al., 2018). Let $r$ be the number of iteration steps, $x _ { 0 }$ be the original clean example, then PGD iteratively crafts the adversarial example as
+
+$$
+\begin{array} { r } { x _ { i } ^ { * } = \mathrm { c l i p } _ { x , \epsilon } ( x _ { i - 1 } ^ { * } + \epsilon _ { i } \cdot \mathrm { s i g n } ( \nabla _ { x _ { i - 1 } ^ { * } } \mathcal { L } ( x _ { i - 1 } ^ { * } , y ) ) ) , } \end{array}
+$$
+
+where $\mathrm { c l i p } _ { x , \epsilon } ( \cdot )$ is the clipping function. Here $x _ { 0 } ^ { * }$ is a randomly perturbed image in the neighborhood of $x _ { 0 }$ , i.e., $\mathring { U } ( x _ { 0 } , \epsilon )$ , and the finally returned adversarial example is $x = x _ { r } ^ { * } = x _ { 0 } + \delta$ , following our notations in the main text.
+
+Threat models. Here we introduce different threat models in the adversarial setting. As suggested in Carlini et al. (2019), a threat model includes a set of assumptions about the adversarys goals, capabilities, and knowledge.
+
+Adversary’s goals could be simply fooling the classifiers to misclassify, which is referred to as untargeted mode. Alternatively, the goals can be more specific to make the model misclassify certain examples from a source class into a target class, which is referred to as targeted mode. In our experiments, we evaluate under both modes, as shown in Table 2 and Table 3.
+
+Adversary’s capabilities describe the constraints imposed on the attackers. Adversarial examples require the perturbation $\delta$ to be bounded by a small threshold $\epsilon$ under $\ell _ { p }$ -norm, i.e., $\| \delta \| _ { p } \leq \epsilon$ . For example, in the PGD attack, we consider under the $\ell _ { \infty }$ -norm.
+
+Adversary’s knowledge describes what knowledge the adversary is assumed to have. Typically, there are three settings when evaluating a defense method:
+
+• Oblivious adversaries are not aware of the existence of the defense $D$ and generate adversarial examples based on the unsecured classification model $F$ (Carlini & Wagner, 2017). White-box adversaries know the scheme and parameters of $D$ , and can design adaptive methods to attack both the model $F$ and the defense $D$ simultaneously (Athalye et al., 2018). • Black-box adversaries have no access to the parameters of the defense $D$ or the model $F$ with varying degrees of black-box access (Dong et al., 2018).
+
+In our experiments, we mainly test under the oblivious setting (Sec. 4.3) and white-box setting (Sec. 4.4), since previous work has already demonstrated that randomness itself is efficient on defending black-box attacks (Guo et al., 2018; Xie et al., 2018).
+
+# A.2 INTERPOLATED ADVERSARIAL TRAINING
+
+To date, the most widely applied framework for adversarial training (AT) methods is the saddle point framework introduced in Madry et al. (2018):
+
+$$
+\operatorname* { m i n } _ { \theta } \rho ( \theta ) , \mathrm { w h e r e } \rho ( \theta ) = \operatorname { \mathbb { E } } _ { ( x , y ) \sim p } [ \operatorname* { m a x } _ { \delta \in S } \mathcal { L } ( x + \delta , y ; \theta ) ] .
+$$
+
+Here $\theta$ represents the trainable parameters in the classifier $F$ , and $S$ is a set of allowed perturbations. In implementation, the inner maximization problem for each input-label pair $( x , y )$ is approximately solved by, e.g., the PGD method with different random initialization (Madry et al., 2018).
+
+As a variant of the AT method, Lamb et al. (2019) propose the interpolated AT method, which combines AT with mixup. Interpolated AT trains on interpolations of adversarial examples along with interpolations of unperturbed examples (cf. Alg. 1 in Lamb et al. (2019)). Previous empirical results demonstrate that interpolated AT can obtain higher accuracy on the clean inputs compared to the AT method without mixup, while keeping the similar performance of robustness.
+
+Table 4: The parameter settings for the methods in Table 2. The number of execution for each random method is 30.   
+
+<table><tr><td>Methods</td><td>Parameter Settings</td></tr><tr><td>Mixup Mixup + Gaussian noise</td><td>Noise standard deviationo= 0.04</td></tr><tr><td>Mixup +Random rotation Mixup + Xie et al. (2018)</td><td>Rotation degree range[-40°,40°] The random crop size is randomly selected from [16, 24]</td></tr><tr><td>Mixup + Guo et al. (2018)</td><td>The random crop size is randomly selected from [22,30]</td></tr><tr><td>ERM+ MI-OL (ablation study) Mixup+MI-OL</td><td>The XoL = 0.6</td></tr><tr><td></td><td>The 入oL = 0.5</td></tr><tr><td>Mixup+MI-Combined</td><td>The 入oL = O.5,入oL = O.4,threshold is 0.2</td></tr><tr><td>Interpolated AT</td><td></td></tr><tr><td></td><td>=</td></tr><tr><td>Interpolated AT + Gaussian noise</td><td>Noise standard deviation o = 0.075</td></tr><tr><td>Interpolated AT +Random rotation</td><td>Rotation degree range[-3O°,30°]</td></tr><tr><td>Interpolated AT + Xie et al. (2018)</td><td>The random crop size is randomly selected from [20, 28]</td></tr><tr><td>Interpolated AT + Guo et al. (2018)</td><td>The random crop size is randomly selected from [20, 28]</td></tr><tr><td>AT+ MI-OL (ablation study)</td><td>The 入oL = 0.8</td></tr><tr><td>Interpolated AT + MI-OL</td><td>The 入oL = 0.6</td></tr></table>
+
+# B TECHNICAL DETAILS
+
+We provide more technical details about our method and the implementation of the experiments.
+
+# B.1 MORE DISCUSSION ON THE MI METHOD
+
+Generality. According to Sec. 3, except for the mixup-trained models, the MI method is generally compatible with any trained model with induced global linearity. These models could be trained by other methods, e.g., manifold mixup (Verma et al., 2019a; Inoue, 2018; Lamb et al., 2019). Besides, to better defend white-box adaptive attacks, the mixup ratio $\lambda$ in MI could also be sampled from certain distribution to put in additional randomness.
+
+Empirical gap. As demonstrated in Fig. 2, there is a gap between the empirical results and the theoretical formulas in Table 1. This is because that the mixup mechanism mainly acts as a regularization in training, which means the induced global linearity may not satisfy the expected behaviors. To improve the performance of MI, a stronger regularization can be imposed, e.g., training with mixup for more epochs, or applying matched $\lambda$ both in training and inference.
+
+# B.2 ADAPTIVE ATTACKS FOR MIXUP INFERENCE
+
+Following Athalye et al. (2018), we design the adaptive attacks for our MI method. Specifically, according to Eq. (6), the expected model prediction returned by MI is:
+
+$$
+F _ { \mathrm { M I } } ( x ) = \mathbb { E } _ { p _ { s } } [ F ( \lambda x + ( 1 - \lambda ) x _ { s } ) ] .
+$$
+
+Note that generally the $\lambda$ in MI comes from certain distribution. For simplicity, we fix $\lambda$ as a hyperparameter in our implementation. Therefore, the gradients of the prediction w.r.t. the input $x$ is:
+
+$$
+\begin{array} { r l } {  { \frac { \partial F _ { \mathrm { M I } } ( { \boldsymbol x } ) } { \partial { \boldsymbol x } } = \mathbb { E } _ { p _ { s } } [ \frac { \partial F ( \lambda { \boldsymbol x } + ( 1 - \lambda ) { \boldsymbol x } _ { s } ) } { \partial { \boldsymbol x } } ] } \ ~ } & { } \\ & { = \mathbb { E } _ { p _ { s } } [ \frac { \partial F ( { \boldsymbol u } ) } { \partial { \boldsymbol u } } \Big | _ { { \boldsymbol u } = \lambda { \boldsymbol x } + ( 1 - \lambda ) { \boldsymbol x } _ { s } } \cdot \frac { \partial \lambda { \boldsymbol x } + ( 1 - \lambda ) { \boldsymbol x } _ { s } } { \partial { \boldsymbol x } } ] } \\ & { = \lambda \mathbb { E } _ { p _ { s } } [ \frac { \partial F ( { \boldsymbol u } ) } { \partial { \boldsymbol u } } | _ { { \boldsymbol u } = \lambda { \boldsymbol x } + ( 1 - \lambda ) { \boldsymbol x } _ { s } } ] . } \end{array}
+$$
+
+Table 5: The parameter settings for the methods in Table 3. The number of execution for each random method is 30.   
+
+<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Parameter Settings</td></tr><tr><td rowspan=1 colspan=1>MixupMixup + Gaussian noiseMixup +Random rotationMixup + Xie et al. (2018)Mixup + Guo et al. (2018)</td><td rowspan=1 colspan=1>=Noise standard deviation g = 0.025Rotation degree range[-2O°,20°]The random crop size is randomly selected from [18, 26]The random crop size is randomly selected from [24,32]</td></tr><tr><td rowspan=1 colspan=1>Mixup + MI-OLMixup+MI-Combined</td><td rowspan=1 colspan=1>The 入oL = 0.5The 入oL = 0.5,入oL = O.4,threshold is 0.2</td></tr><tr><td rowspan=1 colspan=1>Interpolated ATInterpolated AT+Gaussian noiseInterpolated AT+RandomrotationInterpolated AT + Xie et al. (2018)Interpolated AT + Guo et al. (2018)</td><td rowspan=1 colspan=1>Noise standard deviation o = 0.06Rotation degree range[-2Oo,20°]The random crop size is randomly selected from [22,30]The random crop size is randomly selected from [24, 32]</td></tr><tr><td rowspan=1 colspan=1>Interpolated AT + MI-OL</td><td rowspan=1 colspan=1>The 入oL = 0.6</td></tr></table>
+
+![](images/ebd56fb7b59810ebc034e274f2b54f45adac6206f0e7c759ed718eee36e9848e.jpg)  
+Figure 5: Adversarial examples crafted by adaptive attacks with $\epsilon = 1 6 / 2 5 5$ on CIFAR-10, against the defense of Interpolated $\mathbf { A T } + \mathbf { M I } \mathbf { - O L }$ .
+
+In the implementation of adaptive PGD attacks, we first sample a series of examples {xs,k}NAk=1, where $N _ { A }$ is the number of adaptive samples in Fig. 3. Then according to Eq. (18), the sign of gradients used in adaptive PGD can be approximated by
+
+$$
+\mathrm { s i g n } \left( \frac { \partial F _ { \mathrm { M I } } ( \boldsymbol { x } ) } { \partial \boldsymbol { x } } \right) \approx \mathrm { s i g n } \left( \sum _ { k = 1 } ^ { N _ { A } } \frac { \partial F ( \boldsymbol { u } ) } { \partial \boldsymbol { u } } \Big | _ { \boldsymbol { u } = \boldsymbol { \lambda } \boldsymbol { x } + ( 1 - \boldsymbol { \lambda } ) \boldsymbol { x } _ { s , k } } \right) .
+$$
+
+# B.3 HYPERPARAMETER SETTINGS
+
+The hyperparameter settings of the experiments shown in Table 2 and Table 3 are provided in Table 4 and Table 5, respectively. Since the original methods in Xie et al. (2018) and Guo et al. (2018) are both designed for the models on ImageNet, we adapt them for CIFAR-10 and CIFAR-100. Most of our experiments are conducted on the NVIDIA DGX-1 server with eight Tesla P100 GPUs.

parse/train/S1exA2NtDB/S1exA2NtDB.md

@@ -0,0 +1,462 @@
+# ES-MAML: SIMPLE HESSIAN-FREE META LEARNING
+
+Xingyou Song∗, Yuxiang Yang‡, Krzysztof Choromanski Google Brain {xingyousong,yxyang,kchoro}@google.com
+
+Aldo Pacchiano   
+UC Berkeley   
+pacchiano@berkeley.edu
+
+Wenbo $\mathbf { G a o ^ { * } } ^ { \dagger }$ , Yunhao Tang† Columbia University $\{ \mathrm { w g } 2 2 7 9 , \mathrm { y t } 2 5 4 \dot { 1 } \} ($ @columbia.edu
+
+# ABSTRACT
+
+We introduce ES-MAML, a new framework for solving the model agnostic meta learning (MAML) problem based on Evolution Strategies (ES). Existing algorithms for MAML are based on policy gradients, and incur significant difficulties when attempting to estimate second derivatives using backpropagation on stochastic policies. We show how ES can be applied to MAML to obtain an algorithm which avoids the problem of estimating second derivatives, and is also conceptually simple and easy to implement. Moreover, ES-MAML can handle new types of non-smooth adaptation operators, and other techniques for improving performance and estimation of ES methods become applicable. We show empirically that ES-MAML is competitive with existing methods and often yields better adaptation with fewer queries.
+
+# 1 INTRODUCTION
+
+Meta-learning is a paradigm in machine learning that aims to develop models and training algorithms which can quickly adapt to new tasks and data. Our focus in this paper is on meta-learning in reinforcement learning (RL), where data efficiency is of paramount importance because gathering new samples often requires costly simulations or interactions with the real world. A popular technique for RL meta-learning is Model Agnostic Meta Learning (MAML) (Finn et al., 2017; 2018), a model for training an agent which can quickly adapt to new and unknown tasks by performing one (or a few) gradient updates in the new environment. We provide a formal description of MAML in Section 2.
+
+MAML has proven to be successful for many applications. However, implementing and running MAML continues to be challenging. One major complication is that the standard version of MAML requires estimating second derivatives of the RL reward function, which is difficult when using backpropagation on stochastic policies; indeed, the original implementation of MAML (Finn et al., 2017) did so incorrectly, which spurred the development of unbiased higher-order estimators (DiCE, (Foerster et al., 2018)) and further analysis of the credit assignment mechanism in MAML (Rothfuss et al., 2019). Another challenge arises from the high variance inherent in policy gradient methods, which can be ameliorated through control variates such as in T-MAML (Liu et al., 2019), through careful adaptive hyperparameter tuning (Behl et al., 2019; Antoniou et al., 2019) and learning rate annealing (Loshchilov & Hutter, 2017).
+
+To avoid these issues, we propose an alternative approach to MAML based on Evolution Strategies (ES), as opposed to the policy gradient underlying previous MAML algorithms. We provide a detailed discussion of ES in Section 3.1. ES has several advantages:
+
+1. Our zero-order formulation of ES-MAML (Section 3.2, Algorithm 3) does not require estimating any second derivatives. This dodges the many issues caused by estimating second derivatives with backpropagation on stochastic policies (see Section 2 for details).
+
+2. ES is conceptually much simpler than policy gradients, which also translates to ease of implementation. It does not use backpropagation, so it can be run on CPUs only.
+
+3. ES is highly flexible with different adaptation operators (Section 3.3).
+
+4. ES allows us to use deterministic policies, which can be safer when doing adaptation (Section 4.3). ES is also capable of learning linear and other compact policies (Section 4.2).
+
+On the point (4), a feature of ES algorithms is that exploration takes place in the parameter space. Whereas policy gradient methods are primarily motivated by interactions with the environment through randomized actions, ES is driven by optimization in high-dimensional parameter spaces with an expensive querying model. In the context of MAML, the notions of “exploration” and “task identification” have thus been shifted to the parameter space instead of the action space. This distinction plays a key role in the stability of the algorithm. One immediate implication is that we can use deterministic policies, unlike policy gradients which is based on stochastic policies. Another difference is that ES uses only the total reward and not the individual state-action pairs within each episode. While this may appear to be a weakness, since less information is being used, we find in practice that it seems to lead to more stable training profiles.
+
+This paper is organized as follows. In Section 2, we give a formal definition of MAML, and discuss related works. In Section 3, we introduce Evolutionary Strategies and show how ES can be applied to create a new framework for MAML. In Section 4, we present numerical experiments, highlighting the topics of exploration (Section 4.1), the utility of compact architectures (Section 4.2), the stability of deterministic policies (Section 4.3), and comparisons against existing MAML algorithms in the few-shot regime (Section 4.4). Additional material can be found in the Appendix.
+
+# 2 MODEL AGNOSTIC META LEARNING IN RL
+
+We first discuss the original formulation of MAML (Finn et al., 2017). Let $\tau$ be a set of reinforcement learning tasks with common state and action spaces $s , A$ , and $\mathcal { P } ( \mathcal { T } )$ a distribution over $\tau$ . In the standard MAML setting, each task $T _ { i } \in \mathcal { T }$ has an associated Markov Decision Process (MDP) with transition distribution $q _ { i } ( s _ { t + 1 } | s _ { t } , a _ { t } )$ , an episode length $H$ , and a reward function $R _ { T _ { i } }$ which maps a trajectory $\tau = ( s _ { 0 } , a _ { 1 } , . . . , a _ { H - 1 } , s _ { H } )$ to the total reward $R ( \tau )$ . A stochastic policy is a function $\pi : { \mathcal { S } }  { \mathcal { P } } ( { \mathcal { A } } )$ which maps states to probability distributions over the action space. A deterministic policy is a function $\pi : { \mathcal { S } }  A$ . Policies are typically encoded by a neural network with parameters $\theta$ , and we often refer to the policy $\pi _ { \theta }$ simply by $\theta$ .
+
+The MAML problem is to find the so-called MAML point (called also a meta-policy), which is a policy $\theta ^ { * }$ that can be ‘adapted’ quickly to solve an unknown task $T \in { \mathcal { T } }$ by taking a (few)1 policy gradient steps with respect to $T$ . The optimization problem to be solved in training (in its one-shot version) is thus of the form:
+
+$$
+\operatorname* { m a x } _ { \theta } J ( \theta ) : = \mathbb { E } _ { T \sim \mathcal { P } ( \mathcal { T } ) } [ \mathbb { E } _ { \tau ^ { \prime } \sim \mathcal { P } _ { \mathcal { T } } ( \tau ^ { \prime } \mid \theta ^ { \prime } ) } [ R _ { T } ( \tau ^ { \prime } ) ] ] ,
+$$
+
+where: $\theta ^ { \prime } = U ( \theta , T ) = \theta + \alpha \nabla _ { \theta } \mathbb { E } _ { \tau \sim \mathcal { P } _ { T } ( \tau | \theta ) } [ R _ { T } ( \tau ) ]$ is called the adapted policy for a step size $\alpha > 0$ and $\mathcal { P } _ { T } ( \cdot | \eta )$ is a distribution over trajectories given task $T \in { \mathcal { T } }$ and conditioned on the policy parameterized by $\eta$ .
+
+Standard MAML approaches are based on the following expression for the gradient of the MAML objective function (1) to conduct training:
+
+$$
+\nabla _ { \theta } J ( \theta ) = \mathbb { E } _ { T \sim \mathcal { P } ( \mathcal { T } ) } [ \mathbb { E } _ { r ^ { \prime } \sim \mathcal { P } _ { T } ( \tau ^ { \prime } \mid \theta ^ { \prime } ) } [ \nabla _ { \theta ^ { \prime } } \log \mathcal { P } _ { T } ( \tau ^ { \prime } \mid \theta ^ { \prime } ) R _ { T } ( \tau ^ { \prime } ) \nabla _ { \theta } U ( \theta , T ) ] ] .
+$$
+
+We collectively refer to algorithms based on computing (2) using policy gradients as PG-MAML.
+
+Since the adaptation operator $U ( \theta , T )$ contains the policy gradient $\nabla _ { \boldsymbol { \theta } } \mathbb { E } _ { \tau \sim \mathcal { P } _ { T } ( \tau \mid \boldsymbol { \theta } ) } [ R ( \tau ) ]$ , its own gradient $\nabla _ { \boldsymbol { \theta } } U ( \boldsymbol { \theta } , T )$ is second-order in $\theta$ :
+
+$$
+\mathcal { I } _ { \theta } U = \mathbf { I } + \alpha \int \mathcal { P } _ { T } ( \tau | \theta ) \nabla _ { \theta } ^ { 2 } \log \pi _ { \theta } ( \tau ) R _ { T } ( \tau ) d \tau + \alpha \int \mathcal { P } _ { T } ( \tau | \theta ) \nabla _ { \theta } \log \pi _ { \theta } ( \tau ) \nabla _ { \theta } \log \pi _ { \theta } ( \tau ) ^ { T } R _ { T } ( \tau ) d \tau .
+$$
+
+Correctly computing the gradient (2) with the term (3) using automatic differentiation is known to be tricky. Multiple authors (Foerster et al., 2018; Rothfuss et al., 2019; Liu et al., 2019) have pointed out that the original implementation of MAML incorrectly estimates the term (3), which inadvertently causes the training to lose ‘pre-adaptation credit assignment’. Moreover, even when correctly implemented, the variance when estimating (3) can be extremely high, which impedes training. To improve on this, extensions to the original MAML include ProMP (Rothfuss et al., 2019), which introduces a new low-variance curvature (LVC) estimator for the Hessian, and T-MAML (Liu et al., 2019), which adds control variates to reduce the variance of the unbiased DiCE estimator (Foerster et al., 2018). However, these are not without their drawbacks: the proposed solutions are complicated, the variance of the Hessian estimate remains problematic, and LVC introduces unknown estimator bias.
+
+Another issue that arises in PG-MAML is that policies are necessarily stochastic. However, randomized actions can lead to risky exploration behavior when computing the adaptation, especially for robotics applications where the collection of tasks may involve differing system dynamics as opposed to only differing rewards (Yang et al., 2019). We explore this further in Section 4.3.
+
+These issues: the difficulty of estimating the Hessian term (3), the typically high variance of $\nabla _ { \boldsymbol { \theta } } J ( \boldsymbol { \theta } )$ for policy gradient algorithms in general, and the unsuitability of stochastic policies in some domains, lead us to the proposed method ES-MAML in Section 3.
+
+Aside from policy gradients, there have also been biologically-inspired algorithms for MAML, based on concepts such as the Baldwin effect (Fernando et al., 2018). However, we note that despite the similar naming, methods such as ‘Evolvability ES’ (Gajewski et al., 2019) bear little resemblance to our proposed ES-MAML. The problem solved by our algorithm is the standard MAML, whereas (Gajewski et al., 2019) aims to maximize loosely related notions of the diversity of behavioral characteristics. Moreover, ES-MAML and its extensions we consider are all derived notions such as smoothings and approximations, with rigorous mathematical definitions as stated below.
+
+# 3 ES-MAML ALGORITHMS
+
+Formulating MAML with ES allows us to employ numerous techniques originally developed for enhancing ES, to MAML. We aim to improve both phases of MAML algorithm: the meta-learning training algorithm, and the efficiency of the adaptation operator.
+
+# 3.1 EVOLUTION STRATEGIES METHODS (ES)
+
+Evolution Strategies (ES) (Wierstra et al., 2008; 2014), which recently became popular for RL (Salimans et al., 2017), rely on optimizing the smoothing of the blackbox function $f : \mathbb { R } ^ { d }  \mathbb { R }$ , which takes as input parameters $\theta \in  { \mathbb { R } } ^ { d }$ of the policy and outputs total discounted (expected) reward obtained by an agent applying that policy in the given environment. Instead of optimizing the function $f$ directly, we optimize a smoothed objective. We define the Gaussian smoothing of $F$ as $\tilde { f } _ { \sigma } ( \theta ) = \mathbb { E } _ { \mathbf { g } \sim \mathcal { N } ( 0 , \mathbb { I } _ { d } ) } [ f ( \theta + \sigma \mathbf { g } ) ]$ . The gradient of this smoothed objective, sometimes called an $E S$ -gradient, is given as (see: (Nesterov & Spokoiny, 2017)):
+
+$$
+\nabla _ { \boldsymbol { \theta } } \tilde { f } _ { \sigma } ( \boldsymbol { \theta } ) = \frac { 1 } { \sigma } \mathbb { E } _ { \mathbf { g } \sim \mathcal { N } ( 0 , \mathbf { I } _ { d } ) } [ f ( \boldsymbol { \theta } + \sigma \mathbf { g } ) \mathbf { g } ] .
+$$
+
+Note that the gradient can be approximated via Monte Carlo (MC) samples:
+
+In ES literature the above algorithm is often modified by adding control variates to equation 4 to obtain other unbiased estimators with reduced variance. The forward finite difference (Forward- $F D$ ) estimator (Choromanski et al., 2018) is given by subtracting the current policy value $f ( \theta )$ , yielding $\begin{array} { r } { \nabla _ { \boldsymbol { \theta } } \tilde { f } _ { \sigma } ( \boldsymbol { \theta } ) = \frac { 1 } { \sigma } \mathbb { E } _ { \mathbf { g } \sim \mathcal { N } ( 0 , \mathbf { I } _ { d } ) } [ ( f ( \boldsymbol { \theta } + \sigma \mathbf { g } ) - f ( \boldsymbol { \theta } ) ) \mathbf { g } ] } \end{array}$ . The antithetic estimator (Nesterov & Spokoiny, 2017; Mania et al., 2018) is given by the symmetric difference $\begin{array} { r } { \nabla _ { \theta } \tilde { f } _ { \sigma } ( \theta ) = \frac { 1 } { 2 \sigma } \mathbb { E } _ { \mathbf { g } \sim \mathcal { N } ( 0 , \mathbf { I } _ { d } ) } [ ( f ( \theta + } \end{array}$
+
+1 ESGrad $( f , \theta , n , \sigma )$
+
+inputs: function $f$ , policy $\theta$ , number of perturbations $n$ , precision $\sigma$ 2 Sample $n$ i.i.d $N ( 0 , I )$ vectors $g _ { 1 } , \ldots , g _ { n }$ ; 3 return $\begin{array} { r } { { \frac { 1 } { n \sigma } } \sum _ { i = 1 } ^ { n } f ( \theta + \sigma g _ { i } ) g _ { i } } \end{array}$ ;
+
+Algorithm 1: Monte Carlo ES Gradient
+
+$\boldsymbol { \sigma } \mathbf { g } ) - f ( \boldsymbol { \theta } - \boldsymbol { \sigma } \mathbf { g } ) ) \mathbf { g } ]$ . Notice that the variance of the Forward-FD and antithetic estimators is translation-invariant with respect to $f$ . In practice, the Forward-FD or antithetic estimator is usually preferred over the basic version expressed in equation 4.
+
+In the next sections we will refer to Algorithm 1 for computing the gradient though we emphasize that there are several other recently developed variants of computing ES-gradients as well as applying them for optimization. We describe some of these variants in Section 3.3 and appendix A.3. A key feature of ES-MAML is that we can directly make use of new enhancements of ES.
+
+# 3.2 META-TRAINING MAML WITH ES
+
+To formulate MAML in the ES framework, we take a more abstract viewpoint. For each task $T \in { \mathcal { T } }$ , let $f ^ { T } ( \theta )$ be the (expected) cumulative reward of the policy $\theta$ . We treat ${ \bf { \bar { f } } } ^ { T }$ as a blackbox, and make no assumptions on its structure (so the task need not even be MDP, and $f ^ { T }$ may be nonsmooth). The MAML problem is then
+
+$$
+\operatorname* { m a x } _ { \theta } J ( \theta ) : = \mathbb { E } _ { T \sim \mathcal { P } ( T ) } f ^ { T } ( U ( \theta , T ) ) .
+$$
+
+As argued in (Liu et al., 2019; Rothfuss et al., 2019) (see also Section 2), a major challenge for policy gradient MAML is estimating the Hessian, which is both conceptually subtle and difficult to correctly implement using automatic differentiation. The algorithm we propose obviates the need to calculate any second derivatives, and thus avoids this issue.
+
+Suppose that we can evaluate (or approximate) $f ^ { T } ( \theta )$ and $U ( \theta , T )$ , but $f ^ { T }$ and $U ( \cdot , T )$ may be nonsmooth or their gradients may be intractable. We consider the Gaussian smoothing ${ \mathcal { \widetilde { I } } } _ { \sigma }$ of the MAML reward (5), and optimize ${ \mathcal { \widetilde { I } } } _ { \sigma }$ using ES methods. The gradient $\nabla \mathcal { I } _ { \sigma } ( \theta )$ is given by
+
+$$
+\nabla \widetilde { J } _ { \sigma } ( \theta ) = \mathbb { E } _ { T \sim \mathcal { P } ( T ) } \left[ \frac { 1 } { \sigma } f ^ { T } ( U ( \theta + \sigma \mathbf { g } , T ) ) \mathbf { g } \right]
+$$
+
+and can be estimated by jointly sampling over $( T , \mathbf { g } )$ and evaluating $f ^ { T } ( U ( \theta + \sigma { \bf g } , T ) )$ . This algorithm is specified in Algorithm 2 box, and we refer to it as (zero-order) ES-MAML.
+
+Data: initial policy $\theta _ { 0 }$ , meta step size $\beta$ 1 for $t = 0 , 1 , \ldots$ do
+
+2 Sample $n$ tasks $T _ { 1 } , \ldots , T _ { n }$ and iid   
+vectors ${ \bf g } _ { 1 } , \ldots , { \bf g } _ { n } \sim { \mathcal N } ( 0 , { \bf I } )$ ;   
+3 foreach $( T _ { i } , \mathbf { g } _ { i } )$ do   
+4 $\begin{array} { r l } { \parallel } & { { } v _ { i }  f ^ { T _ { i } } ( U ( \theta _ { t } + \sigma \mathbf { g } _ { i } , T _ { i } ) ) } \end{array}$   
+5 end   
+6 $\begin{array} { r } { \theta _ { t + 1 }  \theta _ { t } + \frac { \beta } { \sigma n } \sum _ { i = 1 } ^ { n } v _ { i } \mathbf { g } _ { i } } \end{array}$
+
+7 end
+
+Algorithm 2: Zero-Order ES-MAML (general adaptation operator $U ( \cdot , T )$ )
+
+Data: initial policy $\theta _ { 0 }$ , adaptation step size $\alpha$ , meta step size $\beta$ , number of queries $K$ for $t = 0 , 1 , \ldots { }$ do
+
+Algorithm 3: Zero-Order ES-MAML with ESGradient Adaptation
+
+The standard adaptation operator $U ( \cdot , T )$ is the one-step task gradient. Since $f ^ { T }$ is permitted to be nonsmooth in our setting, we use the adaptation operator $U ( \theta , T ) = \theta + \alpha \nabla \widetilde { f } _ { \sigma } ^ { T } ( \theta )$ acting on its smoothing. Expanding the definition of ${ \mathcal { \widetilde { I } } } _ { \sigma }$ , the gradient of the smoothed MAML is then given by
+
+$$
+\nabla \widetilde { J } _ { \sigma } ( \theta ) = \frac { 1 } { \sigma } \mathbb { E } _ { T \sim \mathcal { P } ( \mathcal { T } ) } \left[ f ^ { T } \left( \theta + \sigma \mathbf { g } + \frac { 1 } { \sigma } \mathbb { E } _ { \mathbf { h } \sim \mathcal { N } ( 0 , \mathbf { I } ) } [ f ^ { T } ( \theta + \sigma \mathbf { g } + \sigma \mathbf { h } ) \mathbf { h } ] \right) \mathbf { g } \right] .
+$$
+
+This leads to the algorithm that we specify in Algorithm 3, where the adaptation operator $U ( \cdot , T )$ is itself estimated using the ES gradient in the inner loop.
+
+We can also derive an algorithm analogous to PG-MAML by applying a first-order method to the MAML reward $\mathbb { E } _ { T \sim \mathcal { P } ( \mathcal { T } ) } \overline { { \hat { f } ^ { T } } } ( \theta + \alpha \nabla \tilde { f } ^ { T } ( \theta ) )$ directly, without smoothing. The gradient is given by
+
+$$
+\nabla J ( \theta ) = \mathbb { E } _ { T \sim \mathcal { P } ( \mathcal { T } ) } \nabla \widetilde { f } ^ { T } ( \theta + \alpha \nabla \widetilde { f } ^ { T } ( \theta ) ) ( \mathbf { I } + \alpha \nabla ^ { 2 } \widetilde { f } ^ { T } ( \theta ) ) ,
+$$
+
+which corresponds to equation (3) in (Liu et al., 2019) when expressed in terms of policy gradients. Every term in this expression has a simple Monte Carlo estimator (see Algorithm 4 in the appendix for the MC Hessian estimator). We discuss this algorithm in greater detail in Appendix A.1. This formulation can be viewed as the “MAML of the smoothing”, compared to the “smoothing of the MAML” which is the basis for Algorithm 3. It is the additional smoothing present in equation 6 which eliminates the gradient of $U { \bar { ( } } \cdot , T )$ (and hence, the Hessian of $f ^ { T }$ ). Just as with the Hessian estimation in the original PG-MAML, we find empirically that the MC estimator of the Hessian (Algorithm 4) has high variance, making it often harmful in training. We present some comparisons between Algorithm 3 and Algorithm 5, with and without the Hessian term, in Appendix A.1.2.
+
+Note that when $U ( \cdot , T )$ is estimated, such as in Algorithm 3, the resulting estimator for $\nabla \mathcal { \tilde { I } } _ { \sigma }$ will in general be biased. This is similar to the estimator bias which occurs in PG-MAML because we do not have access to the true adapted trajectory distribution. We discuss this further in Appendix A.2.
+
+# 3.3 IMPROVING THE ADAPTATION OPERATOR WITH ES
+
+Algorithm 2 allows for great flexibility in choosing new adaptation operators. The simplest extension is to modify the ES gradient step: we can draw on general techniques for improving the ES gradient estimator, some of which are described in Appendix A.3. Some other methods are explored below.
+
+# 3.3.1 IMPROVED EXPLORATION
+
+Instead of using i.i.d Gaussian vectors to estimate the ES gradient in $U ( \cdot , T )$ , we consider samples constructed according to Determinantal Point Processes (DPP). DPP sampling (Kulesza & Taskar, 2012; Wachinger & Golland, 2015) is a method of selecting a subset of samples so as to maximize the ‘diversity’ of the subset. It has been applied to ES to select perturbations $\mathbf { g } _ { i }$ so that the gradient estimator has lower variance (Choromanski et al., 2019a). The sampling matrix determining DPP sampling can also be data-dependent and use information from the meta-training stage to construct a learned kernel with better properties for the adaptation phase. In the experimental section we show that DPP-ES can help in improving adaptation in MAML.
+
+# 3.3.2 HILL CLIMBING AND POPULATION SEARCH
+
+Nondifferentiable operators $U ( \cdot , T )$ can be also used in Algorithm 2. One particularly interesting example is the local search operator given by $U ( \theta , T ) ~ \stackrel { \scriptscriptstyle = } { = } ~ \mathrm { a r g m a x } \{ f ^ { T } ( \theta ^ { \prime } ) ~ : ~ \| \theta ^ { \prime } ~ \stackrel { \scriptscriptstyle < } { - } ~ \theta \| ~ \le ~ R \}$ , where $R > 0$ is the search radius. That is, $U ( \theta , T )$ selects the best policy for task $T$ which is in a ‘neighborhood’ of $\theta$ . For simplicity, we took the search neighborhood to be the ball $B ( \theta , R )$ here, but we may also use more general neighborhoods of $\theta$ . In general, exactly solving for the maximizer of $f ^ { T }$ over $B ( \theta , R )$ is intractable, but local search can often be well approximated by a hill climbing algorithm. Hill climbing creates a population of candidate policies by perturbing the best observed policy (which is initialized to $\theta$ ), evaluates the reward $f ^ { T }$ for each candidate, and then updates the best observed policy. This is repeated for several iterations. A key property of this search method is that the progress is monotonic, so the reward of the returned policy $U ( \theta , T )$ will always improve over $\theta$ . This does not hold for the stochastic gradient operator, and appears to be beneficial on some difficult problems (see Section 4.1). It has been claimed that hill climbing and other genetic algorithms (Moriarty et al., 1999) are competitive with gradient-based methods for solving difficult RL tasks (Such et al., 2017; Risi & Stanley, 2019). Another stochastic algorithm approximating local search is CMA-ES (Hansen et al., 2003; Igel, 2003; Krause et al., 2016), which performs more sophisticated search by adapting the covariance matrix of the perturbations.
+
+![](images/5b77f59ea37c11d2933018aea788898ad3032a87ac6e81ebea970c6f43e0c40b.jpg)  
+Figure 1: (a) ES-MAML and PG-MAML exploration behavior. (b) Different exploration methods when $K$ is limited $K = 5$ plotted with lighter colors) or large penalties are added on wrong goals.
+
+# 4 EXPERIMENTS
+
+The performance of MAML algorithms can be evaluated in several ways. One important measure is the performance of the final meta-policy: whether the algorithm can consistently produce metapolicies with better adaptation. In the RL setting, the adaptation of the meta-policy is also a function of the number $K$ of queries used: that is, the number of rollouts used by the adaptation operator $U ( \cdot , T )$ . The meta-learning goal of data efficiency corresponds to adapting with low $K$ . The speed of the meta-training is also important, and can be measured in several ways: the number of metapolicy updates, wall-clock time, and the number of rollouts used for meta-training. In this section, we present experiments which evaluate various aspects of ES-MAML and PG-MAML in terms of data efficiency $( K )$ and meta-training time. Further details of the environments and hyperparameters are given in Appendix A.7.
+
+In the RL setting, the amount of information used drastically decreases if ES methods are applied in comparison to the PG setting. To be precise, ES uses only the cumulative reward over an episode, whereas policy gradients use every state-action pair. Intuitively, we may thus expect that ES should have worse sampling complexity because it uses less information for the same number of rollouts. However, it seems that in practice ES often matches or even exceeds policy gradients approaches (Salimans et al., 2017; Mania et al., 2018). Several explanations have been proposed: In the PG case, especially with algorithms such as PPO, the network must optimize multiple additional surrogate objectives such as entropy bonuses and value functions as well as hyperparameters such as the TDstep number. Furthermore, it has been argued that ES is more robust against delayed rewards, action infrequency, and long time horizons (Salimans et al., 2017). These advantages of ES in traditional RL also transfer to MAML, as we show empirically in this section. ES may lead to additional advantages (even if the numbers of rollouts needed in training is comparable with PG ones) in terms of wall-clock time, because it does not require backpropagation, and can be parallelized over CPUs.
+
+# 4.1 EXPLORATION: TARGET ENVIRONMENTS
+
+In this section, we present two experiments on environments with very sparse rewards where the meta-policy must exhibit exploratory behavior to determine the correct adaptation.
+
+The four corners benchmark was introduced in (Rothfuss et al., 2019) to demonstrate the weaknesses of exploration in PG-MAML. An agent on a 2D square receives reward for moving towards a selected corner of the square, but only observes rewards once it is sufficiently close to the target corner, making the reward sparse. An effective exploration strategy for this set of tasks is for the meta-policy $\theta ^ { * }$ to travel in circular trajectories to observe which corner produces rewards; however, for a single policy to produce this exploration behavior is difficult. In Figure 1, we demonstrate the behavior of ES-MAML on the four corners problem. When $K = 2 0$ , the same number of rollouts for adaptation as used in (Rothfuss et al., 2019), the basic version of Algorithm 3 is able to correctly explore and adapt to the task by finding the target corner. Moreover, it does not require any modifications to encourage exploration, unlike PG-MAML. We further used $K = 1 0 , 5$ , which caused the performance to drop. For better performance in this low-information environment, we experimented with two different adaptation operators $U ( \cdot , T )$ in Algorithm 2, which are HC (hill climbing) and DPP-ES. The standard ES gradient is denoted MC.
+
+Furthermore, ES-MAML is not limited to “single goal” exploration. We created a more difficult task, six circles, where the agent continuously accrues negative rewards until it reaches six target points to “deactivate” them. Solving this task requires the agent to explore in circular trajectories, similar to the trajectory used by PG-MAML on the four corners task. We visualize the behavior in Figure 2. Observe that ES-MAML with the HC operator is able to develop a strategy to explore the target locations.
+
+![](images/8fa5d0f0176bb5b94749567589e0fb1f6245dea2259a70bf70180cbfc661f6fe.jpg)  
+Figure 2: ES-MAML exploration on six circle task $K = 2 0$ ).
+
+From Figure 1, we observed that both operators DPP-ES and HC were able to improve exploration performance. We also created a modified task by heavily penalizing incorrect goals, which caused performance to dramatically drop for MC and DPP-ES. This is due to the variance from the MC-gradient, which may result in a adapted policy that accidentally produces large negative rewards or become stuck in local-optima (i.e. refuse to explore due to negative rewards). This is also fixed by the HC adaptation, which enforces non-decreasing rewards during adaptation, allowing the ES-MAML to progress.
+
+Additional examples on the classic Navigation-2D task are presented in Appendix A.4, highlighting the differences in exploration behavior between PG-MAML and ES-MAML.
+
+# 4.2 GOOD ADAPTATION WITH COMPACT ARCHITECTURES
+
+One of the main benefits of ES is due to its ability to train compact linear policies, which can outperform hidden-layer policies. We demonstrate this on several benchmark MAML problems in the HalfCheetah and Ant environments in Figure 3. In contrast, (Finn & Levine, 2018) observed that PG-MAML empirically and theoretically suggested that training with more deeper layers under SGD increases performance. We demonstrate that on the Forward-Backward and Goal-Velocity MAML benchmarks, ES-MAML is consistently able to train successful linear policies faster than deep networks. We also show that, for the Forward-Backward Ant problem, ES-MAML with the new HC operator is the most performant. Using more compact policies also directly speeds up ES-MAML, since fewer perturbations are needed for gradient estimation.
+
+![](images/cbb5a4cbd49afd91a97672d25c0c17c04de7ca7c0d13bd7dd8f2092c02d0b049.jpg)  
+Figure 3: The Forward-Backward and Goal-Velocity MAML problems. We compare the performance for Linear (L) policies and policies with one hidden layer (H) for different $K$ .
+
+# 4.3 DETERMINISTIC POLICIES
+
+We find that deterministic policies often produce more stable behaviors than the stochastic ones that are required for PG, where randomized actions in unstable environments can lead to catastrophic outcomes. In PG, this is often mitigated by reducing the entropy bonus, but this has an undesirable side effect of reducing exploration. In contrast, ES-MAML explores in parameter space, which mitigates this issue. To demonstrate this, we use the “Biased-Sensor CartPole” environment from (Yang et al., 2019). This environment has unstable dynamics and sparse rewards, so it requires exploration but is also risky. We see in Figure 4 that ES-MAML is able to stably maintain the maximum reward (500).
+
+![](images/dd5d2488f52f41293baaa80eb977559d5924da6ae5098cb338b0c7f7cb5920e5.jpg)  
+Figure 4: Stability comparisons of ES and PG on the Biased-Sensor CartPole and Swimmer, Walker2d environments. (L), (H), and (HH) denote linear, one- and two-hidden layer policies.
+
+We also include results in Figure 4 from two other environments, Swimmer and Walker2d, for which it is known that PG is surprisingly unstable, and ES yields better training (Mania et al., 2018). Notice that we again find linear policies (L) outperforming policies with one (H) or two (HH) hidden layers.
+
+# 4.4 LOW- $K$ BENCHMARKS
+
+For real-world applications, we may be constrained to use fewer queries $K$ than has typically been demonstrated in previous MAML works. Hence, it is of interest to compare how ES-MAML compares to PG-MAML for adapting with very low $K$ .
+
+One possible concern is that low $K$ might harm ES in particular because it uses only the cumulative rewards; if for example $K = 5$ , then the ES adaptation gradient can make use of only 5 values. In comparison, PG-MAML uses $K \cdot H$ state-action pairs, so for $K = 5 , H = 2 0 0$ , PG-MAML still has 1000 pieces of information available.
+
+However, we find experimentally that the standard ES-MAML (Algorithm 3) remains competitive with PG-MAML even in the low- $K$ setting. In Figure 5, we compare ES-MAML and PG-MAML on the Forward-Backward and Goal-Velocity tasks across four environments (HalfCheetah, Swimmer, Walker2d, Ant) and two model architectures. While PG-MAML can generally outperform ESMAML on the Goal-Velocity task, ES-MAML is similar or better on the Forward-Backward task. Moreover, we observed that for low $K$ , PG-MAML can be highly unstable (note the wide error bars), with some trajectories failing catastrophically, whereas ES-MAML is relatively stable. This is an important consideration in real applications, where the risk of catastrophic failure is undesirable.
+
+![](images/4e4c088e05427dc9efc62b542510eeeade9c204551dbf77412efe8e315f1aba0.jpg)  
+Figure 5: Low $K$ comparisons between ES-MAML and PG-MAML.
+
+# 5 CONCLUSION
+
+We have presented a new framework for MAML based on ES algorithms. The ES-MAML approach avoids the problems of Hessian estimation which necessitated complicated alterations in PG-MAML and is straightforward to implement. ES-MAML is flexible in the choice of adaptation operators, and can be augmented with general improvements to ES, along with more exotic adaptation operators. In particular, ES-MAML can be paired with nonsmooth adaptation operators such as hill climbing, which we found empirically to yield better exploratory behavior and better performance on sparse-reward environments. ES-MAML performs well with linear or compact deterministic policies, which is an advantage when adapting if the state dynamics are possibly unstable.
+
+# REFERENCES
+
+Maruan Al-Shedivat, Trapit Bansal, Yura Burda, Ilya Sutskever, Igor Mordatch, and Pieter Abbeel. Continuous adaptation via meta-learning in nonstationary and competitive environments. In International Conference on Learning Representations, 2018.
+
+Antreas Antoniou, Harrison Edwards, and Amos J. Storkey. How to train your MAML. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019.
+
+Harkirat Singh Behl, Atilim Gunes Baydin, and Philip H. S. Torr. Alpha MAML: adaptive model-¨ agnostic meta-learning. CoRR, abs/1905.07435, 2019.
+
+Jose Blanchet, Donald Goldfarb, Garud Iyengar, Fengpei Li, and Chaoxu Zhou. Unbiased simulation for optimizing stochastic function compositions. arXiv:1711.07564, 2017.
+
+Krzysztof Choromanski, Mark Rowland, Vikas Sindhwani, Richard E. Turner, and Adrian Weller. Structured evolution with compact architectures for scalable policy optimization. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan,¨ Stockholm, Sweden, July 10-15, 2018, pp. 969–977, 2018.
+
+Krzysztof Choromanski, Aldo Pacchiano, Jack Parker-Holder, and Yunhao Tang. Structured monte carlo sampling for nonisotropic distributions via determinantal point processes. arXiv:1905.12667, 2019a.
+
+Krzysztof Choromanski, Aldo Pacchiano, Jack Parker-Holder, and Yunhao Tang. From complexity to simplicity: Adaptive es-active subspaces for blackbox optimization. NeurIPS 2019, 2019b.
+
+Krzysztof Choromanski, Aldo Pacchiano, Jack Parker-Holder, Yunhao Tang, Deepali Jain, Yuxiang Yang, Atil Iscen, Jasmine Hsu, and Vikas Sindhwani. Provably robust blackbox optimization for reinforcement learning. accepted to CoRL 2019, 2019c.
+
+Chrisantha Fernando, Jakub Sygnowski, Simon Osindero, Jane Wang, Tom Schaul, Denis Teplyashin, Pablo Sprechmann, Alexander Pritzel, and Andrei A. Rusu. Meta-learning by the baldwin effect. In Proceedings of the Genetic and Evolutionary Computation Conference Companion, GECCO 2018, Kyoto, Japan, July 15-19, 2018, pp. 109–110, 2018. doi: 10.1145/3205651.3205763. URL https://doi.org/10.1145/3205651.3205763.
+
+Chelsea Finn and Sergey Levine. Meta-learning and universality: Deep representations and gradient descent can approximate any learning algorithm. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings, 2018.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 1126–1135, 2017.
+
+Chelsea Finn, Kelvin Xu, and Sergey Levine. Probabilistic model-agnostic meta-learning. In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, 3-8 December 2018, Montreal, Canada. ´ , pp. 9537– 9548, 2018.
+
+Jakob Foerster, Gregory Farquhar, Maruan Al-Shedivat, Tim Rocktaschel, Eric Xing, and Shimon ¨ Whiteson. DiCE: The infinitely differentiable Monte Carlo estimator. In Proceedings of the 35th International Conference on Machine Learning, volume 80, pp. 1529–1538, 2018.
+
+Alexander Gajewski, Jeff Clune, Kenneth O. Stanley, and Joel Lehman. Evolvability ES: scalable and direct optimization of evolvability. In Proceedings of the Genetic and Evolutionary Computation Conference, GECCO 2019, Prague, Czech Republic, July 13-17, 2019, pp. 107–115, 2019. doi: 10.1145/3321707.3321876. URL https://doi.org/10.1145/3321707. 3321876.
+
+Nikolaus Hansen, Sibylle Muller, and Petros Koumoutsakos. Reducing the time complexity of ¨ the derandomized evolution strategy with covariance matrix adaptation (cma-es). Evolutionary Computation, 11(1):1–18, 2003.
+
+Mingyi Hong, Zhi-Quan Luo, and Meisam Razaviyayn. Convergence analysis of alternating direction method of multipliers for a family of nonconvex problems. SIAM Journal on Optimization, 26(1):337–364, 2016.
+
+Christian Igel. Neuroevolution for reinforcement learning using evolution strategies. In 2003 IEEE Congress on Evolutionary Computation, 2003.
+
+Oswin Krause, Didac Arbones, and Christian Igel. Cma-es with optimal covariance update and storage complexity. Advances in Neural Information Processing Systems, pp. 370–378, 2016.
+
+Alex Kulesza and Ben Taskar. Determinantal point processes for machine learning. Foundations and Trends in Machine Learning, 5(2-3):123–286, 2012.
+
+Hao Liu, Richard Socher, and Caiming Xiong. Taming MAML: efficient unbiased metareinforcement learning. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, pp. 4061–4071, 2019.
+
+Ilya Loshchilov and Frank Hutter. SGDR: stochastic gradient descent with warm restarts. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings, 2017.
+
+Horia Mania, Aurelia Guy, and Benjamin Recht. Simple random search provides a competitive approach to reinforcement learning. Advances in Neural Information Processing Systems 31, pp. 1800–1809, 2018.
+
+David Moriarty, Alan Schultz, and John Grefenstette. Evolutionary algorithms for reinforcement learning. Journal of Artificial Intelligence Research, 11:241–276, 1999.
+
+Yurii Nesterov and Vladimir Spokoiny. Random gradient-free minimization of convex functions. Foundations of Computational Mathematics, 17(2):527–566, 2017.
+
+Sebastian Risi and Kenneth Stanley. Deep neuroevolution of recurrent and discrete world models. arXiv:1906.08857, 2019.
+
+Jonas Rothfuss, Dennis Lee, Ignasi Clavera, Tamim Asfour, and Pieter Abbeel. Promp: Proximal meta-policy search. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019.
+
+Tim Salimans, Jonathan Ho, Xi Chen, Szymon Sidor, and Ilya Sutskever. Evolution strategies as a scalable alternative to reinforcement learning. arXiv:1703.03864, 2017.
+
+Felipe Petroski Such, Vashisht Madhavan, Edoardo Conti, Joel Lehman, Kenneth Stanley, and Jeff Clune. Deep neuroevolution: Genetic algorithms are a competitive alternative for training deep neural networks for reinforcement learning. arXiv:1712.06567, 2017.
+
+Christian Wachinger and Polina Golland. Sampling from determinantal point processes for scalable manifold learning. Information Processing for Medical Imaging, pp. 687–698, 2015.
+
+Mengdi Wang, Ji Liu, and Xingyuan Fang. Accelerating stochastic composition optimization. Journal of Machine Learning Research, 18:1–23, 2017.
+
+Daan Wierstra, Tom Schaul, Jan Peters, and Jurgen Schmidhuber. Natural evolution strategies. In ¨ 2008 IEEE Congress on Evolutionary Computation, pp. 3381–3387, 2008.
+
+Daan Wierstra, Tom Schaul, Tobias Glasmachers, Yi Sun, Jan Peters, and Jurgen Schmidhuber. ¨ Natural evolution strategies. Journal of Machine Learning Research, 15:949–980, 2014.
+
+Yuxiang Yang, Ken Caluwaerts, Atil Iscen, Jie Tan, and Chelsea Finn. Norml: No-reward meta learning. In Proceedings of the 18th International Conference on Autonomous Agents and MultiAgent Systems, AAMAS ’19, Montreal, QC, Canada, May 13-17, 2019, pp. 323–331, 2019.
+
+# A.1 FIRST-ORDER ES-MAML
+
+# A.1.1 ALGORITHM
+
+Suppose that we first apply Gaussian smoothing to the task rewards and then form the MAML problem, so we have $J ( \tilde { \theta } ) = \mathbb { E } _ { T \sim \mathcal { P } ( T ) } \tilde { f } ^ { T } ( U ( \theta , \hat { T } ) )$ . The function $J$ is then itself differentiable, and we can directly apply first-order methods to it. The classical case where $U ( \theta , T ) = \theta + \alpha \nabla \widetilde { f } ^ { T } ( \theta )$ yields the gradient
+
+$$
+\nabla J ( \theta ) = \mathbb { E } _ { T \sim \mathcal { P } ( \mathcal { T } ) } \nabla \widetilde { f } ^ { T } ( \theta + \alpha \nabla \widetilde { f } ^ { T } ( \theta ) ) ( \mathbf { I } + \alpha \nabla ^ { 2 } \widetilde { f } ^ { T } ( \theta ) ) .
+$$
+
+This is analogous to formulas obtained in e.g (Liu et al., 2019) for the policy gradient MAML. We can then approximate this gradient as an input to stochastic first-order methods. An example with standard SGD is shown in Algorithm 5.
+
+Data: initial policy $\theta _ { 0 }$ , adaptation step size $\alpha$   
+meta step size $\beta$ , number of queries $K$   
+1 for $t = 0 , 1 , \ldots { } \mathbf { d }$ o   
+2 Sample $n$ tasks $T _ { 1 } , \ldots , T _ { n }$ ;   
+3 foreach $T _ { i }$ do   
+4 $\mathbf { d } _ { 1 } ^ { ( i ) }  \mathrm { E S G R A D } ( f ^ { T _ { i } } , \theta _ { t } , K , \sigma )$ ;   
+5 $\mathbf { H } ^ { ( i ) } \gets \mathrm { E S H E S S } ( f ^ { T _ { i } } , \theta _ { t } , K , \sigma ) ;$   
+6 $\boldsymbol { \theta } _ { t } ^ { ( i ) }  \boldsymbol { \theta } _ { t } + \alpha \cdot \mathbf { d } _ { i }$ ;   
+7 $\mathbf { d } _ { 2 } ^ { ( i ) } \gets \mathrm { E S G R A D } ( f ^ { T _ { i } } , \theta _ { t } ^ { ( i ) } , K , \sigma ) ;$ ;   
+8 end   
+9 $\begin{array} { r } { \theta _ { t + 1 }  \theta _ { t } + \frac { \beta } { n } \sum _ { i = 1 } ^ { n } ( \mathbf { I } + \alpha \mathbf { H } ^ { ( i ) } ) \mathbf { d } _ { 2 } ^ { ( i ) } ; } \end{array}$   
+10 end
+
+1 ESHess $( f , \theta , n , \sigma )$ inputs: function $f$ , policy $\theta$ , number of perturbations $n$ , precision $\sigma$   
+2 3 $\textstyle v \gets { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } f ( \theta + \sigma \mathbf { g } _ { i } )$ $\mathcal { N } ( 0 , \bf { I } )$ ors ; $\mathbf { g } _ { 1 } , \ldots , \mathbf { g } _ { n }$ ;   
+4 $\begin{array} { r } { \mathbf { H } ^ { 0 }  \frac { 1 } { n } \sum _ { i = 1 } ^ { n } f ( \theta + \sigma \mathbf { g } _ { i } ) \mathbf { g } _ { i } \mathbf { g } _ { i } ^ { T } } \end{array}$ ;   
+5 return $\begin{array} { r } { \frac { 1 } { \sigma ^ { 2 } } ( \mathbf { H } ^ { 0 } - v \cdot \mathbf { I } ) } \end{array}$ ; Algorithm 4: Monte Carlo ES Hessian
+
+Algorithm 5: First Order ES-MAML
+
+A central problem, as discussed in (Rothfuss et al., 2019; Liu et al., 2019) is the estimation of $\nabla ^ { 2 } \widetilde { f } ^ { T } ( \theta )$ . However, a simple expression exists for this object in the ES setting; it can be shown that
+
+$$
+\nabla ^ { 2 } \widetilde { f } ^ { T } ( \theta ) = \frac { 1 } { \sigma ^ { 2 } } ( \mathbb { E } _ { \mathbf { h } \sim \mathcal { N } ( 0 , \mathbf { I } ) } [ f ^ { T } ( \theta + \sigma \mathbf { h } ) \mathbf { h } \mathbf { h } ^ { T } ] - \widetilde { f } ^ { T } ( \theta ) \mathbf { I } ] .
+$$
+
+Note that for the vector $\mathbf { h }$ , $\mathbf { h } ^ { T }$ is the transpose (and unrelated to tasks $T$ ). A basic MC estimator is shown in Algorithm 4. Given an independent estimator for $\nabla \widetilde { f } ^ { T } ( \theta + \alpha \nabla \widetilde { f } ^ { T } ( \theta ) )$ , we can then take the product to obtain an estimator for $\nabla J$ .
+
+# A.1.2 EXPERIMENTS WITH FIRST-ORDER ES-MAML
+
+Unlike zero-order ES-MAML (Algorithm 3), the first-order ES-MAML explicitly builds an approximation of the Hessian of $f ^ { T }$ . Given the literature on PG-MAML, we expect that estimating the Hessian $\nabla ^ { 2 } \widetilde { f } ^ { T } ( \theta )$ with Algorithm 4 without any control variates may have high variance. We compare two variants of first-order ES-MAML:
+
+1. The full version (FO-Hessian) specified in Algorithm 5.   
+2. The ‘first-order approximation’ (FO-NoHessian) which ignores the term $\mathbf { I } + \alpha \nabla ^ { 2 } \widetilde { f } ^ { T } ( \theta )$ and approximates the MAML gradient as $\mathbb { E } _ { T \sim \mathcal { P } ( \mathcal { T } ) } \nabla \widetilde { f } ^ { T } ( \theta + \alpha \nabla \widetilde { f } ^ { T } ( \theta ) )$ . This is equivalent to setting $\mathbf { H } ^ { ( i ) } = 0$ in line 5 of Algorithm 5.
+
+The results on the four corner exploration problem (Section 4.1) and the Forward-Backward Ant, using Linear policies, are shown in Figure A1. On Forward-Backward Ant, FO-NoHessian actually outperformed FO-Hessian, so the inclusion of the Hessian term actually slowed convergence. On the four corners task, both FO-Hessian and FO-NoHessian have large error bars, and FO-Hessian slightly outperforms FO-NoHessian.
+
+There is conflicting evidence as to whether the same phenomenon occurs with PG-MAML; (Finn et al., 2017, §5.2) found that on supervised learning MAML, omitting Hessian terms is competitive but slightly worse than the full PG-MAML, and does not report comparisons with and without the Hessian on RL MAML. (Rothfuss et al., 2019; Liu et al., 2019) argue for the importance of the second-order terms in proper credit assignment, but use heavily modified estimators (LVC, control variates; see Section 2) in their experiments, so the performance is not directly comparable to the ‘naive’ estimator in Algorithm 4. Our interpretation is that Algorithm 4 has high variance, making the Hessian estimates inaccurate, which can slow training on relatively ‘easier’ tasks like ForwardBackward walking but possibly increase the exploration on four corners.
+
+![](images/b82fcd95dae65f3632d4d9f37f08172486d0d7d9b5f324ebb484980053c65788.jpg)  
+Figure A1: Comparisons between the FO-Hessian and FO-NoHessian variants of Algorithm 5.
+
+We also compare FO-NoHessian against Algorithm 3 on Forward-Backward HalfCheetah and Ant in Figure A2. In this experiment, the two methods ran on servers with different number of workers available, so we measure the score by the total number of rollouts. We found that FO-NoHessian was slightly faster than Algorithm 3 when measured by rollouts on Ant, but FO-NoHessian had notably poor performance when the number of queries was low $K = 5$ ) on HalfCheetah, and failed to reach similar scores as the others even after running for many more rollouts.
+
+![](images/a058edbaf35f35e07ea9570ef2c283ac43bc722a77d3a7e8914bfdd7ff486d46.jpg)  
+Figure A2: Comparisons between FO-NoHessian and Algorithm 3, by rollouts
+
+# A.2 HANDLING ESTIMATOR BIAS
+
+Since the adapted policy $U ( \theta , T )$ generally cannot be evaluated exactly, we cannot easily obtain unbiased estimates of $f ^ { T } ( U ( \theta , T ) )$ . This problem arises for both PG-MAML and ES-MAML.
+
+We consider PG-MAML first as an example. In PG-MAML, the adaptation operator is $U ( \theta , T ) =$ $\theta + \alpha \nabla _ { \theta } \mathbb { E } _ { \tau \sim \mathcal { P } _ { T } ( \tau \mid \theta ) } [ R ( \tau ) ]$ . In general, we can only obtain an estimate of $\nabla _ { \boldsymbol { \theta } } \mathbb { E } _ { \tau \sim \mathcal { P } _ { T } ( \tau \mid \boldsymbol { \theta } ) } [ R ( \tau ) ]$ and not its exact value. However, the MAML gradient is given by
+
+$$
+\nabla _ { \theta } J ( \theta ) = \mathbb { E } _ { \mathcal { T } \sim \mathcal { P } ( \mathcal { T } ) } [ \mathbb { E } _ { r ^ { \prime } \sim \mathcal { P } _ { \mathcal { T } } ( \tau ^ { \prime } \mid \theta ^ { \prime } ) } [ \nabla _ { \theta ^ { \prime } } \log \mathcal { P } _ { \mathcal { T } } ( \tau ^ { \prime } \mid \theta ^ { \prime } ) R ( \tau ^ { \prime } ) \nabla _ { \theta } U ( \theta , T ) ] ]
+$$
+
+which requires exact sampling from the adapted trajectories $\tau ^ { \prime } \sim \mathcal { P } _ { T } ( \tau ^ { \prime } | U ( \theta , T ) )$ . Since this is a nonlinear function of $U ( \theta , T )$ , we cannot obtain unbiased estimates of $\nabla J ( \theta )$ by sampling $\tau ^ { \prime }$ generated by an estimate of $U ( \theta , T )$ .
+
+In the case of ES-MAML, the adaptation operator is $U ( \theta , T ) = \theta + \underline { { { \alpha } } } \nabla \widetilde { f } ( \theta , T ) = \mathbb { E } _ { \mathbf { h } } u ( \theta , T ; \mathbf { h } )$ for $\mathbf { h } \sim { \mathcal { N } } ( 0 , I )$ , where $\begin{array} { r } { u ( \theta , T ; { \bf h } ) = \dot { \theta } + \frac { \alpha } { \sigma } f ^ { \top } ( \theta + \sigma { \bf h } ) { \bf h } } \end{array}$ . Clearly, $f ^ { T } ( u ( \theta , T ; \mathbf { h } ) )$ is not an unbiased estimator of $f ^ { \mathcal { T } } ( U ( \theta , T ) )$ .
+
+We may question whether using an unbiased estimator of $f ^ { T } ( U ( \theta , T ) )$ is likely to improve performance. One natural strategy is to reformulate the objective function so as to make the desired estimator unbiased. This happens to be the case for the algorithm E-MAML (Al-Shedivat et al., 2018), which treats the adaptation operator as an explicit function of $K$ sampled trajectories and “moves the expectation outside”. That is, we now have an adaptation operator $U ( \theta , T ; \tau _ { 1 } , \dots , \tau _ { K } )$ , and the objective function becomes
+
+$$
+\mathbb { E } _ { T } [ \mathbb { E } _ { \tau _ { 1 } , \dots , \tau _ { k } \sim \mathcal { P } _ { T } ( \tau | \theta ) } f ^ { T } ( U ( \theta , T ; \tau _ { 1 } , \dots , \tau _ { K } ) ) ]
+$$
+
+An unbiased estimator for the E-MAML gradient can be obtained by sampling only from $\tau \sim$ ${ \mathcal { P } } _ { T } ( \tau | \theta )$ (Al-Shedivat et al., 2018). However, it has been argued that by doing so, E-MAML does not properly assign credit to the pre-adaptation policy (Rothfuss et al., 2019). Thus, this particular mathematical strategy seems to be disadvantageous for RL.
+
+The problem of finding estimators for function-of-expectations $f ( \mathbb { E } X )$ is difficult and while general unbiased estimation methods exist (Blanchet et al., 2017), they are often complicated and suffer from high variance. In the context of MAML, ProMP compares the low variance curvature (LVC) estimator (Rothfuss et al., 2019), which is biased, against the unbiased DiCE estimator (Foerster et al., 2018), for the Hessian term in the MAML gradient, and found that the lower variance of LVC produced better performance than DiCE. Alternatively, control variates can be used to reduce the variance of the DiCE estimator, which is the approach followed in (Liu et al., 2019).
+
+In the ES framework, the problem can also be formulated to avoid exactly evaluating $U ( \cdot , T )$ , and hence circumvents the question of estimator bias. We observe an interesting connection between MAML and the stochastic composition problem. Let us define $u _ { \mathbf { h } } ( \theta , T ) = u ( \bar { \theta } , T ; \mathbf { h } )$ and $f _ { \mathbf { g } } ^ { T } ( \theta ) =$ $f ^ { T } ( \theta + \sigma \mathbf { g } )$ . For a given task $T$ , the MAML reward is given by
+
+$$
+\widetilde { f } ^ { T } ( U ( \theta , T ) ) = \widetilde { f } ^ { T } [ \mathbb { E } _ { \mathbf { h } } u _ { \mathbf { h } } ( \theta , T ) ] = \mathbb { E } _ { \mathbf { g } } f _ { \mathbf { g } } ^ { T } ( \mathbb { E } _ { \mathbf { h } } u _ { \mathbf { h } } ( \theta , T ) ) .
+$$
+
+This is a two-layer nested stochastic composition problem with outer function $\tilde { f } ^ { T } = \mathbb { E } _ { \mathbf { g } } f _ { \mathbf { g } } ^ { T }$ and inner function $U ( \cdot , T ) = \mathbb { E } _ { \mathbf { h } } u _ { \mathbf { h } } ( \cdot , T )$ . An accelerated algorithm (ASC-PG) was developed in (Wang et al., 2017)] for this class of problems. While neither $f _ { \mathbf { g } } ^ { \breve { T } }$ nor $u _ { \mathbf { h } } ( \cdot , T )$ is smooth, which is assumed in (Wang et al., 2017), we can verify that the crucial content of the assumptions hold:
+
+1. $\mathbb { E } _ { \mathbf { h } } u _ { \mathbf { h } } ( \theta , T ) = U ( \theta , T )$
+
+2. We can define two functions
+
+$$
+\zeta _ { \mathbf { g } } ^ { T } ( \theta ) = { \frac { 1 } { \sigma } } f _ { \mathbf { g } } ^ { T } ( \theta ) \mathbf { g } , \quad \xi _ { \mathbf { h } } ^ { T } ( \theta ) = \mathbf { I } + { \frac { \alpha } { \sigma ^ { 2 } } } { \big ( } f _ { \mathbf { h } } ^ { T } ( \theta ) \mathbf { h } \mathbf { h } ^ { T } - f _ { \mathbf { h } } ^ { T } ( \theta ) \mathbf { I } { \big ) }
+$$
+
+such that for any $\theta _ { 1 } , \theta _ { 2 }$ ,
+
+$$
+\mathbb { E } _ { \mathbf { g } , \mathbf { h } } [ \xi _ { \mathbf { h } } ^ { T } ( \theta _ { 1 } ) \zeta _ { \mathbf { g } } ^ { T } ( \theta _ { 2 } ) ] = J U ( \theta _ { 1 } , T ) \nabla \widetilde { f } ^ { T } ( \theta _ { 2 } )
+$$
+
+where $J U$ denotes the Jacobian of $U ( \cdot , T )$ , and $\mathbf { g } , \mathbf { h }$ are independent vectors sampled from $\mathcal { N } ( 0 , \bf { I } )$ . This follows immediately from equation 4 and equation 10.
+
+The ASC-PG algorithm does not immediately extend to the full MAML problem, as upon taking an outer expectation over $T$ , the MAML reward $J ( \theta ) = \mathbb { E } _ { T } \mathbb { E } _ { \mathbf { g } } f _ { \mathbf { g } } ^ { T } ( \mathbb { E } _ { \mathbf { h } } \dot { u } _ { \mathbf { h } } ( \theta , T ) )$ is no longer a stochastic composition of the required form. In particular, there are conceptual difficulties when the number of tasks in $\tau$ is infinite. However, it can be used to solve the MAML problem for each task within a consensus framework, such as consensus ADMM (Hong et al., 2016).
+
+# A.3 EXTENSIONS OF ES
+
+In this section, we discuss several general techniques for improving the basic ES gradient estimator (Algorithm 1). These can be applied both to the ES gradient of the meta-training (the ‘outer loop’ of Algorithm 3), and more interestingly, to the adaptation operator itself. That is, given $U ( \theta , T ) \stackrel { \textstyle - } { = }$ $\theta + \alpha \nabla \widetilde { f } _ { \sigma } ^ { T } ( \theta )$ , we replace the estimation of $U$ by ESGRAD on line 4 of Algorithm 3 with an improved estimator of $\nabla \widetilde { f } _ { \sigma } ^ { T } ( \theta )$ , which even may depend on data collected during the meta-training stage. Many techniques exist for reducing the variance of the estimator such as Quasi Monte Carlo sampling (Choromanski et al., 2018). Aside from variance reduction, there are also methods with special properties.
+
+# A.3.1 ACTIVE SUBSPACES
+
+Active Subspaces is a method for finding a low-dimensional subspace where the contribution of the gradient is maximized. Conceptually, the goal is to find and update on-the-fly a low-rank subspace $\mathcal { L }$ so that the projection $\nabla f ^ { T } ( \boldsymbol { \theta } ) _ { \mathcal { L } }$ of $\nabla f ^ { \mathbf { \nabla } } ( \theta )$ into $\mathcal { L }$ is maximized and apply $\nabla f ^ { T } ( \theta ) _ { \mathcal { L } }$ instead of $\nabla f ^ { T } ( \theta )$ . This should be done in such a way that $\nabla f ^ { T } ( \theta )$ does not need to be computed explicitly. Optimizing in lower-dimensional subspaces might be computationally more efficient and can be thought of as an example of guided ES methods, where the algorithm is guided how to explore space in the anisotropic way, leveraging its knowledge about function optimization landscape that it gained in the previous steps of optimization. In the context of RL, the active subspace method ASEBO (Choromanski et al., 2019b) was successfully applied to speed up policy training algorithms. This strategy can be made data-dependent also in the MAML context, by learning an optimal subspace using data from the meta-training stage, and sampling from that subspace in the adaptation step.
+
+# A.3.2 REGRESSION-BASED OPTIMIZATION
+
+Regression-Based Optimization (RBO) is an alternative method of gradient estimation. From Taylor series expansion we have $f ( { \boldsymbol { \theta } } + \mathbf { d } ) - f ( { \boldsymbol { \theta } } ) = \nabla f ( { \boldsymbol { \theta } } ) ^ { T } \mathbf { d } + O ( \| \mathbf { \bar { d } } \| ^ { 2 } )$ . By taking multiple finite difference expressions $f ( \theta + { \bf d } ) - f ( \theta )$ for different $\mathbf { d }$ , we can recover the gradient by solving a regularized regression problem. The regularization has an additional advantage - it was shown that the gradient can be recovered even if a substantial fraction of the rewards $f ( \theta + { \bf d } )$ are corrupted (Choromanski et al., 2019c). Strictly speaking, this is not based on the Gaussian smoothing as in ES, but is another method for estimating gradients using only zero-th order evaluations.
+
+# A.3.3 EXPERIMENTS
+
+We present a preliminary experiment with RBO and ASEBO gradient adaptation in Figure A3. To be precise, the algorithms used are identical to Algorithm 3 except that in line 4, $\mathbf { d } ^ { ( i ) }  \mathrm { \bar { E } S G R } \boldsymbol { \mathit { \Sigma } }$ D is replaced by $\mathbf { d } ^ { ( i ) }  \mathbf { R } \mathbf { B } \mathbf { O }$ (yielding RBO-MAML) and $\mathbf { d } ^ { ( i ) }  \bar { \mathbf { A } } \mathbf { S } \mathbf { E } \mathbf { B } \mathbf { O }$ (yielding ASEBO-MAML) respectively.
+
+![](images/944b249f7efd56cf286c8da0000c96bb66703e8e8172ad29e3928cfdcb7cea57.jpg)  
+Figure A3: RBO-MAML and ASEBO-MAML compared to ES-MAML.
+
+On the left plot, we test for noise robustness on the Forward-Backward Swimmer MAML task, comparing standard ES-MAML (Algorithm 3) to RBO-MAML. To simulate noisy data, we randomly corrupt $2 5 \%$ of the queries $f ^ { T } ( { \overline { { \theta } } } + \sigma g )$ used to estimate the adaptation operator $U ( \theta , T )$ with an enormous additive noise. This is the same type of corruption used in (Choromanski et al., 2019c).
+
+Interestingly, RBO does not appear to be more robust against noise than the standard MC estimator, which suggests that the original ES-MAML has some inherent robustness to noise.
+
+On the right plot, we compare ASEBO-MAML to ES-MAML on the Goal-Velocity HalfCheetah task in the low- $K$ setting. We found that when measured in iterations, ASEBO-MAML outperforms ES-MAML. However, ASEBO requires additional linear algebra operations and thus uses significantly more wall-clock time (not shown in plot) per iteration, so if measured by real time, then ES-MAML was more effective.
+
+# A.4 NAVIGATION-2D EXPLORATION TASK
+
+Navigation- $2 D$ (Finn et al., 2017) is a classic environment where the agent must explore to adapt to the task. The agent is represented by a point on a 2D square, and at each time step, receives reward equal to its distance from a given target point on the square. Note that unlike the four corners and six circles tasks, the reward for Navigation-2D is dense. We visualize the differing exploration strategies learned by PG-MAML and ES-MAML in Figure A4. Notice that PG-MAML makes many tiny movements in multiple directions to ‘triangulate’ the target location using the differences in reward for different state-action pairs. On the other hand, ES-MAML learns a meta-policy such that each perturbation of the meta-policy causes the agent to move in a different direction (represented by red paths), so it can determine the target location from the total rewards of each path.
+
+![](images/7743efe9624bcdee1f67cc14ff0db5797eb8968938a97287b4350d5846884cdd.jpg)  
+Figure A4: Comparing the exploration behavior of PG-MAML and ES-MAML on the Navigation2D task. We use $K = 2 0$ queries for each algorithm.
+
+# A.5 PG-MAML RL BENCHMARKS
+
+In Figure A5, we compare ES-MAML and PG-MAML on the Forward-Backward and Goal-Velocity tasks for HalfCheetah, Swimmer, Walker2d, and Ant, using the same values of $K$ that were used in the original experiments of (Finn et al., 2017).
+
+![](images/e3b5fc6f1921e17a3ab454ce483df00bbbc16057bfcd9c0bceb1d395ca2c2664.jpg)  
+Figure A5: Comparisons between ES-MAML and PG-MAML using the queries $K$ from (Finn et al., 2017).
+
+# A.6 REGRESSION AND SUPERVISED LEARNING
+
+MAML has also been applied to supervised learning. We demonstrate ES-MAML on sine regression (Finn et al., 2017), where the task is to fit a sine curve $f$ with unknown amplitude and phase given a set of $K$ pairs $( x _ { i } , f ( x _ { i } ) )$ . The meta-policy must be able to learn that all of tasks have a common periodic nature, so that it can correctly adapt to an unknown sine curve outside of the points $x _ { i }$ .
+
+For regression, the loss is the mean-squared error (MSE) between the adapted policy $\pi _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ and the true curve $f ( x )$ . Given data samples $\{ ( x _ { i } , f ( x _ { i } ) \} _ { i = 1 } ^ { K }$ , the empirical loss is $\begin{array} { r } { L ( \theta ) = \frac { 1 } { K } \sum _ { i = 1 } ^ { K } ( f ( x _ { i } ) - } \end{array}$ $\pi _ { \boldsymbol { \theta } } ( x _ { i } ) ) ^ { 2 }$ . Note that unlike in reinforcement learning, we can exactly compute $\nabla L ( \theta )$ ; for deep networks, this is by automatic differentiation. Thus, we opt to use Tensorflow to compute the adaptation operator $U ( \theta , T )$ in Algorithm 3. This is in accordance with the general principle that when gradients are available, it is more efficient to use the gradient than to approximate it by a zero-order method (Nesterov & Spokoiny, 2017).
+
+We show several results in Figure A6. The adaptation step size is $\alpha = 0 . 0 1$ , which is the same as in (Finn et al., 2017). For comparison, (Finn et al., 2017) reports that PG-MAML can obtain a loss of $\approx 0 . 5$ after one adaptation step with $K = 5$ , though it is not specified how many iterations the meta-policy was trained for. ES-MAML approaches the same level of performance, though the number of training iterations required is higher than for the RL tasks, and surprisingly high for what appears to be a simpler problem. This is likely again a reflection of the fact that for problems such as regression where the gradients are available, it is more efficient to use gradients.
+
+As an aside, this leads to a related question of the correct interpretation of the query number $K$ in the supervised setting. There is a distinction between obtaining a data sample $( x _ { i } , f ( x _ { i } ) )$ , and doing a computation (such as a gradient) using that sample. If the main bottleneck is collecting the data $\{ ( x _ { i } , f ( x _ { i } ) \}$ , then we may be satisfied with any algorithm that performs any number of operations on the data, as long as it uses only $K$ samples. On the other hand, in the (on-policy) RL setting, samples cannot typically be ‘re-used’ to the same extent, because rollouts $\tau$ sampled with a given policy $\pi _ { \theta }$ follow an unknown distribution ${ \mathcal { P } } ( \tau | \theta )$ which reduces their usefulness away from $\theta$ . Thus, the corresponding notion to rollouts in the SL setting would be the number of backpropagations (for PG-MAML) or perturbations (for ES-MAML), but clearly these have different relative costs than doing simulations in RL.
+
+![](images/b90ce753a22a6b3ac6b1cd444b23d91872ae060a1fa15556ab4bbc9c766cbe11.jpg)  
+Figure A6: The MSE of the adapted policy, for varying number of gradient steps and query number $K$ . Runs are averaged across 3 seeds.
+
+# A.7 HYPERPARAMETERS AND SETUPS
+
+# A.7.1 ENVIRONMENTS
+
+Unless otherwise explicitly stated, we default to $K = 2 0$ and horizon $= 2 0 0$ for all RL experiments. We also use the standard reward normalization in (Mania et al., 2018), and use a global state normalization (i.e. the same mean, standard deviation normalization values for MDP states are shared across workers).
+
+For the Ant environments (Goal-Position Ant, Forward-Backward Ant), there are significant differences in weighting on the auxiliary rewards such as control costs, contact costs, and survival rewards across different previous work (e.g. those costs are downweighted in (Finn et al., 2017) whereas the coefficients are vanilla Gym weightings in (Liu et al., 2019)). These auxiliary rewards can lead to local minima, such as the agent staying stationary to collect the survival bonus which may be confused with movement progress when presenting a training curve. To make sure the agent is explicitly performing the required task, we opted to remove such costs in our work and only present the main goal-distance cost and forward-movement reward respectively.
+
+For the other environments, we used default weightings and rewards, since they do not change across previous works.
+
+# A.7.2 ES-MAML HYPERPARAMETERS
+
+Let $N$ be the number of possible distinct tasks possible. We sample tasks without replacement, which is important if $N \ll 5$ , as each worker performs adaptations on all possible tasks.
+
+For standard ES-MAML (Algorithm 3), we used the following settings.
+
+<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>(Total Workers,#Perturbations,#Current Evals)</td><td rowspan=1 colspan=1>(300,150,150)</td></tr><tr><td rowspan=1 colspan=1>(Train SetSize,Task Batch Size,Test SetSize)</td><td rowspan=1 colspan=1>(50,5,5) or (N,N,N)</td></tr><tr><td rowspan=1 colspan=1>Number of rolloutsper parameter</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>NumberofPerturbationsperworker</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>Outer-Loop Precision Parameter</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>AdaptationPrecision Parameter</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>Outer-Loop Step Size</td><td rowspan=1 colspan=1>0.01</td></tr><tr><td rowspan=1 colspan=1>Adaptation Step Size (α)</td><td rowspan=1 colspan=1>0.05</td></tr><tr><td rowspan=1 colspan=1>Hidden Layer Width</td><td rowspan=1 colspan=1>32</td></tr><tr><td rowspan=1 colspan=1>ES Estimation Type</td><td rowspan=1 colspan=1>Forward-FD</td></tr><tr><td rowspan=1 colspan=1>Reward Normalization</td><td rowspan=1 colspan=1>True</td></tr><tr><td rowspan=1 colspan=1>State Normalization</td><td rowspan=1 colspan=1>True</td></tr></table>
+
+For ES-MAML and PG-MAML, we took 3 seeded runs, using the default TRPO hyperparameters found in (Liu et al., 2019).

parse/train/SyOvg6jxx/SyOvg6jxx.md

@@ -0,0 +1,372 @@
+# #Exploration: A Study of Count-Based Exploration for Deep Reinforcement Learning
+
+Haoran $\mathbf { T a n g ^ { 1 * } }$ , Rein Houthooft3,4∗, Davis Foote2, Adam Stooke2, Xi Chen2,4, Yan Duan2 4, John Schulman4, Filip De Turck3, Pieter Abbeel 2 4
+
+1 UC Berkeley, Department of Mathematics   
+2 UC Berkeley, Department of Electrical Engineering and Computer Sciences   
+3 Ghent University – imec, Department of Information Technology   
+4 OpenAI
+
+# Abstract
+
+Count-based exploration algorithms are known to perform near-optimally when used in conjunction with tabular reinforcement learning (RL) methods for solving small discrete Markov decision processes (MDPs). It is generally thought that count-based methods cannot be applied in high-dimensional state spaces, since most states will only occur once. Recent deep RL exploration strategies are able to deal with high-dimensional continuous state spaces through complex heuristics, often relying on optimism in the face of uncertainty or intrinsic motivation. In this work, we describe a surprising finding: a simple generalization of the classic count-based approach can reach near state-of-the-art performance on various highdimensional and/or continuous deep RL benchmarks. States are mapped to hash codes, which allows to count their occurrences with a hash table. These counts are then used to compute a reward bonus according to the classic count-based exploration theory. We find that simple hash functions can achieve surprisingly good results on many challenging tasks. Furthermore, we show that a domain-dependent learned hash code may further improve these results. Detailed analysis reveals important aspects of a good hash function: 1) having appropriate granularity and 2) encoding information relevant to solving the MDP. This exploration strategy achieves near state-of-the-art performance on both continuous control tasks and Atari 2600 games, hence providing a simple yet powerful baseline for solving MDPs that require considerable exploration.
+
+# 1 Introduction
+
+Reinforcement learning (RL) studies an agent acting in an initially unknown environment, learning through trial and error to maximize rewards. It is impossible for the agent to act near-optimally until it has sufficiently explored the environment and identified all of the opportunities for high reward, in all scenarios. A core challenge in RL is how to balance exploration—actively seeking out novel states and actions that might yield high rewards and lead to long-term gains; and exploitation—maximizing short-term rewards using the agent’s current knowledge. While there are exploration techniques for finite MDPs that enjoy theoretical guarantees, there are no fully satisfying techniques for highdimensional state spaces; therefore, developing more general and robust exploration techniques is an active area of research.
+
+Most of the recent state-of-the-art RL results have been obtained using simple exploration strategies such as uniform sampling (Mnih et al., 2015) and i.i.d./correlated Gaussian noise (Schulman et al., 2015; Lillicrap et al., 2015). Although these heuristics are sufficient in tasks with well-shaped rewards, the sample complexity can grow exponentially (with state space size) in tasks with sparse rewards (Osband et al., 2016b). Recently developed exploration strategies for deep RL have led to significantly improved performance on environments with sparse rewards. Bootstrapped DQN (Osband et al., 2016a) led to faster learning in a range of Atari 2600 games by training an ensemble of Q-functions. Intrinsic motivation methods using pseudo-counts achieve state-of-the-art performance on Montezuma’s Revenge, an extremely challenging Atari 2600 game (Bellemare et al., 2016). Variational Information Maximizing Exploration (VIME, Houthooft et al. (2016)) encourages the agent to explore by acquiring information about environment dynamics, and performs well on various robotic locomotion problems with sparse rewards. However, we have not seen a very simple and fast method that can work across different domains.
+
+Some of the classic, theoretically-justified exploration methods are based on counting state-action visitations, and turning this count into a bonus reward. In the bandit setting, the well-known UCB algorithm of Lai & Robbins (1985) chooses the action $a _ { t }$ at time $t$ that maximizes $\begin{array} { r } { \hat { r } ( a _ { t } ) + \sqrt { \frac { 2 \log t } { n ( a _ { t } ) } } } \end{array}$ where $\hat { r } ( a _ { t } )$ is the estimated reward, and $n ( a _ { t } )$ is the number of times action $a _ { t }$ was previously chosen. In the MDP setting, some of the algorithms have similar structure, for example, Model Based Interval Estimation–Exploration Bonus (MBIE-EB) of Strehl & Littman (2008) counts state-action pairs with a table $n ( s , a )$ and adding a bonus reward of the form $\frac { \beta } { \sqrt { n ( s , a ) } }$ to encourage exploring less visited pairs. Kolter & $\mathrm { N g }$ , (2009) show that the inverse-square-root dependence is optimal. MBIE and related algorithms assume that the augmented MDP is solved analytically at each timestep, which is only practical for small finite state spaces.
+
+This paper presents a simple approach for exploration, which extends classic counting-based methods to high-dimensional, continuous state spaces. We discretize the state space with a hash function and apply a bonus based on the state-visitation count. The hash function can be chosen to appropriately balance generalization across states, and distinguishing between states. We select problems from rllab (Duan et al., 2016) and Atari 2600 (Bellemare et al., 2012) featuring sparse rewards, and demonstrate near state-of-the-art performance on several games known to be hard for naïve exploration strategies. The main strength of the presented approach is that it is fast, flexible and complementary to most existing RL algorithms.
+
+In summary, this paper proposes a generalization of classic count-based exploration to high-dimensional spaces through hashing (Section 2); demonstrates its effectiveness on challenging deep RL benchmark problems and analyzes key components of well-designed hash functions (Section 3).
+
+# 2 Methodology
+
+# 2.1 Notation
+
+This paper assumes a finite-horizon discounted Markov decision process (MDP), defined by $( S , \mathcal { A } , \mathcal { P } , r , \rho _ { 0 } , \gamma , T )$ , in which $s$ is the state space, $\mathcal { A }$ the action space, $\mathcal { P }$ a transition proba, , , , ρ , γ,bility distribution, $r : S \times \mathcal { A } \to \mathbb { R } _ { \geq 0 }$ a reward function, $\rho _ { 0 }$ an initial state distribution, $\gamma \in ( 0 , 1 ]$ a discount factor, and f $T$ ρ γ ,the horizon. The goal of RL is to maximize the total expected discountedg reward $\begin{array} { r } { \mathbb { E } _ { \pi , \mathcal { P } } \left[ \sum _ { t = 0 } ^ { T } \gamma ^ { t } r ( s _ { t } , a _ { t } ) \right] } \end{array}$ over a policy $\pi$ , which outputs a distribution over actions given a state.
+
+# 2.2 Count-Based Exploration via Static Hashing
+
+Our approach discretizes the state space with a hash function $\phi : S \to \mathbb { Z }$ . An exploration bonus is added to the reward function, defined as
+
+$$
+r ^ { + } ( s , a ) = \frac { \beta } { \sqrt { n ( \phi ( s ) ) } } ,
+$$
+
+where $\beta \in \mathbb { R } _ { \geq 0 }$ is the bonus coefficient. Initially the counts $n ( \cdot )$ are set to zero for the whole range of $\phi$ β. For every state $s _ { t }$ encountered at time step $t$ , $n ( \phi ( s _ { t } ) )$ is increased by one. The agent is trained φwith rewards $( r + r ^ { + } )$ φ, while performance is evaluated as the sum of rewards without bonuses.
+
+Note that our approach is a departure from count-based exploration methods such as MBIE-EB since we use a state-space count $n ( s )$ rather than a state-action count $n ( s , a )$ . State-action counts $n ( s , a )$ , ,are investigated in Appendix A.6, but no significant performance gains over state counting could be witnessed.
+
+1 Define state preprocessor $g : S \to { \mathbb { R } ^ { K } }$   
+2 (In case of SimHash) Initialize $A \in \mathbb { R } ^ { k \times K }$ with entries drawn i.i.d. from the standard Gaussian distribution $N ( 0 , 1 )$   
+,3 Initialize a hash table with values $n ( \cdot ) \equiv 0$   
+4 for each iteration $j$ do   
+5 Collect a set of state-action samples $\{ ( s _ { m } , a _ { m } ) \} _ { m = 0 } ^ { M }$ with policy $\pi$   
+6 , πCompute hash codes through any LSH method, e.g., for SimHash, $\phi ( s _ { m } ) = \operatorname { s g n } ( A g ( s _ { m } ) )$   
+7 Update the hash table counts $\forall m : 0 \leq m \leq M$ as $n ( \phi ( s _ { m } ) )  n ( \phi ( s _ { m } ) ) + 1$   
+8 Update the policy $\pi$ using rewards $\begin{array} { r } { \bigg \{ r ( s _ { m } , a _ { m } ) + \frac { \beta } { \sqrt { n ( \phi ( s _ { m } ) ) } } \bigg \} _ { m = 0 } ^ { M } } \end{array}$ with any RL algorithm
+
+Clearly the performance of this method will strongly depend on the choice of hash function $\phi$ . One φimportant choice we can make regards the granularity of the discretization: we would like for “distant” states to be be counted separately while “similar” states are merged. If desired, we can incorporate prior knowledge into the choice of $\phi$ , if there would be a set of salient state features which are known to be relevant.
+
+Algorithm 1 summarizes our method. The main idea is to use locality-sensitive hashing (LSH) to convert continuous, high-dimensional data to discrete hash codes. LSH is a popular class of hash functions for querying nearest neighbors based on certain similarity metrics (Andoni $\&$ Indyk, 2006). A computationally efficient type of LSH is SimHash (Charikar, 2002), which measures similarity by angular distance. SimHash retrieves a binary code of state $s \in S$ as
+
+$$
+\phi ( s ) = \operatorname { s g n } ( A g ( s ) ) \in \{ - 1 , 1 \} ^ { k } ,
+$$
+
+where $g : S  \mathbb { R } ^ { d }$ is an optional preprocessing function and $A$ is a $k \times d$ matrix with i.i.d. entries drawn from a standard Gaussian distribution $N ( 0 , 1 )$ . The value for $k$ controls the granularity: higher ,values lead to fewer collisions and are thus more likely to distinguish states.
+
+# 2.3 Count-Based Exploration via Learned Hashing
+
+When the MDP states have a complex structure, as is the case with image observations, measuring their similarity directly in pixel space fails to provide the semantic similarity measure one would desire. Previous work in computer vision (Lowe, 1999; Dalal & Triggs, 2005; Tola et al., 2010) introduce manually designed feature representations of images that are suitable for semantic tasks including detection and classification. More recent methods learn complex features directly from data by training convolutional neural networks (Krizhevsky et al., 2012; Simonyan & Zisserman, 2014; He et al., 2015). Considering these results, it may be difficult for SimHash to cluster states appropriately using only raw pixels.
+
+![](images/fb4582a662e173f79d27cec1b6c5fc7d7c3c6da61f9553210eb95cbf03c39201.jpg)  
+Figure 1: The autoencoder (AE) architecture; the solid block represents the dense sigmoidal binary code layer, after which noise $U ( - a , a )$ is injected.
+
+Therefore, we propose to use an autoencoder (AE) consisting of convolutional, dense, and transposed convolutional layers to learn meaningful hash codes in one of its hidden layers. This AE takes as input states $s$ and contains one special dense layer comprised of $K$ saturating activation functions,
+
+1 Define state preprocessor $g : S \to { \mathbb { B } } ^ { K }$ as the binary code resulting from the autoencoder (AE)   
+2 Initialize $A \in \mathbb { R } ^ { k \times K }$ with entries drawn i.i.d. from the standard Gaussian distribution $N ( 0 , 1 )$   
+3 Initialize a hash table with values $n ( \cdot ) \equiv 0$   
+4 for each iteration $j$ do   
+5 Collect a set of state-action samples $\{ ( s _ { m } , a _ { m } ) \} _ { m = 0 } ^ { M }$ with policy $\pi$   
+6 Add the state samples $\{ s _ { m } \} _ { m = 0 } ^ { M }$ , to a FIFO replay pool $\mathcal { R }$   
+7 if $j$ mod $j _ { \mathrm { u p d a t e } } = 0$ then   
+8 Update the AE loss function in Eq. (3) using samples drawn from the replay pool   
+$\{ s _ { n } \} _ { n = 1 } ^ { N } \sim \mathcal { R }$ , for example using stochastic gradient descent   
+9 Compute $g ( s _ { m } ) = \lfloor b ( s _ { m } ) \rceil$ , the $K$ -dim rounded hash code for $s _ { m }$ learned by the AE   
+10 Project $g ( s _ { m } )$ to a lower dimension $k$ via SimHash as $\phi ( s _ { m } ) = \operatorname { s g n } ( A g ( s _ { m } ) )$   
+11 Update the hash table counts $\forall m : 0 \leq m \leq M$ as $n ( \phi ( s _ { m } ) )  n ( \phi ( s _ { m } ) ) + 1$   
+12 Update the policy $\pi$ using rewards $\begin{array} { r } { \bigg \{ r ( s _ { m } , a _ { m } ) + \frac { \beta } { \sqrt { n ( \phi ( s _ { m } ) ) } } \bigg \} _ { m = } ^ { M } } \end{array}$ with any RL algorithm
+
+more specifically sigmoid functions. By rounding the sigmoid output $b ( s )$ of this layer to the closest binary number, any state $s$ can be binarized.
+
+Since gradients cannot be back-propagated through a rounding function, an alternative method must be used to ensure that distinct states are mapped to distinct binary codes. Therefore, uniform noise $U ( - a , a )$ is added to the sigmoid output. By choosing uniform noise with a sufficiently high variance, ,the AE is only capable of reconstructing distinct inputs $s$ if its hidden dense layer outputs values $b ( s )$ that are sufficiently far apart from each other (Gregor et al., 2016). Feeding a state $s$ to the AE input, extracting $b ( s )$ and rounding it to $\lfloor b ( s ) \rceil$ yields a learned binary code. As such, the loss function $L ( \cdot )$ over a set of collected states $\{ s _ { i } \} _ { i = 1 } ^ { N }$ is defined as
+
+$$
+L \left( \{ s _ { n } \} _ { n = 1 } ^ { N } \right) = - \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \left[ \log p ( s _ { n } ) - \frac { \lambda } { K } \sum _ { i = 1 } ^ { K } \operatorname* { m i n } \left\{ \left( 1 - b _ { i } ( s _ { n } ) \right) ^ { 2 } , b _ { i } ( s _ { n } ) ^ { 2 } \right\} \right] .
+$$
+
+This objective function consists of a cross-entropy term and a term that pressures the binary code layer to take on binary values, scaled by $\lambda \in \mathbb { R } _ { \ge 0 }$ . The reasoning behind this is that uniform noise $U ( - a , a )$ λ ,alone is insufficient, in case the AE does not use a particular sigmoid unit. This term ensures that an unused binary code output is assigned an arbitrary binary value. When omitting this term, the code is more prone to oscillations, causing unwanted bit flips, and destabilizing the counting process.
+
+In order to make the AE train sufficiently fast—which is required since it is updated during the agent’s training—we make use of a pixel-wise softmax output layer (van den Oord et al., 2016) that shares weights between all pixels. The different softmax outputs merge together pixel intensities into discrete bins. The architectural details are described in Appendix A.1 and are depicted in Figure 1. Because the code dimension often needs to be large in order to correctly reconstruct the input, we apply a downsampling procedure to the resulting binary code $\lfloor b ( s ) \rceil$ , which can be done through random projection to a lower-dimensional space via SimHash as in Eq. (2).
+
+One the one hand, it is important that the mapping from state to code needs to remain relatively consistent over time, which is nontrivial as the AE is constantly updated according to the latest data (Algorithm 2 line 8). An obvious solution would be to significantly downsample the binary code to a very low dimension, or by slowing down the training process. But on the other hand, the code has to remain relatively unique for states that are both distinct and close together on the image manifold. This is tackled both by the second term in Eq. (3) and by the saturating behavior of the sigmoid units. As such, states that are already well represented in the AE hidden layers tend to saturate the sigmoid units, causing the resulting loss gradients to be close to zero and making the code less prone to change.
+
+# 3 Experiments
+
+Experiments were designed to investigate and answer the following research questions:
+
+1. Can count-based exploration through hashing improve performance significantly across different domains? How does the proposed method compare to the current state of the art in exploration for deep RL?   
+2. What is the impact of learned or static state preprocessing on the overall performance when image observations are used?   
+3. What factors contribute to good performance, e.g., what is the appropriate level of granularity of the hash function?
+
+To answer question 1, we run the proposed method on deep RL benchmarks (rllab and ALE) that feature sparse rewards, and compare it to other state-of-the-art algorithms. Question 2 is answered by trying out different image preprocessors on Atari 2600 games. Finally, we investigate question 3 in Section 3.3 and 3.4. Trust Region Policy Optimization (TRPO, Schulman et al. (2015)) is chosen as the RL algorithm for all experiments, because it can handle both discrete and continuous action spaces, it can conveniently ensure stable improvement in the policy performance, and is relatively insensitive to hyperparameter changes. The hyperparameters settings are reported in Appendix A.1.
+
+# 3.1 Continuous Control
+
+The rllab benchmark (Duan et al., 2016) consists of various control tasks to test deep RL algorithms. We selected several variants of the basic and locomotion tasks that use sparse rewards, as shown in Figure 2, and adopt the experimental setup as defined in (Houthooft et al., 2016)—a description can be found in Appendix A.2. These tasks are all highly difficult to solve with naïve exploration strategies, such as adding Gaussian noise to the actions.
+
+![](images/b361a9b8e95718220308863d606ae375328e7733c70f739e9726b183648949f3.jpg)  
+Figure 2: Illustrations of the rllab tasks used in the continuous control experiments, namely MountainCar, CartPoleSwingup, SimmerGather, and HalfCheetah; taken from (Duan et al., 2016).
+
+![](images/3bddef7257aca125ef3ed901547493485ea605e4b0e6a4992fb9a784035e4180.jpg)  
+Figure 3: Mean average return of different algorithms on rllab tasks with sparse rewards; the solid line represents the mean average return, while the shaded area represents one standard deviation, over 5 seeds for the baseline and SimHash.
+
+Figure 3 shows the results of TRPO (baseline), TRPO-SimHash, and VIME (Houthooft et al., 2016) on the classic tasks MountainCar and CartPoleSwingup, the locomotion task HalfCheetah, and the hierarchical task SwimmerGather. Using count-based exploration with hashing is capable of reaching the goal in all environments (which corresponds to a nonzero return), while baseline TRPO with Gaussian control noise fails completely. Although TRPO-SimHash picks up the sparse reward on HalfCheetah, it does not perform as well as VIME. In contrast, the performance of SimHash is comparable with VIME on MountainCar, while it outperforms VIME on SwimmerGather.
+
+# 3.2 Arcade Learning Environment
+
+The Arcade Learning Environment (ALE, Bellemare et al. (2012)), which consists of Atari 2600 video games, is an important benchmark for deep RL due to its high-dimensional state space and wide variety of games. In order to demonstrate the effectiveness of the proposed exploration strategy, six games are selected featuring long horizons while requiring significant exploration: Freeway, Frostbite, Gravitar, Montezuma’s Revenge, Solaris, and Venture. The agent is trained for 500 iterations in all experiments, with each iteration consisting of $0 . 1 { \bf M }$ steps (the TRPO batch size, corresponds to $0 . 4 { \bf M }$ . .frames). Policies and value functions are neural networks with identical architectures to (Mnih et al., 2016). Although the policy and baseline take into account the previous four frames, the counting algorithm only looks at the latest frame.
+
+BASS To compare with the autoencoder-based learned hash code, we propose using Basic Abstraction of the ScreenShots (BASS, also called Basic; see Bellemare et al. (2012)) as a static preprocessing function g. BASS is a hand-designed feature transformation for images in Atari 2600 games. BASS builds on the following observations specific to Atari: 1) the game screen has a low resolution, 2) most objects are large and monochrome, and 3) winning depends mostly on knowing object locations and motions. We designed an adapted version of BASS1, that divides the RGB screen into square cells, computes the average intensity of each color channel inside a cell, and assigns the resulting values to bins that uniformly partition the intensity range [0 255]. Mathematically, let $C$ be the cell size (width and height), $B$ the number of bins, $( i , j )$ ,cell location, $( x , y )$ pixel location, and $z$ the channel.
+
+$$
+\begin{array} { r } { \mathrm { f e a t u r e } ( i , j , z ) = \left\lfloor { \frac { B } { 2 5 5 C ^ { 2 } } } \sum _ { ( x , y ) \in \mathrm { c e l l } ( i , j ) } I ( x , y , z ) \right\rfloor . } \end{array}
+$$
+
+Afterwards, the resulting integer-valued feature tensor is converted to an integer hash code $\mathbf { \nabla } _ { \phi } ( s _ { t } )$ in φLine 6 of Algorithm 1). A BASS feature can be regarded as a miniature that efficiently encodes object locations, but remains invariant to negligible object motions. It is easy to implement and introduces little computation overhead. However, it is designed for generic Atari game images and may not capture the structure of each specific game very well.
+
+Table 1: Atari 2600: average total reward after training for $5 0 \mathrm { M }$ time steps. Boldface numbers indicate best results. Italic numbers are the best among our methods.   
+
+<table><tr><td></td><td>Freeway</td><td>Frostbite1</td><td>Gravitar</td><td>Montezuma</td><td>Solaris</td><td>Venture</td></tr><tr><td>TRPO (baseline)</td><td>16.5</td><td>2869</td><td>486</td><td>0</td><td>2758</td><td>121</td></tr><tr><td>TRPO-pixel-SimHash</td><td>31.6</td><td>4683</td><td>468</td><td>0</td><td>2897</td><td>263</td></tr><tr><td>TRPO-BASS-SimHash</td><td>28.4</td><td>3150</td><td>604</td><td>238</td><td>1201</td><td>616</td></tr><tr><td>TRPO-AE-SimHash</td><td>33.5</td><td>5214</td><td>482</td><td>75</td><td>4467</td><td>445</td></tr><tr><td>Double-DQN</td><td>33.3</td><td>1683</td><td>412</td><td>0</td><td>3068</td><td>98.0</td></tr><tr><td>Dueling network</td><td>0.0</td><td>4672</td><td>588</td><td>0</td><td>2251</td><td>497</td></tr><tr><td>Gorila</td><td>11.7</td><td>605</td><td>1054</td><td>4</td><td>N/A</td><td>1245</td></tr><tr><td>DQN Pop-Art</td><td>33.4</td><td>3469</td><td>483</td><td>0</td><td>4544</td><td>1172</td></tr><tr><td>A3C+</td><td>27.3</td><td>507</td><td>246</td><td>142</td><td>2175</td><td>0</td></tr><tr><td>pseudo-count²</td><td>29.2</td><td>1450</td><td>/</td><td>3439</td><td></td><td>369</td></tr></table>
+
+1 While Vezhnevets et al. (2016) reported best score 8108, their evaluation was based on top 5 agents trained with 500M time steps, hence not comparable. 2 Results reported only for $2 5 \mathbf { M }$ time steps ( $1 0 0 \mathbf { M }$ frames).
+
+We compare our results to double DQN (van Hasselt et al., 2016b), dueling network (Wang et al., 2016), ${ \bf A } 3 { \bf C } +$ (Bellemare et al., 2016), double DQN with pseudo-counts (Bellemare et al., 2016), Gorila (Nair et al., 2015), and DQN Pop-Art (van Hasselt et al., 2016a) on the “null op” metric2. We show training curves in Figure 4 and summarize all results in Table 1. Surprisingly, TRPO-pixelSimHash already outperforms the baseline by a large margin and beats the previous best result on Frostbite. TRPO-BASS-SimHash achieves significant improvement over TRPO-pixel-SimHash on
+
+Montezuma’s Revenge and Venture, where it captures object locations better than other methods.3   
+TRPO-AE-SimHash achieves near state-of-the-art performance on Freeway, Frostbite and Solaris.4
+
+![](images/7b881fc3dab477957b5fae40811e112642ed0c282e638819df700bebd28f689a.jpg)  
+Figure 4: Atari 2600 games: the solid line is the mean average undiscounted return per iteration, while the shaded areas represent the one standard deviation, over 5 seeds for the baseline, TRPOpixel-SimHash, and TRPO-BASS-SimHash, while over 3 seeds for TRPO-AE-SimHash.
+
+As observed in Table 1, preprocessing images with BASS or using a learned hash code through the AE leads to much better performance on Gravitar, Montezuma’s Revenge and Venture. Therefore, an static or adaptive preprocessing step can be important for a good hash function.
+
+In conclusion, our count-based exploration method is able to achieve remarkable performance gains even with simple hash functions like SimHash on the raw pixel space. If coupled with domain-dependent state preprocessing techniques, it can sometimes achieve far better results.
+
+# 3.3 Granularity
+
+While our proposed method is able to achieve remarkable results without requiring much tuning, the granularity of the hash function should be chosen wisely. Granularity plays a critical role in count-based exploration, where the hash function should cluster states without under-generalizing or over-generalizing. Table 2 summarizes granularity parameters for our hash functions. In Table 3 we summarize the performance of TRPO-pixel-SimHash under different granularities. We choose Frostbite and Venture on which TRPO-pixel-SimHash outperforms the baseline, and choose as reward bonus coefficient $\textstyle { \beta = 0 . 0 1 \times { \frac { 2 5 6 } { k } } }$ to keep average bonus rewards at approximately the same scale. $k = 1 6$ β . only corresponds to 65536 distinct hash codes, which is insufficient to distinguish between semantically distinct states and hence leads to worse performance. We observed that $k = 5 1 2$ tends to capture trivial image details in Frostbite, leading the agent to believe that every state is new and equally worth exploring. Similar results are observed while tuning the granularity parameters for TRPO-BASS-SimHash and TRPO-AE-SimHash.
+
+The best granularity depends on both the hash function and the MDP. While adjusting granularity parameter, we observed that it is important to lower the bonus coefficient as granularity is increased. This is because a higher granularity is likely to cause lower state counts, leading to higher bonus rewards that may overwhelm the true rewards.
+
+Table 2: Granularity parameters of various hash functions   
+
+<table><tr><td>SimHash</td><td>k: size of the binary code</td></tr><tr><td>BASS</td><td>C: cell size;B: number of bins for each color channel</td></tr><tr><td>AE</td><td>k: down stream SimHash parameter; size of the binary code λ: binarization parameter</td></tr><tr><td></td><td>SmartHashs: grid size for the agent&#x27;s (x,y) coordinates</td></tr></table>
+
+Table 3: Average score at $5 0 \mathrm { M }$ time steps achieved by TRPO-pixel-SimHash   
+
+<table><tr><td>k</td><td>16</td><td>64</td><td>128</td><td>256</td><td>512</td></tr><tr><td>Frostbite</td><td>3326</td><td>4029</td><td>3932</td><td>4683</td><td>1117</td></tr><tr><td> Venture</td><td>0</td><td>218</td><td>142</td><td>263</td><td>306</td></tr></table>
+
+Table 4: Average score at $5 0 \mathrm { M }$ time steps achieved by TRPO-SmartHash on Montezuma’s Revenge (RAM observations)   
+
+<table><tr><td>S</td><td>1</td><td>5</td><td>10</td><td>20</td><td>40</td><td>60</td></tr><tr><td>score</td><td>2598</td><td>2500</td><td>3533</td><td>3025</td><td>2500</td><td>1921</td></tr></table>
+
+# 3.4 A Case Study of Montezuma’s Revenge
+
+Montezuma’s Revenge is widely known for its extremely sparse rewards and difficult exploration (Bellemare et al., 2016). While our method does not outperform Bellemare et al. (2016) on this game, we investigate the reasons behind this through various experiments. The experiment process below again demonstrates the importance of a hash function having the correct granularity and encoding relevant information for solving the MDP.
+
+Our first attempt is to use game RAM states instead of image observations as inputs to the policy (details in Appendix A.1), which leads to a game score of 2500 with TRPO-BASS-SimHash. Our second attempt is to manually design a hash function that incorporates domain knowledge, called SmartHash, which uses an integer-valued vector consisting of the agent’s $( x , y )$ location, room number ,and other useful RAM information as the hash code (details in Appendix A.3). The best SmartHash agent is able to obtain a score of 3500. Still the performance is not optimal. We observe that a slight change in the agent’s coordinates does not always result in a semantically distinct state, and thus the hash code may remain unchanged. Therefore we choose grid size $s$ and replace the √ $x$ coordinate by $\lfloor ( x - x _ { \mathrm { m i n } } ) / s \rfloor$ (similarly for $y$ ). The bonus coefficient is chosen as $\beta = 0 . 0 \bar { 1 } \sqrt { s }$ to maintain the scale / β .relative to the true reward5 (see Table 4). Finally, the best agent is able to obtain 6600 total rewards after training for 1000 iterations ( $1 0 0 0 \mathbf { M }$ time steps), with a grid size $s = 1 0$ .
+
+![](images/be0d5543a0ab05f99beefa2981092d2dbb3a8aa035a340793a06231dfa7e6ede.jpg)  
+Figure 5: SmartHash results on Montezuma’s Revenge (RAM observations): the solid line is the mean average undiscounted return per iteration, while the shaded areas represent the one standard deviation, over 5 seeds.
+
+During our pursuit, we had another interesting discovery that the ideal hash function should not simply cluster states by their visual similarity, but instead by their relevance to solving the MDP. We experimented with including enemy locations in the first two rooms into SmartHash $( s = 1 0$ ), and observed that average score dropped to 1672 (at iteration 1000). Though it is important for the agent to dodge enemies, the agent also erroneously “enjoys” watching enemy motions at distance (since new states are constantly observed) and “forgets” that his main objective is to enter other rooms. An alternative hash function keeps the same entry “enemy locations”, but instead only puts randomly sampled values in it, which surprisingly achieves better performance (3112). However, by ignoring enemy locations altogether, the agent achieves a much higher score (5661) (see Figure 5). In retrospect, we examine the hash codes generated by BASS-SimHash and find that codes clearly distinguish between visually different states (including various enemy locations), but fails to emphasize that the agent needs to explore different rooms. Again this example showcases the importance of encoding relevant information in designing hash functions.
+
+# 4 Related Work
+
+Classic count-based methods such as MBIE (Strehl & Littman, 2005), MBIE-EB and (Kolter & Ng, 2009) solve an approximate Bellman equation as an inner loop before the agent takes an action (Strehl & Littman, 2008). As such, bonus rewards are propagated immediately throughout the state-action space. In contrast, contemporary deep RL algorithms propagate the bonus signal based on rollouts collected from interacting with environments, with value-based (Mnih et al., 2015) or policy gradient-based (Schulman et al., 2015; Mnih et al., 2016) methods, at limited speed. In addition, our proposed method is intended to work with contemporary deep RL algorithms, it differs from classical count-based method in that our method relies on visiting unseen states first, before the bonus reward can be assigned, making uninformed exploration strategies still a necessity at the beginning. Filling the gaps between our method and classic theories is an important direction of future research.
+
+A related line of classical exploration methods is based on the idea of optimism in the face of uncertainty (Brafman & Tennenholtz, 2002) but not restricted to using counting to implement “optimism”, e.g. R-Max (Brafman & Tennenholtz, 2002), UCRL (Jaksch et al., 2010), and $\mathrm { E } ^ { \hat { 3 } }$ (Kearns & Singh, 2002). These methods, similar to MBIE and MBIE-EB, have theoretical guarantees in tabular settings.
+
+Bayesian RL methods (Kolter & Ng, 2009; Guez et al., 2014; Sun et al., 2011; Ghavamzadeh et al., 2015), which keep track of a distribution over MDPs, are an alternative to optimism-based methods. Extensions to continuous state space have been proposed by Pazis & Parr (2013) and Osband et al. (2016b).
+
+Another type of exploration is curiosity-based exploration. These methods try to capture the agent’s surprise about transition dynamics. As the agent tries to optimize for surprise, it naturally discovers novel states. We refer the reader to Schmidhuber (2010) and Oudeyer & Kaplan (2007) for an extensive review on curiosity and intrinsic rewards.
+
+Several exploration strategies for deep RL have been proposed to handle high-dimensional state space recently. Houthooft et al. (2016) propose VIME, in which information gain is measured in Bayesian neural networks modeling the MDP dynamics, which is used an exploration bonus. Stadie et al. (2015) propose to use the prediction error of a learned dynamics model as an exploration bonus. Thompson sampling through bootstrapping is proposed by Osband et al. (2016a), using bootstrapped Q-functions.
+
+The most related exploration strategy is proposed by Bellemare et al. (2016), in which an exploration bonus is added inversely proportional to the square root of a pseudo-count quantity. A state pseudocount is derived from its log-probability improvement according to a density model over the state space, which in the limit converges to the empirical count. Our method is similar to pseudo-count approach in the sense that both methods are performing approximate counting to have the necessary generalization over unseen states. The difference is that a density model has to be designed and learned to achieve good generalization for pseudo-count whereas in our case generalization is obtained by a wide range of simple hash functions (not necessarily SimHash). Another interesting connection is that our method also implies a density model $\begin{array} { r } { \rho ( s ) = \frac { n ( \phi ( s ) ) } { N } } \end{array}$ over all visited states, where $N$ is the ρ total number of states visited. Another method similar to hashing is proposed by Abel et al. (2016), which clusters states and counts cluster centers instead of the true states, but this method has yet to be tested on standard exploration benchmark problems.
+
+# 5 Conclusions
+
+This paper demonstrates that a generalization of classical counting techniques through hashing is able to provide an appropriate signal for exploration, even in continuous and/or high-dimensional MDPs using function approximators, resulting in near state-of-the-art performance across benchmarks. It provides a simple yet powerful baseline for solving MDPs that require informed exploration.
+
+# Acknowledgments
+
+We would like to thank our colleagues at Berkeley and OpenAI for insightful discussions. This research was funded in part by ONR through a PECASE award. Yan Duan was also supported by a Berkeley AI Research lab Fellowship and a Huawei Fellowship. Xi Chen was also supported by a Berkeley AI Research lab Fellowship. We gratefully acknowledge the support of the NSF through grant IIS-1619362 and of the ARC through a Laureate Fellowship (FL110100281) and through the ARC Centre of Excellence for Mathematical and Statistical Frontiers. Adam Stooke gratefully acknowledges funding from a Fannie and John Hertz Foundation fellowship. Rein Houthooft is supported by a Ph.D. Fellowship of the Research Foundation - Flanders (FWO).
+
+# References
+
+David Abel, Alekh Agarwal, Fernando Diaz, Akshay Krishnamurthy, and Robert E Schapire. Exploratory gradient boosting for reinforcement learning in complex domains. arXiv preprint arXiv:1603.04119, 2016.
+
+Alexandr Andoni and Piotr Indyk. Near-optimal hashing algorithms for approximate nearest neighbor in high dimensions. In 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS), pp. 459–468, 2006.
+
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 2012.
+
+Marc G Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, 2016.
+
+Burton H. Bloom. Space/time trade-offs in hash coding with allowable errors. Communications of the ACM, 13(7):422–426, 1970.
+
+Ronen I Brafman and Moshe Tennenholtz. R-max-a general polynomial time algorithm for near-optimal reinforcement learning. Journal of Machine Learning Research, 3:213–231, 2002.
+
+Moses S Charikar. Similarity estimation techniques from rounding algorithms. In Proceedings of the thirty-fourth annual ACM symposium on Theory of computing, pp. 380–388, 2002.
+
+Graham Cormode and S Muthukrishnan. An improved data stream summary: the count-min sketch and its applications. Journal of Algorithms, 55(1):58–75, 2005.
+
+Navneet Dalal and Bill Triggs. Histograms of oriented gradients for human detection. In 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’05), volume 1, pp. 886–893. IEEE, 2005.
+
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continous control. In International Conference on Machine Learning (ICML), 2016.
+
+Li Fan, Pei Cao, Jussara Almeida, and Andrei Z Broder. Summary cache: a scalable wide-area web cache sharing protocol. IEEE/ACM Transactions on Networking (TON), 8(3):281–293, 2000.
+
+Mohammad Ghavamzadeh, Shie Mannor, Joelle Pineau, and Aviv Tamar. Bayesian reinforcement learning: A survey. Foundations and Trends in Machine Learning, 8(5-6):359–483, 2015.
+
+Karol Gregor, Frederic Besse, Danilo Jimenez Rezende, Ivo Danihelka, and Daan Wierstra. Towards conceptual compression. arXiv preprint arXiv:1604.08772, 2016.
+
+Arthur Guez, Nicolas Heess, David Silver, and Peter Dayan. Bayes-adaptive simulation-based search with value function approximation. In Advances in Neural Information Processing Systems (NIPS), pp. 451–459, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.
+
+Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. VIME: Variational information maximizing exploration. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning (ICML), pp. 448–456, 2015.
+
+Thomas Jaksch, Ronald Ortner, and Peter Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11:1563–1600, 2010.
+
+Michael Kearns and Satinder Singh. Near-optimal reinforcement learning in polynomial time. Machine Learning, 49(2-3):209–232, 2002.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR), 2015.
+
+J Zico Kolter and Andrew Y Ng. Near-bayesian exploration in polynomial time. In International Conference on Machine Learning (ICML), pp. 513–520, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Tze Leung Lai and Herbert Robbins. Asymptotically efficient adaptive allocation rules. Advances in applied mathematics, 6(1):4–22, 1985.
+
+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.
+
+David G Lowe. Object recognition from local scale-invariant features. In Computer vision, 1999. The proceedings of the seventh IEEE international conference on, volume 2, pp. 1150–1157. Ieee, 1999.
+
+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 P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. arXiv preprint arXiv:1602.01783, 2016.
+
+Arun Nair, Praveen Srinivasan, Sam Blackwell, Cagdas Alcicek, Rory Fearon, Alessandro De Maria, Vedavyas Panneershelvam, Mustafa Suleyman, Charles Beattie, Stig Petersen, et al. Massively parallel methods for deep reinforcement learning. arXiv preprint arXiv:1507.04296, 2015.
+
+Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped DQN. In Advances in Neural Information Processing Systems (NIPS), 2016a.
+
+Ian Osband, Benjamin Van Roy, and Zheng Wen. Generalization and exploration via randomized value functions. In International Conference on Machine Learning (ICML), 2016b.
+
+Pierre-Yves Oudeyer and Frederic Kaplan. What is intrinsic motivation? A typology of computational approaches. Frontiers in Neurorobotics, 1:6, 2007.
+
+Jason Pazis and Ronald Parr. PAC optimal exploration in continuous space Markov decision processes. In Twenty-Seventh AAAI Conference on Artificial Intelligence, 2013.
+
+Jürgen Schmidhuber. Formal theory of creativity, fun, and intrinsic motivation (1990–2010). IEEE Transactions on Autonomous Mental Development, 2(3):230–247, 2010.
+
+John Schulman, Sergey Levine, Philipp Moritz, Michael I Jordan, and Pieter Abbeel. Trust region policy optimization. In International Conference on Machine Learning (ICML), 2015.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Bradly C Stadie, Sergey Levine, and Pieter Abbeel. Incentivizing exploration in reinforcement learning with deep predictive models. arXiv preprint arXiv:1507.00814, 2015.
+
+Alexander L Strehl and Michael L Littman. A theoretical analysis of model-based interval estimation. In International Conference on Machine Learning (ICML), pp. 856–863, 2005.
+
+Alexander L Strehl and Michael L Littman. An analysis of model-based interval estimation for Markov decision processes. Journal of Computer and System Sciences, 74(8):1309–1331, 2008.
+
+Yi Sun, Faustino Gomez, and Jürgen Schmidhuber. Planning to be surprised: Optimal Bayesian exploration in dynamic environments. In Artificial General Intelligence, pp. 41–51. 2011.
+
+Engin Tola, Vincent Lepetit, and Pascal Fua. Daisy: An efficient dense descriptor applied to wide-baseline stereo. IEEE transactions on pattern analysis and machine intelligence, 32(5): 815–830, 2010.
+
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. In International Conference on Machine Learning (ICML), 2016.
+
+Hado van Hasselt, Arthur Guez, Matteo Hessel, and David Silver. Learning functions across many orders of magnitudes. arXiv preprint arXiv:1602.07714, 2016a.
+
+Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double Q-learning. In Thirtieth AAAI Conference on Artificial Intelligence, 2016b.
+
+Alexander Vezhnevets, Volodymyr Mnih, John Agapiou, Simon Osindero, Alex Graves, Oriol Vinyals, and Koray Kavukcuoglu. Strategic attentive writer for learning macro-actions. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Ziyu Wang, Nando de Freitas, and Marc Lanctot. Dueling network architectures for deep reinforcement learning. In International Conference on Machine Learning (ICML), 2016.
+
+# A Appendices
+
+# A.1 Hyperparameter Settings
+
+For the rllab experiments, we used batch size 5000 for all tasks except SwimmerGather, for which we used batch size 50000. CartpoleSwingup makes use of a neural network policy with one layer of 32 tanh units. The other tasks make use of a two layer neural network policy of 32 tanh units each for MountainCar and HalfCheetah, and of 64 and 32 tanh units for SwimmerGather. The outputs are modeled by a fully factorized Gaussian distribution ${ \cal N } ( \mu , \sigma ^ { 2 } I )$ , in which $\mu$ is modeled as the network output, while $\sigma$ µ, σ µis a parameter. CartPoleSwingup makes use of a neural network baseline with one σlayer of 32 ReLU units, while all other tasks make use of a linear baseline function. For all tasks, we used TRPO step size 0 01 and discount factor $\gamma = 0 . 9 9$ . We choose SimHash parameter $k = 3 2$ and bonus coefficient $\beta = 0 . 0 1$ γ ., found through a coarse grid search.
+
+For Atari experiments, a batch size of 100000 is used, while the KL divergence step size is set to 0 01. The policy and baseline both have the following architecture: 2 convolutional layers with .respectively 16 and 32 filters, sizes $8 \times 8$ and $4 \times 4$ , strides 4 and 2, using no padding, feeding into a single hidden layer of 256 units. The nonlinearities are rectified linear units (ReLUs). The input frames are downsampled to $5 2 \times 5 2$ . The input to policy and baseline consists of the 4 previous frames, corresponding to the frame skip of 4. The discount factor was set to $\gamma = 0 . 9 9 5$ . All inputs are rescaled to $[ - 1 , 1 ]$ γ .element-wise. All experiments used 5 different training seeds, except the ,experiments with the learned hash code, which uses 3 different training seeds. Batch normalization (Ioffe & Szegedy, 2015) is used at each policy and baseline layer. TRPO-pixel-SimHash uses binary codes of size $k = 2 5 6$ ; BASS (TRPO-BASS-SimHash) extracts features using cell size $C = 2 0$ and $B = 2 0$ bins. The autoencoder for the learned embedding (TRPO-AE-SimHash) uses a binary hidden layer of 512 bit, which are projected to 64 bit.
+
+RAM states in Atari 2600 games are integer-valued vectors over length 128 in the range [0 255]. ,Experiments on Montezuma’s Revenge with RAM observations use a policy consisting of 2 hidden layers, each of size 32. RAM states are rescaled to a range $[ - 1 , 1 ]$ . Unlike images, only the current ,RAM is shown to the agent. Experiment results are averaged over 10 random seeds.
+
+In addition, we apply counting Bloom filters (Fan et al., 2000) to maintain a small hash table. Details can be found in Appendix A.5.
+
+The autoencoder used for the learned hash code has a 512 bit binary code layer, using sigmoid units, to which uniform noise $U ( - a , a )$ with $a = 0 . 3$ is added. The loss function Eq. (3), using $\lambda = 1 0$ , is updated every $j _ { \mathrm { u p d a t e } } = 3$ , . λiterations. The architecture looks as follows: an input layer of size $5 2 \times 5 2$ , representing the image luminance is followed by 3 consecutive $6 \times 6$ convolutional layers with stride 2 and 96 filters feed into a fully connected layer of size 1024, which connects to the binary code layer. This binary code layer feeds into a fully-connected layer of 1024 units, connecting to a fully-connected layer of 2400 units. This layer feeds into 3 consecutive $6 \times 6$ transposed convolutional layers of which the final one connects to a pixel-wise softmax layer with 64 bins, representing the pixel intensities. Moreover, label smoothing is applied to the different softmax bins, in which the log-probability of each of the bins is increased by 0 003, before normalizing. The softmax weights .are shared among each pixel. All output nonlinearities are ReLUs; Adam (Kingma & Ba, 2015) is used as an optimization scheme; batch normalization (Ioffe & Szegedy, 2015) is applied to each layer. The architecture was shown in Figure 1 of Section 2.3.
+
+# A.2 Description of the Adapted rllab Tasks
+
+This section describes the continuous control environments used in the experiments. The tasks are implemented as described in Duan et al. (2016), following the sparse reward adaptation of Houthooft et al. (2016). The tasks have the following state and action dimensions: CartPoleSwingup, $S \subseteq \mathbb { R } ^ { 4 }$ , $\mathcal { A } \subseteq \mathbb { R } ^ { 1 }$ ; MountainCar $s \subseteq \mathbb { R } ^ { 3 }$ , $\mathcal { A } \subseteq \mathbf { \overline { { \mathbb { R } } } } ^ { 1 }$ ; HalfCheetah, $\boldsymbol { s } \subseteq \mathbb { R } ^ { 2 0 }$ , $\mathcal { A } \subseteq \mathbb { R } ^ { 6 }$ ; SwimmerGather, $\boldsymbol { S } \subseteq \mathbb { R } ^ { 3 3 }$ , $\mathcal { A } \subseteq \mathbb { R } ^ { 2 }$ . For the sparse reward experiments, the tasks have been modified as follows. In CartPoleSwingup, the agent receives a reward of $+ 1$ when $\cos ( \beta ) > 0 . 8$ , with $\beta$ the pole angle. In MountainCar, the agent receives a reward of $+ 1$ β > . βwhen the goal state is reached, namely escaping the valley from the right side. Therefore, the agent has to figure out how to swing up the pole in the absence of any initial external rewards. In HalfCheetah, the agent receives a reward of $+ 1$ when $x _ { \mathrm { b o d y } } > 5$ . As such, it has to figure out how to move forward without any initial external reward. The >time horizon is set to $T = 5 0 0$ for all tasks.
+
+# A.3 Examples of Atari 2600 RAM Entries
+
+Table 5 lists the semantic interpretation of certain RAM entries in Montezuma’s Revenge. SmartHash, as described in Section 3.4, makes use of RAM indices 3, 42, 43, 27, and 67. “Beam walls” are deadly barriers that occur periodically in some rooms.
+
+Table 5: Interpretation of particular RAM entries in Montezuma’s Revenge   
+
+<table><tr><td>RAM index</td><td>Group</td><td>Meaning</td></tr><tr><td>3</td><td>room</td><td>room number</td></tr><tr><td>42</td><td>agent</td><td>x coordinate</td></tr><tr><td>43</td><td>agent</td><td>y coordinate</td></tr><tr><td>52</td><td>agent</td><td>orientation (left/right)</td></tr><tr><td>27</td><td>beam walls</td><td>on/off</td></tr><tr><td>83</td><td>beam walls</td><td>beam wall countdown (on: O,off: 36 → 0)</td></tr><tr><td>0</td><td>counter</td><td>counts from O to 255 and repeats</td></tr><tr><td>55</td><td>counter</td><td>death scene countdown</td></tr><tr><td>67</td><td>objects</td><td>existence of objects (doors,skull and key) in the 1st room</td></tr><tr><td>47</td><td>skull</td><td>x coordinate (both 1st and 2nd rooms)</td></tr></table>
+
+# A.4 Analysis of Learned Binary Representation
+
+Figure 6 shows the downsampled codes learned by the autoencoder for several Atari 2600 games (Frostbite, Freeway, and Montezuma’s Revenge). Each row depicts 50 consecutive frames (from 0 to 49, going from left to right, top to bottom). The pictures in the right column depict the binary codes that correspond with each of these frames (one frame per row). Figure 7 shows the reconstructions of several subsequent images according to the autoencoder.
+
+![](images/211bf74321124f76d9aeedcd9061eebfd5f44286aaae4dd4b4fda17411c089b8.jpg)  
+Figure 6: Frostbite, Freeway, and Montezuma’s Revenge: subsequent frames (left) and corresponding code (right); the frames are ordered from left (starting with frame number 0) to right, top to bottom; the vertical axis in the right images correspond to the frame number.
+
+![](images/b12b2c9fed2ee4b18399bef400e2ba7a6e24230656b1816faf85b7f8ee3f8f88.jpg)  
+Figure 7: Freeway: subsequent frames and corresponding code (top); the frames are ordered from left (starting with frame number 0) to right, top to bottom; the vertical axis in the right images correspond to the frame number. Within each image, the left picture is the input frame, the middle picture the reconstruction, and the right picture, the reconstruction error.
+
+# A.5 Counting Bloom Filter/Count-Min Sketch
+
+We experimented with directly building a hashing dictionary with keys $\phi ( s )$ and values the state φcounts, but observed an unnecessary increase in computation time. Our implementation converts the integer hash codes into binary numbers and then into the “bytes” type in Python. The hash table is a dictionary using those bytes as keys.
+
+However, an alternative technique called Count-Min Sketch (Cormode & Muthukrishnan, 2005), with a data structure identical to counting Bloom filters (Fan et al., 2000), can count with a fixed integer array and thus reduce computation time. Specifically, let $p ^ { 1 } , \ldots , p ^ { l }$ be distinct large prime numbers and define $\phi ^ { j } ( s ) = \phi ( s ) \ \mathrm { m o d } p ^ { j }$ . The count of state $s$ is returned as $\mathrm { m i n } _ { 1 \le j \le l } n ^ { j } \left( \bar { \phi ^ { j } } ( \bar { s } ) \right)$ . To increase the count of $s$ , we increment $n ^ { j } \left( \phi ^ { j } ( s ) \right)$ by 1 for all $j$ . Intuitively, the method replaces $\phi$ by weaker hash functions, while it reduces the probability of over-counting by reporting counts agreed by all such weaker hash functions. The final hash code is represented as $\left( \phi ^ { 1 } ( s ) , . . . , \phi ^ { l } ( s ) \right)$ .
+
+Throughout all experiments above, the prime numbers for the counting Bloom filter are 999931, 999953, 999959, 999961, 999979, and 999983, which we abbreviate as $\mathbf { \ddot { \theta } M ^ { \prime \prime } }$ . In addition, we experimented with 6 other prime numbers, each approximately $1 5 \mathbf { M }$ , which we abbreviate as $" 9 0 1 \vec { \bf M } "$ . As we can see in Figure 8, counting states with a dictionary or with Bloom filters lead to similar performance, but the computation time of latter is lower. Moreover, there is little difference between direct counting and using a very larger table for Bloom filters, as the average bonus rewards are almost the same, indicating the same degree of exploration-exploitation trade-off. On the other hand, Bloom filters require a fixed table size, which may not be known beforehand.
+
+![](images/21758b2fa131e1fa7d95610d3c88ea9f86077b67c5f1fe8d3c4ecb1a19a973fb.jpg)  
+Figure 8: Statistics of TRPO-pixel-SimHash $k = 2 5 6$ on Frostbite. Solid lines are the mean, while the shaded areas represent the one standard deviation. Results are derived from 10 random seeds. Direct counting with a dictionary uses 2.7 times more computations than counting Bloom filters (6 M or $9 0 \mathbf { M }$ ).
+
+Theory of Bloom Filters Bloom filters (Bloom, 1970) are popular for determining whether a data sample $s ^ { \prime }$ belongs to a dataset $\mathcal { D }$ . Suppose we have $l$ functions $\phi ^ { j }$ that independently assign each data sample to an integer between 1 and $p$ φuniformly at random. Initially $1 , 2 , \ldots , p$ are marked as 0. Then every $s \in \mathcal { D }$ is “inserted” through marking $\phi ^ { j } { \dot { ( s ) } }$ as 1 for all $j$ , , . . . ,. A new sample $s ^ { \prime }$ is reported as a member of $\mathcal { D }$ only if $\phi ^ { j } ( s )$ φare marked as 1 for all $j$ . A bloom filter has zero false negative rate (any $s \in \mathcal { D }$ φis reported a member), while the false positive rate (probability of reporting a nonmember as a member) decays exponentially in $l$ .
+
+Though Bloom filters support data insertion, it does not allow data deletion. Counting Bloom filters (Fan et al., 2000) maintain a counter $n ( \cdot )$ for each number between 1 and $p$ . Inserting/deleting $s$ corresponds to incrementing/decrementing $n { \Big ( } \phi ^ { j } ( s ) { \Big ) }$ by 1 for all $j$ . Similarly, $s$ is considered a member if $\forall j : n \Big ( \phi ^ { j } ( s ) \Big ) = 0$ .
+
+Count-Min sketch is designed to support memory-efficient counting without introducing too many over-counts. It maintains a separate count $n ^ { j }$ for each hash function $\phi ^ { j }$ defined as $\phi ^ { j } \bar { ( s ) } = \phi ( \bar { s ) }$ mod $p ^ { j }$ , where $p ^ { j }$ φis a large prime number. For simplicity, we may assume that $p ^ { j } \approx p \forall j$ φand $\phi ^ { j }$ assigns $s$ to any of $1 , \ldots , p$ with uniform probability.
+
+We now derive the probability of over-counting. Let $s$ be a fixed data sample (not necessarily inserted yet) and suppose a dataset $\mathcal { D }$ of $N$ samples are inserted. We assume that $p ^ { l } \gg N$ . Let $n : = \mathrm { m i n } _ { 1 \leq j \leq l } n ^ { j } \left( \phi ^ { j } ( s ) \right)$ be the count returned by the Bloom filter. We are interested in computing $\mathrm { P r o b } ( n > 0 | s \notin \mathcal { D } )$ . Due to assumptions about $\phi ^ { j }$ , we know $n ^ { j } ( \phi ( s ) ) \sim \mathrm { B i n o m i a l } \left( N , { \frac { 1 } { p } } \right)$ . Therefore,
+
+$$
+\begin{array} { r l } { \mathrm { P r o b } ( n > 0 | s \mathcal { G } \mathcal { D } ) = } & { \frac { \mathrm { P r o b } ( n > 0 , s \varphi \mathcal { D } ) } { \mathrm { P r o b } ( s \varphi \mathcal { D } ) } } \\ & { = \frac { \mathrm { P r o b } ( n > 0 ) - \mathrm { P r o b } ( s \varphi \mathcal { D } ) } { \mathrm { P r o b } ( s \varphi \mathcal { D } ) } } \\ & { \approx \frac { \mathrm { P r o b } ( n > 0 ) } { \mathrm { P r o b } ( s \varphi \mathcal { D } ) } } \\ & { = \frac { \mathrm { P r o b } ( n > 0 ) } { \mathrm { P r o b } ( s \varphi \mathcal { D } ) } } \\ & { = \frac { ( 1 - 1 ) \cdot ( 1 \rho \mathcal { P } ) ^ { N } ( 1 \circ 1 ) \cdot ( \rho \mathcal { P } ) } { ( 1 - 1 ) \cdot ( 1 \rho \mathcal { P } ) ^ { N } } } \\ & { = \frac { ( 1 - 1 ) \cdot ( 1 \rho \mathcal { P } ) ^ { N } } { ( 1 - 1 ) \cdot ( 1 \rho \mathcal { P } ) ^ { N } } } \\ & { \approx \frac { ( 1 - e ^ { - N \varphi \mathcal { P } } ) } { e ^ { - N \varphi \mathcal { P } } } } \\ & { \approx ( 1 - e ^ { - N \varphi \mathcal { P } } ) . } \end{array}
+$$
+
+In particular, the probability of over-counting decays exponentially in $l$ . We refer the readers to (Cormode & Muthukrishnan, 2005) for other properties of the Count-Min sketch.
+
+# A.6 Robustness Analysis
+
+Apart from the experimental results shown in Table 1 and Table 3, additional experiments have been performed to study several properties of our algorithm.
+
+Hyperparameter sensitivity To study the performance sensitivity to hyperparameter changes, we focus on evaluating TRPO-RAM-SimHash on the Atari 2600 game Frostbite, where the method has a clear advantage over the baseline. Because the final scores can vary between different random seeds, we evaluated each set of hyperparameters with 30 seeds. To reduce computation time and cost, RAM states are used instead of image observations.
+
+Table 6: TRPO-RAM-SimHash performance robustness to hyperparameter changes on Frostbite   
+
+<table><tr><td rowspan="2"></td><td colspan="8">阝</td></tr><tr><td>k 0</td><td>0.01</td><td>0.05</td><td>0.1</td><td>0.2</td><td>0.4</td><td>0.8</td><td>1.6</td></tr><tr><td>1</td><td>397</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>64</td><td>1</td><td>879</td><td>2464</td><td>2243</td><td>2489</td><td>1587</td><td>1107</td><td>441</td></tr><tr><td>128</td><td>1</td><td>1475</td><td>4248</td><td>2801</td><td>3239</td><td>3621</td><td>1543</td><td>395</td></tr><tr><td>256</td><td></td><td>2583</td><td>4497</td><td>4437</td><td>7849</td><td>3516</td><td>2260</td><td>374</td></tr></table>
+
+The results are summarized in Table 6. Herein, $k$ refers to the length of the binary code for hashing while $\beta$ is the multiplicative coefficient for the reward bonus, as defined in Section 2.2. This βtable demonstrates that most hyperparameter settings outperform the baseline $\mathcal { B } = 0 ,$ ) significantly. βMoreover, the final scores show a clear pattern in response to changing hyperparameters. Small $\beta$ -values lead to insufficient exploration, while large $\beta$ -values cause the bonus rewards to overwhelm βthe true rewards. With a fixed $k$ β, the scores are roughly concave in $\beta$ , peaking at around 0 2. Higher granularity $k$ β .leads to better performance. Therefore, it can be concluded that the proposed exploration method is robust to hyperparameter changes in comparison to the baseline, and that the best parameter settings can obtained from a relatively coarse-grained grid search.
+
+State and state-action counting Continuing the results in Table 6, the performance of state-action counting is studied using the same experimental setup, summarized in Table 7. In particular, a bonus reward $\begin{array} { r } { r ^ { + } = \frac { \beta } { \sqrt { n ( s , a ) } } } \end{array}$ instead of $\begin{array} { r } { \bar { r } ^ { + } = \frac { \beta } { \sqrt { n ( s ) } } } \end{array}$ is assigned. These results show that the relative ,performance of state counting compared to state-action counting depends highly on the selected hyperparameter settings. However, we notice that the best performance is achieved using state counting with $k = 2 5 6$ and $\beta = 0 . 2$ .
+
+Table 7: Performance comparison between state counting (left of the slash) and state-action counting (right of the slash) using TRPO-RAM-SimHash on Frostbite   
+
+<table><tr><td rowspan="2"></td><td colspan="8">β</td></tr><tr><td>0.01</td><td>0.05</td><td>0.1</td><td>0.2</td><td></td><td>0.4</td><td>0.8</td><td>1.6</td></tr><tr><td>64</td><td>879/976</td><td>2464/1491</td><td>2243/3954</td><td>2489 /5523</td><td>1587 /5985</td><td>1107/2052</td><td></td><td>441/742</td></tr><tr><td>128</td><td>1475/808</td><td>4248/4302</td><td>2801/4802</td><td>3239 /7291</td><td></td><td>3621/4243</td><td>1543/1941</td><td>395/362</td></tr><tr><td>256</td><td>2583 /1584</td><td>4497 /5402</td><td>4437 /5431</td><td>7849 /4872</td><td>3516/3175</td><td></td><td>2260/1238</td><td>374/96</td></tr></table>

parse/train/SyOvg6jxx/SyOvg6jxx_content_list.json

@@ -0,0 +1,1875 @@
+[
+    {
+        "type": "text",
+        "text": "#Exploration: A Study of Count-Based Exploration for Deep Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            642,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Haoran $\\mathbf { T a n g ^ { 1 * } }$ , Rein Houthooft3,4∗, Davis Foote2, Adam Stooke2, Xi Chen2,4, Yan Duan2 4, John Schulman4, Filip De Turck3, Pieter Abbeel 2 4 ",
+        "bbox": [
+            183,
+            193,
+            720,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 UC Berkeley, Department of Mathematics   \n2 UC Berkeley, Department of Electrical Engineering and Computer Sciences   \n3 Ghent University – imec, Department of Information Technology   \n4 OpenAI ",
+        "bbox": [
+            184,
+            226,
+            692,
+            284
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            459,
+            320,
+            539,
+            335
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Count-based exploration algorithms are known to perform near-optimally when used in conjunction with tabular reinforcement learning (RL) methods for solving small discrete Markov decision processes (MDPs). It is generally thought that count-based methods cannot be applied in high-dimensional state spaces, since most states will only occur once. Recent deep RL exploration strategies are able to deal with high-dimensional continuous state spaces through complex heuristics, often relying on optimism in the face of uncertainty or intrinsic motivation. In this work, we describe a surprising finding: a simple generalization of the classic count-based approach can reach near state-of-the-art performance on various highdimensional and/or continuous deep RL benchmarks. States are mapped to hash codes, which allows to count their occurrences with a hash table. These counts are then used to compute a reward bonus according to the classic count-based exploration theory. We find that simple hash functions can achieve surprisingly good results on many challenging tasks. Furthermore, we show that a domain-dependent learned hash code may further improve these results. Detailed analysis reveals important aspects of a good hash function: 1) having appropriate granularity and 2) encoding information relevant to solving the MDP. This exploration strategy achieves near state-of-the-art performance on both continuous control tasks and Atari 2600 games, hence providing a simple yet powerful baseline for solving MDPs that require considerable exploration. ",
+        "bbox": [
+            233,
+            352,
+            766,
+            628
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            320,
+            671
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning (RL) studies an agent acting in an initially unknown environment, learning through trial and error to maximize rewards. It is impossible for the agent to act near-optimally until it has sufficiently explored the environment and identified all of the opportunities for high reward, in all scenarios. A core challenge in RL is how to balance exploration—actively seeking out novel states and actions that might yield high rewards and lead to long-term gains; and exploitation—maximizing short-term rewards using the agent’s current knowledge. While there are exploration techniques for finite MDPs that enjoy theoretical guarantees, there are no fully satisfying techniques for highdimensional state spaces; therefore, developing more general and robust exploration techniques is an active area of research. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            810
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most of the recent state-of-the-art RL results have been obtained using simple exploration strategies such as uniform sampling (Mnih et al., 2015) and i.i.d./correlated Gaussian noise (Schulman et al., 2015; Lillicrap et al., 2015). Although these heuristics are sufficient in tasks with well-shaped rewards, the sample complexity can grow exponentially (with state space size) in tasks with sparse rewards (Osband et al., 2016b). Recently developed exploration strategies for deep RL have led to significantly improved performance on environments with sparse rewards. Bootstrapped DQN (Osband et al., 2016a) led to faster learning in a range of Atari 2600 games by training an ensemble of Q-functions. Intrinsic motivation methods using pseudo-counts achieve state-of-the-art performance on Montezuma’s Revenge, an extremely challenging Atari 2600 game (Bellemare et al., 2016). Variational Information Maximizing Exploration (VIME, Houthooft et al. (2016)) encourages the agent to explore by acquiring information about environment dynamics, and performs well on various robotic locomotion problems with sparse rewards. However, we have not seen a very simple and fast method that can work across different domains. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Some of the classic, theoretically-justified exploration methods are based on counting state-action visitations, and turning this count into a bonus reward. In the bandit setting, the well-known UCB algorithm of Lai & Robbins (1985) chooses the action $a _ { t }$ at time $t$ that maximizes $\\begin{array} { r } { \\hat { r } ( a _ { t } ) + \\sqrt { \\frac { 2 \\log t } { n ( a _ { t } ) } } } \\end{array}$ where $\\hat { r } ( a _ { t } )$ is the estimated reward, and $n ( a _ { t } )$ is the number of times action $a _ { t }$ was previously chosen. In the MDP setting, some of the algorithms have similar structure, for example, Model Based Interval Estimation–Exploration Bonus (MBIE-EB) of Strehl & Littman (2008) counts state-action pairs with a table $n ( s , a )$ and adding a bonus reward of the form $\\frac { \\beta } { \\sqrt { n ( s , a ) } }$ to encourage exploring less visited pairs. Kolter & $\\mathrm { N g }$ , (2009) show that the inverse-square-root dependence is optimal. MBIE and related algorithms assume that the augmented MDP is solved analytically at each timestep, which is only practical for small finite state spaces. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            363
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper presents a simple approach for exploration, which extends classic counting-based methods to high-dimensional, continuous state spaces. We discretize the state space with a hash function and apply a bonus based on the state-visitation count. The hash function can be chosen to appropriately balance generalization across states, and distinguishing between states. We select problems from rllab (Duan et al., 2016) and Atari 2600 (Bellemare et al., 2012) featuring sparse rewards, and demonstrate near state-of-the-art performance on several games known to be hard for naïve exploration strategies. The main strength of the presented approach is that it is fast, flexible and complementary to most existing RL algorithms. ",
+        "bbox": [
+            173,
+            369,
+            825,
+            481
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, this paper proposes a generalization of classic count-based exploration to high-dimensional spaces through hashing (Section 2); demonstrates its effectiveness on challenging deep RL benchmark problems and analyzes key components of well-designed hash functions (Section 3). ",
+        "bbox": [
+            174,
+            488,
+            825,
+            530
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            554,
+            325,
+            570
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Notation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            279,
+            602
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper assumes a finite-horizon discounted Markov decision process (MDP), defined by $( S , \\mathcal { A } , \\mathcal { P } , r , \\rho _ { 0 } , \\gamma , T )$ , in which $s$ is the state space, $\\mathcal { A }$ the action space, $\\mathcal { P }$ a transition proba, , , , ρ , γ,bility distribution, $r : S \\times \\mathcal { A } \\to \\mathbb { R } _ { \\geq 0 }$ a reward function, $\\rho _ { 0 }$ an initial state distribution, $\\gamma \\in ( 0 , 1 ]$ a discount factor, and f $T$ ρ γ ,the horizon. The goal of RL is to maximize the total expected discountedg reward $\\begin{array} { r } { \\mathbb { E } _ { \\pi , \\mathcal { P } } \\left[ \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } r ( s _ { t } , a _ { t } ) \\right] } \\end{array}$ over a policy $\\pi$ , which outputs a distribution over actions given a state. ",
+        "bbox": [
+            173,
+            614,
+            826,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Count-Based Exploration via Static Hashing ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            709,
+            540,
+            724
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our approach discretizes the state space with a hash function $\\phi : S \\to \\mathbb { Z }$ . An exploration bonus is added to the reward function, defined as ",
+        "bbox": [
+            174,
+            736,
+            823,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/969ff4f41bc42e64d7e7df81476c276d4b73677eb0beaf26e9bfd88ec77d511d.jpg",
+        "text": "$$\nr ^ { + } ( s , a ) = \\frac { \\beta } { \\sqrt { n ( \\phi ( s ) ) } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            773,
+            570,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta \\in \\mathbb { R } _ { \\geq 0 }$ is the bonus coefficient. Initially the counts $n ( \\cdot )$ are set to zero for the whole range of $\\phi$ β. For every state $s _ { t }$ encountered at time step $t$ , $n ( \\phi ( s _ { t } ) )$ is increased by one. The agent is trained φwith rewards $( r + r ^ { + } )$ φ, while performance is evaluated as the sum of rewards without bonuses. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that our approach is a departure from count-based exploration methods such as MBIE-EB since we use a state-space count $n ( s )$ rather than a state-action count $n ( s , a )$ . State-action counts $n ( s , a )$ , ,are investigated in Appendix A.6, but no significant performance gains over state counting could be witnessed. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1 Define state preprocessor $g : S \\to { \\mathbb { R } ^ { K } }$   \n2 (In case of SimHash) Initialize $A \\in \\mathbb { R } ^ { k \\times K }$ with entries drawn i.i.d. from the standard Gaussian distribution $N ( 0 , 1 )$   \n,3 Initialize a hash table with values $n ( \\cdot ) \\equiv 0$   \n4 for each iteration $j$ do   \n5 Collect a set of state-action samples $\\{ ( s _ { m } , a _ { m } ) \\} _ { m = 0 } ^ { M }$ with policy $\\pi$   \n6 , πCompute hash codes through any LSH method, e.g., for SimHash, $\\phi ( s _ { m } ) = \\operatorname { s g n } ( A g ( s _ { m } ) )$   \n7 Update the hash table counts $\\forall m : 0 \\leq m \\leq M$ as $n ( \\phi ( s _ { m } ) )  n ( \\phi ( s _ { m } ) ) + 1$   \n8 Update the policy $\\pi$ using rewards $\\begin{array} { r } { \\bigg \\{ r ( s _ { m } , a _ { m } ) + \\frac { \\beta } { \\sqrt { n ( \\phi ( s _ { m } ) ) } } \\bigg \\} _ { m = 0 } ^ { M } } \\end{array}$ with any RL algorithm ",
+        "bbox": [
+            174,
+            125,
+            805,
+            282
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Clearly the performance of this method will strongly depend on the choice of hash function $\\phi$ . One φimportant choice we can make regards the granularity of the discretization: we would like for “distant” states to be be counted separately while “similar” states are merged. If desired, we can incorporate prior knowledge into the choice of $\\phi$ , if there would be a set of salient state features which are known to be relevant. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            385
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 summarizes our method. The main idea is to use locality-sensitive hashing (LSH) to convert continuous, high-dimensional data to discrete hash codes. LSH is a popular class of hash functions for querying nearest neighbors based on certain similarity metrics (Andoni $\\&$ Indyk, 2006). A computationally efficient type of LSH is SimHash (Charikar, 2002), which measures similarity by angular distance. SimHash retrieves a binary code of state $s \\in S$ as ",
+        "bbox": [
+            173,
+            392,
+            825,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e24538beb7e14461b1c813fc34c8411561b1eea02b8a9e97e2434ec31eaf5130.jpg",
+        "text": "$$\n\\phi ( s ) = \\operatorname { s g n } ( A g ( s ) ) \\in \\{ - 1 , 1 \\} ^ { k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            468,
+            599,
+            487
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $g : S  \\mathbb { R } ^ { d }$ is an optional preprocessing function and $A$ is a $k \\times d$ matrix with i.i.d. entries drawn from a standard Gaussian distribution $N ( 0 , 1 )$ . The value for $k$ controls the granularity: higher ,values lead to fewer collisions and are thus more likely to distinguish states. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 Count-Based Exploration via Learned Hashing ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            553,
+            557,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "When the MDP states have a complex structure, as is the case with image observations, measuring their similarity directly in pixel space fails to provide the semantic similarity measure one would desire. Previous work in computer vision (Lowe, 1999; Dalal & Triggs, 2005; Tola et al., 2010) introduce manually designed feature representations of images that are suitable for semantic tasks including detection and classification. More recent methods learn complex features directly from data by training convolutional neural networks (Krizhevsky et al., 2012; Simonyan & Zisserman, 2014; He et al., 2015). Considering these results, it may be difficult for SimHash to cluster states appropriately using only raw pixels. ",
+        "bbox": [
+            173,
+            578,
+            825,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb4582a662e173f79d27cec1b6c5fc7d7c3c6da61f9553210eb95cbf03c39201.jpg",
+        "image_caption": [
+            "Figure 1: The autoencoder (AE) architecture; the solid block represents the dense sigmoidal binary code layer, after which noise $U ( - a , a )$ is injected. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            704,
+            772,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we propose to use an autoencoder (AE) consisting of convolutional, dense, and transposed convolutional layers to learn meaningful hash codes in one of its hidden layers. This AE takes as input states $s$ and contains one special dense layer comprised of $K$ saturating activation functions, ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1 Define state preprocessor $g : S \\to { \\mathbb { B } } ^ { K }$ as the binary code resulting from the autoencoder (AE)   \n2 Initialize $A \\in \\mathbb { R } ^ { k \\times K }$ with entries drawn i.i.d. from the standard Gaussian distribution $N ( 0 , 1 )$   \n3 Initialize a hash table with values $n ( \\cdot ) \\equiv 0$   \n4 for each iteration $j$ do   \n5 Collect a set of state-action samples $\\{ ( s _ { m } , a _ { m } ) \\} _ { m = 0 } ^ { M }$ with policy $\\pi$   \n6 Add the state samples $\\{ s _ { m } \\} _ { m = 0 } ^ { M }$ , to a FIFO replay pool $\\mathcal { R }$   \n7 if $j$ mod $j _ { \\mathrm { u p d a t e } } = 0$ then   \n8 Update the AE loss function in Eq. (3) using samples drawn from the replay pool   \n$\\{ s _ { n } \\} _ { n = 1 } ^ { N } \\sim \\mathcal { R }$ , for example using stochastic gradient descent   \n9 Compute $g ( s _ { m } ) = \\lfloor b ( s _ { m } ) \\rceil$ , the $K$ -dim rounded hash code for $s _ { m }$ learned by the AE   \n10 Project $g ( s _ { m } )$ to a lower dimension $k$ via SimHash as $\\phi ( s _ { m } ) = \\operatorname { s g n } ( A g ( s _ { m } ) )$   \n11 Update the hash table counts $\\forall m : 0 \\leq m \\leq M$ as $n ( \\phi ( s _ { m } ) )  n ( \\phi ( s _ { m } ) ) + 1$   \n12 Update the policy $\\pi$ using rewards $\\begin{array} { r } { \\bigg \\{ r ( s _ { m } , a _ { m } ) + \\frac { \\beta } { \\sqrt { n ( \\phi ( s _ { m } ) ) } } \\bigg \\} _ { m = } ^ { M } } \\end{array}$ with any RL algorithm ",
+        "bbox": [
+            173,
+            125,
+            810,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "more specifically sigmoid functions. By rounding the sigmoid output $b ( s )$ of this layer to the closest binary number, any state $s$ can be binarized. ",
+        "bbox": [
+            174,
+            378,
+            823,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since gradients cannot be back-propagated through a rounding function, an alternative method must be used to ensure that distinct states are mapped to distinct binary codes. Therefore, uniform noise $U ( - a , a )$ is added to the sigmoid output. By choosing uniform noise with a sufficiently high variance, ,the AE is only capable of reconstructing distinct inputs $s$ if its hidden dense layer outputs values $b ( s )$ that are sufficiently far apart from each other (Gregor et al., 2016). Feeding a state $s$ to the AE input, extracting $b ( s )$ and rounding it to $\\lfloor b ( s ) \\rceil$ yields a learned binary code. As such, the loss function $L ( \\cdot )$ over a set of collected states $\\{ s _ { i } \\} _ { i = 1 } ^ { N }$ is defined as ",
+        "bbox": [
+            173,
+            415,
+            825,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4673c8bef310e742594a7b7f61643912df0fdb53e1dbfbe1d74565f621707c3.jpg",
+        "text": "$$\nL \\left( \\{ s _ { n } \\} _ { n = 1 } ^ { N } \\right) = - \\frac { 1 } { N } \\sum _ { n = 1 } ^ { N } \\left[ \\log p ( s _ { n } ) - \\frac { \\lambda } { K } \\sum _ { i = 1 } ^ { K } \\operatorname* { m i n } \\left\\{ \\left( 1 - b _ { i } ( s _ { n } ) \\right) ^ { 2 } , b _ { i } ( s _ { n } ) ^ { 2 } \\right\\} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            518,
+            741,
+            561
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This objective function consists of a cross-entropy term and a term that pressures the binary code layer to take on binary values, scaled by $\\lambda \\in \\mathbb { R } _ { \\ge 0 }$ . The reasoning behind this is that uniform noise $U ( - a , a )$ λ ,alone is insufficient, in case the AE does not use a particular sigmoid unit. This term ensures that an unused binary code output is assigned an arbitrary binary value. When omitting this term, the code is more prone to oscillations, causing unwanted bit flips, and destabilizing the counting process. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to make the AE train sufficiently fast—which is required since it is updated during the agent’s training—we make use of a pixel-wise softmax output layer (van den Oord et al., 2016) that shares weights between all pixels. The different softmax outputs merge together pixel intensities into discrete bins. The architectural details are described in Appendix A.1 and are depicted in Figure 1. Because the code dimension often needs to be large in order to correctly reconstruct the input, we apply a downsampling procedure to the resulting binary code $\\lfloor b ( s ) \\rceil$ , which can be done through random projection to a lower-dimensional space via SimHash as in Eq. (2). ",
+        "bbox": [
+            173,
+            642,
+            825,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One the one hand, it is important that the mapping from state to code needs to remain relatively consistent over time, which is nontrivial as the AE is constantly updated according to the latest data (Algorithm 2 line 8). An obvious solution would be to significantly downsample the binary code to a very low dimension, or by slowing down the training process. But on the other hand, the code has to remain relatively unique for states that are both distinct and close together on the image manifold. This is tackled both by the second term in Eq. (3) and by the saturating behavior of the sigmoid units. As such, states that are already well represented in the AE hidden layers tend to saturate the sigmoid units, causing the resulting loss gradients to be close to zero and making the code less prone to change. ",
+        "bbox": [
+            173,
+            746,
+            826,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            877,
+            312,
+            893
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Experiments were designed to investigate and answer the following research questions: ",
+        "bbox": [
+            174,
+            909,
+            740,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Can count-based exploration through hashing improve performance significantly across different domains? How does the proposed method compare to the current state of the art in exploration for deep RL?   \n2. What is the impact of learned or static state preprocessing on the overall performance when image observations are used?   \n3. What factors contribute to good performance, e.g., what is the appropriate level of granularity of the hash function? ",
+        "bbox": [
+            205,
+            103,
+            825,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To answer question 1, we run the proposed method on deep RL benchmarks (rllab and ALE) that feature sparse rewards, and compare it to other state-of-the-art algorithms. Question 2 is answered by trying out different image preprocessors on Atari 2600 games. Finally, we investigate question 3 in Section 3.3 and 3.4. Trust Region Policy Optimization (TRPO, Schulman et al. (2015)) is chosen as the RL algorithm for all experiments, because it can handle both discrete and continuous action spaces, it can conveniently ensure stable improvement in the policy performance, and is relatively insensitive to hyperparameter changes. The hyperparameters settings are reported in Appendix A.1. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Continuous Control ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            338,
+            361,
+            352
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The rllab benchmark (Duan et al., 2016) consists of various control tasks to test deep RL algorithms. We selected several variants of the basic and locomotion tasks that use sparse rewards, as shown in Figure 2, and adopt the experimental setup as defined in (Houthooft et al., 2016)—a description can be found in Appendix A.2. These tasks are all highly difficult to solve with naïve exploration strategies, such as adding Gaussian noise to the actions. ",
+        "bbox": [
+            174,
+            364,
+            823,
+            434
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b361a9b8e95718220308863d606ae375328e7733c70f739e9726b183648949f3.jpg",
+        "image_caption": [
+            "Figure 2: Illustrations of the rllab tasks used in the continuous control experiments, namely MountainCar, CartPoleSwingup, SimmerGather, and HalfCheetah; taken from (Duan et al., 2016). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            282,
+            446,
+            715,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3bddef7257aca125ef3ed901547493485ea605e4b0e6a4992fb9a784035e4180.jpg",
+        "image_caption": [
+            "Figure 3: Mean average return of different algorithms on rllab tasks with sparse rewards; the solid line represents the mean average return, while the shaded area represents one standard deviation, over 5 seeds for the baseline and SimHash. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            587,
+            815,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the results of TRPO (baseline), TRPO-SimHash, and VIME (Houthooft et al., 2016) on the classic tasks MountainCar and CartPoleSwingup, the locomotion task HalfCheetah, and the hierarchical task SwimmerGather. Using count-based exploration with hashing is capable of reaching the goal in all environments (which corresponds to a nonzero return), while baseline TRPO with Gaussian control noise fails completely. Although TRPO-SimHash picks up the sparse reward on HalfCheetah, it does not perform as well as VIME. In contrast, the performance of SimHash is comparable with VIME on MountainCar, while it outperforms VIME on SwimmerGather. ",
+        "bbox": [
+            173,
+            753,
+            825,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Arcade Learning Environment ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            434,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Arcade Learning Environment (ALE, Bellemare et al. (2012)), which consists of Atari 2600 video games, is an important benchmark for deep RL due to its high-dimensional state space and wide variety of games. In order to demonstrate the effectiveness of the proposed exploration strategy, six games are selected featuring long horizons while requiring significant exploration: Freeway, Frostbite, Gravitar, Montezuma’s Revenge, Solaris, and Venture. The agent is trained for 500 iterations in all experiments, with each iteration consisting of $0 . 1 { \\bf M }$ steps (the TRPO batch size, corresponds to $0 . 4 { \\bf M }$ . .frames). Policies and value functions are neural networks with identical architectures to (Mnih et al., 2016). Although the policy and baseline take into account the previous four frames, the counting algorithm only looks at the latest frame. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "BASS To compare with the autoencoder-based learned hash code, we propose using Basic Abstraction of the ScreenShots (BASS, also called Basic; see Bellemare et al. (2012)) as a static preprocessing function g. BASS is a hand-designed feature transformation for images in Atari 2600 games. BASS builds on the following observations specific to Atari: 1) the game screen has a low resolution, 2) most objects are large and monochrome, and 3) winning depends mostly on knowing object locations and motions. We designed an adapted version of BASS1, that divides the RGB screen into square cells, computes the average intensity of each color channel inside a cell, and assigns the resulting values to bins that uniformly partition the intensity range [0 255]. Mathematically, let $C$ be the cell size (width and height), $B$ the number of bins, $( i , j )$ ,cell location, $( x , y )$ pixel location, and $z$ the channel. ",
+        "bbox": [
+            173,
+            219,
+            825,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4f62552e589e37f2cc04538adc0b1e308579cca023af0418ad6e38de98abef8c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { f e a t u r e } ( i , j , z ) = \\left\\lfloor { \\frac { B } { 2 5 5 C ^ { 2 } } } \\sum _ { ( x , y ) \\in \\mathrm { c e l l } ( i , j ) } I ( x , y , z ) \\right\\rfloor . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            358,
+            665,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Afterwards, the resulting integer-valued feature tensor is converted to an integer hash code $\\mathbf { \\nabla } _ { \\phi } ( s _ { t } )$ in φLine 6 of Algorithm 1). A BASS feature can be regarded as a miniature that efficiently encodes object locations, but remains invariant to negligible object motions. It is easy to implement and introduces little computation overhead. However, it is designed for generic Atari game images and may not capture the structure of each specific game very well. ",
+        "bbox": [
+            174,
+            387,
+            823,
+            458
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/116cdb30457fa112e70cfb60a9ea230fcc7c4ba658b51ad47c9973b4d83ba14b.jpg",
+        "table_caption": [
+            "Table 1: Atari 2600: average total reward after training for $5 0 \\mathrm { M }$ time steps. Boldface numbers indicate best results. Italic numbers are the best among our methods. "
+        ],
+        "table_footnote": [
+            "1 While Vezhnevets et al. (2016) reported best score 8108, their evaluation was based on top 5 agents trained with 500M time steps, hence not comparable. 2 Results reported only for $2 5 \\mathbf { M }$ time steps ( $1 0 0 \\mathbf { M }$ frames). "
+        ],
+        "table_body": "<table><tr><td></td><td>Freeway</td><td>Frostbite1</td><td>Gravitar</td><td>Montezuma</td><td>Solaris</td><td>Venture</td></tr><tr><td>TRPO (baseline)</td><td>16.5</td><td>2869</td><td>486</td><td>0</td><td>2758</td><td>121</td></tr><tr><td>TRPO-pixel-SimHash</td><td>31.6</td><td>4683</td><td>468</td><td>0</td><td>2897</td><td>263</td></tr><tr><td>TRPO-BASS-SimHash</td><td>28.4</td><td>3150</td><td>604</td><td>238</td><td>1201</td><td>616</td></tr><tr><td>TRPO-AE-SimHash</td><td>33.5</td><td>5214</td><td>482</td><td>75</td><td>4467</td><td>445</td></tr><tr><td>Double-DQN</td><td>33.3</td><td>1683</td><td>412</td><td>0</td><td>3068</td><td>98.0</td></tr><tr><td>Dueling network</td><td>0.0</td><td>4672</td><td>588</td><td>0</td><td>2251</td><td>497</td></tr><tr><td>Gorila</td><td>11.7</td><td>605</td><td>1054</td><td>4</td><td>N/A</td><td>1245</td></tr><tr><td>DQN Pop-Art</td><td>33.4</td><td>3469</td><td>483</td><td>0</td><td>4544</td><td>1172</td></tr><tr><td>A3C+</td><td>27.3</td><td>507</td><td>246</td><td>142</td><td>2175</td><td>0</td></tr><tr><td>pseudo-count²</td><td>29.2</td><td>1450</td><td>/</td><td>3439</td><td></td><td>369</td></tr></table>",
+        "bbox": [
+            171,
+            513,
+            812,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare our results to double DQN (van Hasselt et al., 2016b), dueling network (Wang et al., 2016), ${ \\bf A } 3 { \\bf C } +$ (Bellemare et al., 2016), double DQN with pseudo-counts (Bellemare et al., 2016), Gorila (Nair et al., 2015), and DQN Pop-Art (van Hasselt et al., 2016a) on the “null op” metric2. We show training curves in Figure 4 and summarize all results in Table 1. Surprisingly, TRPO-pixelSimHash already outperforms the baseline by a large margin and beats the previous best result on Frostbite. TRPO-BASS-SimHash achieves significant improvement over TRPO-pixel-SimHash on ",
+        "bbox": [
+            173,
+            786,
+            825,
+            871
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Montezuma’s Revenge and Venture, where it captures object locations better than other methods.3   \nTRPO-AE-SimHash achieves near state-of-the-art performance on Freeway, Frostbite and Solaris.4 ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7b881fc3dab477957b5fae40811e112642ed0c282e638819df700bebd28f689a.jpg",
+        "image_caption": [
+            "Figure 4: Atari 2600 games: the solid line is the mean average undiscounted return per iteration, while the shaded areas represent the one standard deviation, over 5 seeds for the baseline, TRPOpixel-SimHash, and TRPO-BASS-SimHash, while over 3 seeds for TRPO-AE-SimHash. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            154,
+            813,
+            402
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As observed in Table 1, preprocessing images with BASS or using a learned hash code through the AE leads to much better performance on Gravitar, Montezuma’s Revenge and Venture. Therefore, an static or adaptive preprocessing step can be important for a good hash function. ",
+        "bbox": [
+            176,
+            478,
+            821,
+            520
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In conclusion, our count-based exploration method is able to achieve remarkable performance gains even with simple hash functions like SimHash on the raw pixel space. If coupled with domain-dependent state preprocessing techniques, it can sometimes achieve far better results. ",
+        "bbox": [
+            174,
+            526,
+            821,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 Granularity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            593,
+            305,
+            607
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "While our proposed method is able to achieve remarkable results without requiring much tuning, the granularity of the hash function should be chosen wisely. Granularity plays a critical role in count-based exploration, where the hash function should cluster states without under-generalizing or over-generalizing. Table 2 summarizes granularity parameters for our hash functions. In Table 3 we summarize the performance of TRPO-pixel-SimHash under different granularities. We choose Frostbite and Venture on which TRPO-pixel-SimHash outperforms the baseline, and choose as reward bonus coefficient $\\textstyle { \\beta = 0 . 0 1 \\times { \\frac { 2 5 6 } { k } } }$ to keep average bonus rewards at approximately the same scale. $k = 1 6$ β . only corresponds to 65536 distinct hash codes, which is insufficient to distinguish between semantically distinct states and hence leads to worse performance. We observed that $k = 5 1 2$ tends to capture trivial image details in Frostbite, leading the agent to believe that every state is new and equally worth exploring. Similar results are observed while tuning the granularity parameters for TRPO-BASS-SimHash and TRPO-AE-SimHash. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The best granularity depends on both the hash function and the MDP. While adjusting granularity parameter, we observed that it is important to lower the bonus coefficient as granularity is increased. This is because a higher granularity is likely to cause lower state counts, leading to higher bonus rewards that may overwhelm the true rewards. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            852
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/1bf2681ad69fdcfdf7266d034144508c4f5fe8a9da5ad0804f1b32d36fea2ebd.jpg",
+        "table_caption": [
+            "Table 2: Granularity parameters of various hash functions "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SimHash</td><td>k: size of the binary code</td></tr><tr><td>BASS</td><td>C: cell size;B: number of bins for each color channel</td></tr><tr><td>AE</td><td>k: down stream SimHash parameter; size of the binary code λ: binarization parameter</td></tr><tr><td></td><td>SmartHashs: grid size for the agent&#x27;s (x,y) coordinates</td></tr></table>",
+        "bbox": [
+            243,
+            127,
+            753,
+            227
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cc59975e359579284b9171978390eb1ce46c67c9a34724eb54cf13ec5ad7c24f.jpg",
+        "table_caption": [
+            "Table 3: Average score at $5 0 \\mathrm { M }$ time steps achieved by TRPO-pixel-SimHash "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>k</td><td>16</td><td>64</td><td>128</td><td>256</td><td>512</td></tr><tr><td>Frostbite</td><td>3326</td><td>4029</td><td>3932</td><td>4683</td><td>1117</td></tr><tr><td> Venture</td><td>0</td><td>218</td><td>142</td><td>263</td><td>306</td></tr></table>",
+        "bbox": [
+            173,
+            279,
+            477,
+            347
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5779cdf129debae3e227b8962f9d867748ec11da4b72182fcc3943bd3886e26.jpg",
+        "table_caption": [
+            "Table 4: Average score at $5 0 \\mathrm { M }$ time steps achieved by TRPO-SmartHash on Montezuma’s Revenge (RAM observations) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>S</td><td>1</td><td>5</td><td>10</td><td>20</td><td>40</td><td>60</td></tr><tr><td>score</td><td>2598</td><td>2500</td><td>3533</td><td>3025</td><td>2500</td><td>1921</td></tr></table>",
+        "bbox": [
+            509,
+            295,
+            820,
+            344
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4 A Case Study of Montezuma’s Revenge ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            495,
+            386
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Montezuma’s Revenge is widely known for its extremely sparse rewards and difficult exploration (Bellemare et al., 2016). While our method does not outperform Bellemare et al. (2016) on this game, we investigate the reasons behind this through various experiments. The experiment process below again demonstrates the importance of a hash function having the correct granularity and encoding relevant information for solving the MDP. ",
+        "bbox": [
+            174,
+            397,
+            826,
+            467
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our first attempt is to use game RAM states instead of image observations as inputs to the policy (details in Appendix A.1), which leads to a game score of 2500 with TRPO-BASS-SimHash. Our second attempt is to manually design a hash function that incorporates domain knowledge, called SmartHash, which uses an integer-valued vector consisting of the agent’s $( x , y )$ location, room number ,and other useful RAM information as the hash code (details in Appendix A.3). The best SmartHash agent is able to obtain a score of 3500. Still the performance is not optimal. We observe that a slight change in the agent’s coordinates does not always result in a semantically distinct state, and thus the hash code may remain unchanged. Therefore we choose grid size $s$ and replace the √ $x$ coordinate by $\\lfloor ( x - x _ { \\mathrm { m i n } } ) / s \\rfloor$ (similarly for $y$ ). The bonus coefficient is chosen as $\\beta = 0 . 0 \\bar { 1 } \\sqrt { s }$ to maintain the scale / β .relative to the true reward5 (see Table 4). Finally, the best agent is able to obtain 6600 total rewards after training for 1000 iterations ( $1 0 0 0 \\mathbf { M }$ time steps), with a grid size $s = 1 0$ . ",
+        "bbox": [
+            173,
+            473,
+            825,
+            627
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/be0d5543a0ab05f99beefa2981092d2dbb3a8aa035a340793a06231dfa7e6ede.jpg",
+        "image_caption": [
+            "Figure 5: SmartHash results on Montezuma’s Revenge (RAM observations): the solid line is the mean average undiscounted return per iteration, while the shaded areas represent the one standard deviation, over 5 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            643,
+            751,
+            789
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "During our pursuit, we had another interesting discovery that the ideal hash function should not simply cluster states by their visual similarity, but instead by their relevance to solving the MDP. We experimented with including enemy locations in the first two rooms into SmartHash $( s = 1 0$ ), and observed that average score dropped to 1672 (at iteration 1000). Though it is important for the agent to dodge enemies, the agent also erroneously “enjoys” watching enemy motions at distance (since new states are constantly observed) and “forgets” that his main objective is to enter other rooms. An alternative hash function keeps the same entry “enemy locations”, but instead only puts randomly sampled values in it, which surprisingly achieves better performance (3112). However, by ignoring enemy locations altogether, the agent achieves a much higher score (5661) (see Figure 5). In retrospect, we examine the hash codes generated by BASS-SimHash and find that codes clearly distinguish between visually different states (including various enemy locations), but fails to emphasize that the agent needs to explore different rooms. Again this example showcases the importance of encoding relevant information in designing hash functions. ",
+        "bbox": [
+            176,
+            861,
+            820,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            290,
+            328,
+            306
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Classic count-based methods such as MBIE (Strehl & Littman, 2005), MBIE-EB and (Kolter & Ng, 2009) solve an approximate Bellman equation as an inner loop before the agent takes an action (Strehl & Littman, 2008). As such, bonus rewards are propagated immediately throughout the state-action space. In contrast, contemporary deep RL algorithms propagate the bonus signal based on rollouts collected from interacting with environments, with value-based (Mnih et al., 2015) or policy gradient-based (Schulman et al., 2015; Mnih et al., 2016) methods, at limited speed. In addition, our proposed method is intended to work with contemporary deep RL algorithms, it differs from classical count-based method in that our method relies on visiting unseen states first, before the bonus reward can be assigned, making uninformed exploration strategies still a necessity at the beginning. Filling the gaps between our method and classic theories is an important direction of future research. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A related line of classical exploration methods is based on the idea of optimism in the face of uncertainty (Brafman & Tennenholtz, 2002) but not restricted to using counting to implement “optimism”, e.g. R-Max (Brafman & Tennenholtz, 2002), UCRL (Jaksch et al., 2010), and $\\mathrm { E } ^ { \\hat { 3 } }$ (Kearns & Singh, 2002). These methods, similar to MBIE and MBIE-EB, have theoretical guarantees in tabular settings. ",
+        "bbox": [
+            174,
+            476,
+            825,
+            531
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bayesian RL methods (Kolter & Ng, 2009; Guez et al., 2014; Sun et al., 2011; Ghavamzadeh et al., 2015), which keep track of a distribution over MDPs, are an alternative to optimism-based methods. Extensions to continuous state space have been proposed by Pazis & Parr (2013) and Osband et al. (2016b). ",
+        "bbox": [
+            174,
+            537,
+            825,
+            593
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another type of exploration is curiosity-based exploration. These methods try to capture the agent’s surprise about transition dynamics. As the agent tries to optimize for surprise, it naturally discovers novel states. We refer the reader to Schmidhuber (2010) and Oudeyer & Kaplan (2007) for an extensive review on curiosity and intrinsic rewards. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Several exploration strategies for deep RL have been proposed to handle high-dimensional state space recently. Houthooft et al. (2016) propose VIME, in which information gain is measured in Bayesian neural networks modeling the MDP dynamics, which is used an exploration bonus. Stadie et al. (2015) propose to use the prediction error of a learned dynamics model as an exploration bonus. Thompson sampling through bootstrapping is proposed by Osband et al. (2016a), using bootstrapped Q-functions. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The most related exploration strategy is proposed by Bellemare et al. (2016), in which an exploration bonus is added inversely proportional to the square root of a pseudo-count quantity. A state pseudocount is derived from its log-probability improvement according to a density model over the state space, which in the limit converges to the empirical count. Our method is similar to pseudo-count approach in the sense that both methods are performing approximate counting to have the necessary generalization over unseen states. The difference is that a density model has to be designed and learned to achieve good generalization for pseudo-count whereas in our case generalization is obtained by a wide range of simple hash functions (not necessarily SimHash). Another interesting connection is that our method also implies a density model $\\begin{array} { r } { \\rho ( s ) = \\frac { n ( \\phi ( s ) ) } { N } } \\end{array}$ over all visited states, where $N$ is the ρ total number of states visited. Another method similar to hashing is proposed by Abel et al. (2016), which clusters states and counts cluster centers instead of the true states, but this method has yet to be tested on standard exploration benchmark problems. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            313,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper demonstrates that a generalization of classical counting techniques through hashing is able to provide an appropriate signal for exploration, even in continuous and/or high-dimensional MDPs using function approximators, resulting in near state-of-the-art performance across benchmarks. It provides a simple yet powerful baseline for solving MDPs that require informed exploration. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            189
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            212,
+            334,
+            227
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank our colleagues at Berkeley and OpenAI for insightful discussions. This research was funded in part by ONR through a PECASE award. Yan Duan was also supported by a Berkeley AI Research lab Fellowship and a Huawei Fellowship. Xi Chen was also supported by a Berkeley AI Research lab Fellowship. We gratefully acknowledge the support of the NSF through grant IIS-1619362 and of the ARC through a Laureate Fellowship (FL110100281) and through the ARC Centre of Excellence for Mathematical and Statistical Frontiers. Adam Stooke gratefully acknowledges funding from a Fannie and John Hertz Foundation fellowship. Rein Houthooft is supported by a Ph.D. Fellowship of the Research Foundation - Flanders (FWO). ",
+        "bbox": [
+            174,
+            242,
+            825,
+            353
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            376,
+            272,
+            391
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Abel, Alekh Agarwal, Fernando Diaz, Akshay Krishnamurthy, and Robert E Schapire. Exploratory gradient boosting for reinforcement learning in complex domains. arXiv preprint arXiv:1603.04119, 2016. ",
+        "bbox": [
+            174,
+            400,
+            826,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexandr Andoni and Piotr Indyk. Near-optimal hashing algorithms for approximate nearest neighbor in high dimensions. In 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS), pp. 459–468, 2006. ",
+        "bbox": [
+            174,
+            452,
+            823,
+            493
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 2012. ",
+        "bbox": [
+            171,
+            503,
+            825,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            174,
+            542,
+            823,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Burton H. Bloom. Space/time trade-offs in hash coding with allowable errors. Communications of the ACM, 13(7):422–426, 1970. ",
+        "bbox": [
+            173,
+            594,
+            823,
+            625
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ronen I Brafman and Moshe Tennenholtz. R-max-a general polynomial time algorithm for near-optimal reinforcement learning. Journal of Machine Learning Research, 3:213–231, 2002. ",
+        "bbox": [
+            173,
+            635,
+            821,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Moses S Charikar. Similarity estimation techniques from rounding algorithms. In Proceedings of the thirty-fourth annual ACM symposium on Theory of computing, pp. 380–388, 2002. ",
+        "bbox": [
+            173,
+            672,
+            821,
+            703
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Graham Cormode and S Muthukrishnan. An improved data stream summary: the count-min sketch and its applications. Journal of Algorithms, 55(1):58–75, 2005. ",
+        "bbox": [
+            173,
+            712,
+            823,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Navneet Dalal and Bill Triggs. Histograms of oriented gradients for human detection. In 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’05), volume 1, pp. 886–893. IEEE, 2005. ",
+        "bbox": [
+            176,
+            751,
+            823,
+            794
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continous control. In International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Li Fan, Pei Cao, Jussara Almeida, and Andrei Z Broder. Summary cache: a scalable wide-area web cache sharing protocol. IEEE/ACM Transactions on Networking (TON), 8(3):281–293, 2000. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Ghavamzadeh, Shie Mannor, Joelle Pineau, and Aviv Tamar. Bayesian reinforcement learning: A survey. Foundations and Trends in Machine Learning, 8(5-6):359–483, 2015. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karol Gregor, Frederic Besse, Danilo Jimenez Rezende, Ivo Danihelka, and Daan Wierstra. Towards conceptual compression. arXiv preprint arXiv:1604.08772, 2016. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arthur Guez, Nicolas Heess, David Silver, and Peter Dayan. Bayes-adaptive simulation-based search with value function approximation. In Advances in Neural Information Processing Systems (NIPS), pp. 451–459, 2014. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. VIME: Variational information maximizing exploration. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            176,
+            229,
+            825,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning (ICML), pp. 448–456, 2015. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas Jaksch, Ronald Ortner, and Peter Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11:1563–1600, 2010. ",
+        "bbox": [
+            173,
+            334,
+            823,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Kearns and Satinder Singh. Near-optimal reinforcement learning in polynomial time. Machine Learning, 49(2-3):209–232, 2002. ",
+        "bbox": [
+            173,
+            371,
+            823,
+            401
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            439
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J Zico Kolter and Andrew Y Ng. Near-bayesian exploration in polynomial time. In International Conference on Machine Learning (ICML), pp. 513–520, 2009. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            174,
+            484,
+            826,
+            527
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tze Leung Lai and Herbert Robbins. Asymptotically efficient adaptive allocation rules. Advances in applied mathematics, 6(1):4–22, 1985. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            566
+        ],
+        "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 preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            173,
+            574,
+            826,
+            617
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David G Lowe. Object recognition from local scale-invariant features. In Computer vision, 1999. The proceedings of the seventh IEEE international conference on, volume 2, pp. 1150–1157. Ieee, 1999. ",
+        "bbox": [
+            169,
+            626,
+            825,
+            656
+        ],
+        "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, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            176,
+            664,
+            825,
+            708
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. arXiv preprint arXiv:1602.01783, 2016. ",
+        "bbox": [
+            176,
+            715,
+            825,
+            760
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arun Nair, Praveen Srinivasan, Sam Blackwell, Cagdas Alcicek, Rory Fearon, Alessandro De Maria, Vedavyas Panneershelvam, Mustafa Suleyman, Charles Beattie, Stig Petersen, et al. Massively parallel methods for deep reinforcement learning. arXiv preprint arXiv:1507.04296, 2015. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            811
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped DQN. In Advances in Neural Information Processing Systems (NIPS), 2016a. ",
+        "bbox": [
+            173,
+            819,
+            823,
+            849
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Osband, Benjamin Van Roy, and Zheng Wen. Generalization and exploration via randomized value functions. In International Conference on Machine Learning (ICML), 2016b. ",
+        "bbox": [
+            173,
+            857,
+            821,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pierre-Yves Oudeyer and Frederic Kaplan. What is intrinsic motivation? A typology of computational approaches. Frontiers in Neurorobotics, 1:6, 2007. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Pazis and Ronald Parr. PAC optimal exploration in continuous space Markov decision processes. In Twenty-Seventh AAAI Conference on Artificial Intelligence, 2013. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jürgen Schmidhuber. Formal theory of creativity, fun, and intrinsic motivation (1990–2010). IEEE Transactions on Autonomous Mental Development, 2(3):230–247, 2010. ",
+        "bbox": [
+            174,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Philipp Moritz, Michael I Jordan, and Pieter Abbeel. Trust region policy optimization. In International Conference on Machine Learning (ICML), 2015. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            174,
+            217,
+            823,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bradly C Stadie, Sergey Levine, and Pieter Abbeel. Incentivizing exploration in reinforcement learning with deep predictive models. arXiv preprint arXiv:1507.00814, 2015. ",
+        "bbox": [
+            173,
+            253,
+            825,
+            284
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander L Strehl and Michael L Littman. A theoretical analysis of model-based interval estimation. In International Conference on Machine Learning (ICML), pp. 856–863, 2005. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            321
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander L Strehl and Michael L Littman. An analysis of model-based interval estimation for Markov decision processes. Journal of Computer and System Sciences, 74(8):1309–1331, 2008. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            359
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yi Sun, Faustino Gomez, and Jürgen Schmidhuber. Planning to be surprised: Optimal Bayesian exploration in dynamic environments. In Artificial General Intelligence, pp. 41–51. 2011. ",
+        "bbox": [
+            176,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Engin Tola, Vincent Lepetit, and Pascal Fua. Daisy: An efficient dense descriptor applied to wide-baseline stereo. IEEE transactions on pattern analysis and machine intelligence, 32(5): 815–830, 2010. ",
+        "bbox": [
+            176,
+            405,
+            823,
+            448
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. In International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            173,
+            457,
+            823,
+            486
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, Matteo Hessel, and David Silver. Learning functions across many orders of magnitudes. arXiv preprint arXiv:1602.07714, 2016a. ",
+        "bbox": [
+            174,
+            494,
+            821,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double Q-learning. In Thirtieth AAAI Conference on Artificial Intelligence, 2016b. ",
+        "bbox": [
+            174,
+            531,
+            821,
+            561
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander Vezhnevets, Volodymyr Mnih, John Agapiou, Simon Osindero, Alex Graves, Oriol Vinyals, and Koray Kavukcuoglu. Strategic attentive writer for learning macro-actions. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            174,
+            569,
+            823,
+            613
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Nando de Freitas, and Marc Lanctot. Dueling network architectures for deep reinforcement learning. In International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            651
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A Appendices ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            303,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 Hyperparameter Settings ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            400,
+            150
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the rllab experiments, we used batch size 5000 for all tasks except SwimmerGather, for which we used batch size 50000. CartpoleSwingup makes use of a neural network policy with one layer of 32 tanh units. The other tasks make use of a two layer neural network policy of 32 tanh units each for MountainCar and HalfCheetah, and of 64 and 32 tanh units for SwimmerGather. The outputs are modeled by a fully factorized Gaussian distribution ${ \\cal N } ( \\mu , \\sigma ^ { 2 } I )$ , in which $\\mu$ is modeled as the network output, while $\\sigma$ µ, σ µis a parameter. CartPoleSwingup makes use of a neural network baseline with one σlayer of 32 ReLU units, while all other tasks make use of a linear baseline function. For all tasks, we used TRPO step size 0 01 and discount factor $\\gamma = 0 . 9 9$ . We choose SimHash parameter $k = 3 2$ and bonus coefficient $\\beta = 0 . 0 1$ γ ., found through a coarse grid search. ",
+        "bbox": [
+            174,
+            164,
+            825,
+            290
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For Atari experiments, a batch size of 100000 is used, while the KL divergence step size is set to 0 01. The policy and baseline both have the following architecture: 2 convolutional layers with .respectively 16 and 32 filters, sizes $8 \\times 8$ and $4 \\times 4$ , strides 4 and 2, using no padding, feeding into a single hidden layer of 256 units. The nonlinearities are rectified linear units (ReLUs). The input frames are downsampled to $5 2 \\times 5 2$ . The input to policy and baseline consists of the 4 previous frames, corresponding to the frame skip of 4. The discount factor was set to $\\gamma = 0 . 9 9 5$ . All inputs are rescaled to $[ - 1 , 1 ]$ γ .element-wise. All experiments used 5 different training seeds, except the ,experiments with the learned hash code, which uses 3 different training seeds. Batch normalization (Ioffe & Szegedy, 2015) is used at each policy and baseline layer. TRPO-pixel-SimHash uses binary codes of size $k = 2 5 6$ ; BASS (TRPO-BASS-SimHash) extracts features using cell size $C = 2 0$ and $B = 2 0$ bins. The autoencoder for the learned embedding (TRPO-AE-SimHash) uses a binary hidden layer of 512 bit, which are projected to 64 bit. ",
+        "bbox": [
+            174,
+            296,
+            825,
+            463
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "RAM states in Atari 2600 games are integer-valued vectors over length 128 in the range [0 255]. ,Experiments on Montezuma’s Revenge with RAM observations use a policy consisting of 2 hidden layers, each of size 32. RAM states are rescaled to a range $[ - 1 , 1 ]$ . Unlike images, only the current ,RAM is shown to the agent. Experiment results are averaged over 10 random seeds. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            526
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In addition, we apply counting Bloom filters (Fan et al., 2000) to maintain a small hash table. Details can be found in Appendix A.5. ",
+        "bbox": [
+            176,
+            532,
+            821,
+            560
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The autoencoder used for the learned hash code has a 512 bit binary code layer, using sigmoid units, to which uniform noise $U ( - a , a )$ with $a = 0 . 3$ is added. The loss function Eq. (3), using $\\lambda = 1 0$ , is updated every $j _ { \\mathrm { u p d a t e } } = 3$ , . λiterations. The architecture looks as follows: an input layer of size $5 2 \\times 5 2$ , representing the image luminance is followed by 3 consecutive $6 \\times 6$ convolutional layers with stride 2 and 96 filters feed into a fully connected layer of size 1024, which connects to the binary code layer. This binary code layer feeds into a fully-connected layer of 1024 units, connecting to a fully-connected layer of 2400 units. This layer feeds into 3 consecutive $6 \\times 6$ transposed convolutional layers of which the final one connects to a pixel-wise softmax layer with 64 bins, representing the pixel intensities. Moreover, label smoothing is applied to the different softmax bins, in which the log-probability of each of the bins is increased by 0 003, before normalizing. The softmax weights .are shared among each pixel. All output nonlinearities are ReLUs; Adam (Kingma & Ba, 2015) is used as an optimization scheme; batch normalization (Ioffe & Szegedy, 2015) is applied to each layer. The architecture was shown in Figure 1 of Section 2.3. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            748
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 Description of the Adapted rllab Tasks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            771,
+            504,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This section describes the continuous control environments used in the experiments. The tasks are implemented as described in Duan et al. (2016), following the sparse reward adaptation of Houthooft et al. (2016). The tasks have the following state and action dimensions: CartPoleSwingup, $S \\subseteq \\mathbb { R } ^ { 4 }$ , $\\mathcal { A } \\subseteq \\mathbb { R } ^ { 1 }$ ; MountainCar $s \\subseteq \\mathbb { R } ^ { 3 }$ , $\\mathcal { A } \\subseteq \\mathbf { \\overline { { \\mathbb { R } } } } ^ { 1 }$ ; HalfCheetah, $\\boldsymbol { s } \\subseteq \\mathbb { R } ^ { 2 0 }$ , $\\mathcal { A } \\subseteq \\mathbb { R } ^ { 6 }$ ; SwimmerGather, $\\boldsymbol { S } \\subseteq \\mathbb { R } ^ { 3 3 }$ , $\\mathcal { A } \\subseteq \\mathbb { R } ^ { 2 }$ . For the sparse reward experiments, the tasks have been modified as follows. In CartPoleSwingup, the agent receives a reward of $+ 1$ when $\\cos ( \\beta ) > 0 . 8$ , with $\\beta$ the pole angle. In MountainCar, the agent receives a reward of $+ 1$ β > . βwhen the goal state is reached, namely escaping the valley from the right side. Therefore, the agent has to figure out how to swing up the pole in the absence of any initial external rewards. In HalfCheetah, the agent receives a reward of $+ 1$ when $x _ { \\mathrm { b o d y } } > 5$ . As such, it has to figure out how to move forward without any initial external reward. The >time horizon is set to $T = 5 0 0$ for all tasks. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 Examples of Atari 2600 RAM Entries ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            485,
+            164
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 5 lists the semantic interpretation of certain RAM entries in Montezuma’s Revenge. SmartHash, as described in Section 3.4, makes use of RAM indices 3, 42, 43, 27, and 67. “Beam walls” are deadly barriers that occur periodically in some rooms. ",
+        "bbox": [
+            174,
+            175,
+            826,
+            217
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/11466a8ac05b50c7f75922b0b2695e26f2f91adcc962f6f38979c5de9ed3f2b5.jpg",
+        "table_caption": [
+            "Table 5: Interpretation of particular RAM entries in Montezuma’s Revenge "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>RAM index</td><td>Group</td><td>Meaning</td></tr><tr><td>3</td><td>room</td><td>room number</td></tr><tr><td>42</td><td>agent</td><td>x coordinate</td></tr><tr><td>43</td><td>agent</td><td>y coordinate</td></tr><tr><td>52</td><td>agent</td><td>orientation (left/right)</td></tr><tr><td>27</td><td>beam walls</td><td>on/off</td></tr><tr><td>83</td><td>beam walls</td><td>beam wall countdown (on: O,off: 36 → 0)</td></tr><tr><td>0</td><td>counter</td><td>counts from O to 255 and repeats</td></tr><tr><td>55</td><td>counter</td><td>death scene countdown</td></tr><tr><td>67</td><td>objects</td><td>existence of objects (doors,skull and key) in the 1st room</td></tr><tr><td>47</td><td>skull</td><td>x coordinate (both 1st and 2nd rooms)</td></tr></table>",
+        "bbox": [
+            202,
+            256,
+            794,
+            469
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.4 Analysis of Learned Binary Representation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            493,
+            535,
+            507
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows the downsampled codes learned by the autoencoder for several Atari 2600 games (Frostbite, Freeway, and Montezuma’s Revenge). Each row depicts 50 consecutive frames (from 0 to 49, going from left to right, top to bottom). The pictures in the right column depict the binary codes that correspond with each of these frames (one frame per row). Figure 7 shows the reconstructions of several subsequent images according to the autoencoder. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            589
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/211bf74321124f76d9aeedcd9061eebfd5f44286aaae4dd4b4fda17411c089b8.jpg",
+        "image_caption": [
+            "Figure 6: Frostbite, Freeway, and Montezuma’s Revenge: subsequent frames (left) and corresponding code (right); the frames are ordered from left (starting with frame number 0) to right, top to bottom; the vertical axis in the right images correspond to the frame number. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            195,
+            815,
+            772
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/b12b2c9fed2ee4b18399bef400e2ba7a6e24230656b1816faf85b7f8ee3f8f88.jpg",
+        "image_caption": [
+            "Figure 7: Freeway: subsequent frames and corresponding code (top); the frames are ordered from left (starting with frame number 0) to right, top to bottom; the vertical axis in the right images correspond to the frame number. Within each image, the left picture is the input frame, the middle picture the reconstruction, and the right picture, the reconstruction error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            103,
+            816,
+            479
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.5 Counting Bloom Filter/Count-Min Sketch ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            594,
+            522,
+            609
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We experimented with directly building a hashing dictionary with keys $\\phi ( s )$ and values the state φcounts, but observed an unnecessary increase in computation time. Our implementation converts the integer hash codes into binary numbers and then into the “bytes” type in Python. The hash table is a dictionary using those bytes as keys. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            686
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "However, an alternative technique called Count-Min Sketch (Cormode & Muthukrishnan, 2005), with a data structure identical to counting Bloom filters (Fan et al., 2000), can count with a fixed integer array and thus reduce computation time. Specifically, let $p ^ { 1 } , \\ldots , p ^ { l }$ be distinct large prime numbers and define $\\phi ^ { j } ( s ) = \\phi ( s ) \\ \\mathrm { m o d } p ^ { j }$ . The count of state $s$ is returned as $\\mathrm { m i n } _ { 1 \\le j \\le l } n ^ { j } \\left( \\bar { \\phi ^ { j } } ( \\bar { s } ) \\right)$ . To increase the count of $s$ , we increment $n ^ { j } \\left( \\phi ^ { j } ( s ) \\right)$ by 1 for all $j$ . Intuitively, the method replaces $\\phi$ by weaker hash functions, while it reduces the probability of over-counting by reporting counts agreed by all such weaker hash functions. The final hash code is represented as $\\left( \\phi ^ { 1 } ( s ) , . . . , \\phi ^ { l } ( s ) \\right)$ . ",
+        "bbox": [
+            173,
+            693,
+            825,
+            805
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Throughout all experiments above, the prime numbers for the counting Bloom filter are 999931, 999953, 999959, 999961, 999979, and 999983, which we abbreviate as $\\mathbf { \\ddot { \\theta } M ^ { \\prime \\prime } }$ . In addition, we experimented with 6 other prime numbers, each approximately $1 5 \\mathbf { M }$ , which we abbreviate as $\" 9 0 1 \\vec { \\bf M } \"$ . As we can see in Figure 8, counting states with a dictionary or with Bloom filters lead to similar performance, but the computation time of latter is lower. Moreover, there is little difference between direct counting and using a very larger table for Bloom filters, as the average bonus rewards are almost the same, indicating the same degree of exploration-exploitation trade-off. On the other hand, Bloom filters require a fixed table size, which may not be known beforehand. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/21758b2fa131e1fa7d95610d3c88ea9f86077b67c5f1fe8d3c4ecb1a19a973fb.jpg",
+        "image_caption": [
+            "Figure 8: Statistics of TRPO-pixel-SimHash $k = 2 5 6$ on Frostbite. Solid lines are the mean, while the shaded areas represent the one standard deviation. Results are derived from 10 random seeds. Direct counting with a dictionary uses 2.7 times more computations than counting Bloom filters (6 M or $9 0 \\mathbf { M }$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            102,
+            792,
+            265
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Theory of Bloom Filters Bloom filters (Bloom, 1970) are popular for determining whether a data sample $s ^ { \\prime }$ belongs to a dataset $\\mathcal { D }$ . Suppose we have $l$ functions $\\phi ^ { j }$ that independently assign each data sample to an integer between 1 and $p$ φuniformly at random. Initially $1 , 2 , \\ldots , p$ are marked as 0. Then every $s \\in \\mathcal { D }$ is “inserted” through marking $\\phi ^ { j } { \\dot { ( s ) } }$ as 1 for all $j$ , , . . . ,. A new sample $s ^ { \\prime }$ is reported as a member of $\\mathcal { D }$ only if $\\phi ^ { j } ( s )$ φare marked as 1 for all $j$ . A bloom filter has zero false negative rate (any $s \\in \\mathcal { D }$ φis reported a member), while the false positive rate (probability of reporting a nonmember as a member) decays exponentially in $l$ . ",
+        "bbox": [
+            173,
+            371,
+            826,
+            469
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Though Bloom filters support data insertion, it does not allow data deletion. Counting Bloom filters (Fan et al., 2000) maintain a counter $n ( \\cdot )$ for each number between 1 and $p$ . Inserting/deleting $s$ corresponds to incrementing/decrementing $n { \\Big ( } \\phi ^ { j } ( s ) { \\Big ) }$ by 1 for all $j$ . Similarly, $s$ is considered a member if $\\forall j : n \\Big ( \\phi ^ { j } ( s ) \\Big ) = 0$ . ",
+        "bbox": [
+            173,
+            476,
+            825,
+            542
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Count-Min sketch is designed to support memory-efficient counting without introducing too many over-counts. It maintains a separate count $n ^ { j }$ for each hash function $\\phi ^ { j }$ defined as $\\phi ^ { j } \\bar { ( s ) } = \\phi ( \\bar { s ) }$ mod $p ^ { j }$ , where $p ^ { j }$ φis a large prime number. For simplicity, we may assume that $p ^ { j } \\approx p \\forall j$ φand $\\phi ^ { j }$ assigns $s$ to any of $1 , \\ldots , p$ with uniform probability. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            606
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We now derive the probability of over-counting. Let $s$ be a fixed data sample (not necessarily inserted yet) and suppose a dataset $\\mathcal { D }$ of $N$ samples are inserted. We assume that $p ^ { l } \\gg N$ . Let $n : = \\mathrm { m i n } _ { 1 \\leq j \\leq l } n ^ { j } \\left( \\phi ^ { j } ( s ) \\right)$ be the count returned by the Bloom filter. We are interested in computing $\\mathrm { P r o b } ( n > 0 | s \\notin \\mathcal { D } )$ . Due to assumptions about $\\phi ^ { j }$ , we know $n ^ { j } ( \\phi ( s ) ) \\sim \\mathrm { B i n o m i a l } \\left( N , { \\frac { 1 } { p } } \\right)$ . Therefore, ",
+        "bbox": [
+            173,
+            612,
+            825,
+            679
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b78348a010792e41a008c324c65dc5655ddca439600d5c1357b1d1ff97efceed.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathrm { P r o b } ( n > 0 | s \\mathcal { G } \\mathcal { D } ) = } & { \\frac { \\mathrm { P r o b } ( n > 0 , s \\varphi \\mathcal { D } ) } { \\mathrm { P r o b } ( s \\varphi \\mathcal { D } ) } } \\\\ & { = \\frac { \\mathrm { P r o b } ( n > 0 ) - \\mathrm { P r o b } ( s \\varphi \\mathcal { D } ) } { \\mathrm { P r o b } ( s \\varphi \\mathcal { D } ) } } \\\\ & { \\approx \\frac { \\mathrm { P r o b } ( n > 0 ) } { \\mathrm { P r o b } ( s \\varphi \\mathcal { D } ) } } \\\\ & { = \\frac { \\mathrm { P r o b } ( n > 0 ) } { \\mathrm { P r o b } ( s \\varphi \\mathcal { D } ) } } \\\\ & { = \\frac { ( 1 - 1 ) \\cdot ( 1 \\rho \\mathcal { P } ) ^ { N } ( 1 \\circ 1 ) \\cdot ( \\rho \\mathcal { P } ) } { ( 1 - 1 ) \\cdot ( 1 \\rho \\mathcal { P } ) ^ { N } } } \\\\ & { = \\frac { ( 1 - 1 ) \\cdot ( 1 \\rho \\mathcal { P } ) ^ { N } } { ( 1 - 1 ) \\cdot ( 1 \\rho \\mathcal { P } ) ^ { N } } } \\\\ & { \\approx \\frac { ( 1 - e ^ { - N \\varphi \\mathcal { P } } ) } { e ^ { - N \\varphi \\mathcal { P } } } } \\\\ & { \\approx ( 1 - e ^ { - N \\varphi \\mathcal { P } } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            699,
+            665,
+            928
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In particular, the probability of over-counting decays exponentially in $l$ . We refer the readers to (Cormode & Muthukrishnan, 2005) for other properties of the Count-Min sketch. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "A.6 Robustness Analysis ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            366,
+            164
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Apart from the experimental results shown in Table 1 and Table 3, additional experiments have been performed to study several properties of our algorithm. ",
+        "bbox": [
+            174,
+            174,
+            823,
+            203
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameter sensitivity To study the performance sensitivity to hyperparameter changes, we focus on evaluating TRPO-RAM-SimHash on the Atari 2600 game Frostbite, where the method has a clear advantage over the baseline. Because the final scores can vary between different random seeds, we evaluated each set of hyperparameters with 30 seeds. To reduce computation time and cost, RAM states are used instead of image observations. ",
+        "bbox": [
+            174,
+            218,
+            825,
+            289
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e1aa064e523954524023c87b9d32d4de7b54bb375fae24c591e73e2dac08e29.jpg",
+        "table_caption": [
+            "Table 6: TRPO-RAM-SimHash performance robustness to hyperparameter changes on Frostbite "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"8\">阝</td></tr><tr><td>k 0</td><td>0.01</td><td>0.05</td><td>0.1</td><td>0.2</td><td>0.4</td><td>0.8</td><td>1.6</td></tr><tr><td>1</td><td>397</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>64</td><td>1</td><td>879</td><td>2464</td><td>2243</td><td>2489</td><td>1587</td><td>1107</td><td>441</td></tr><tr><td>128</td><td>1</td><td>1475</td><td>4248</td><td>2801</td><td>3239</td><td>3621</td><td>1543</td><td>395</td></tr><tr><td>256</td><td></td><td>2583</td><td>4497</td><td>4437</td><td>7849</td><td>3516</td><td>2260</td><td>374</td></tr></table>",
+        "bbox": [
+            274,
+            328,
+            723,
+            457
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "The results are summarized in Table 6. Herein, $k$ refers to the length of the binary code for hashing while $\\beta$ is the multiplicative coefficient for the reward bonus, as defined in Section 2.2. This βtable demonstrates that most hyperparameter settings outperform the baseline $\\mathcal { B } = 0 ,$ ) significantly. βMoreover, the final scores show a clear pattern in response to changing hyperparameters. Small $\\beta$ -values lead to insufficient exploration, while large $\\beta$ -values cause the bonus rewards to overwhelm βthe true rewards. With a fixed $k$ β, the scores are roughly concave in $\\beta$ , peaking at around 0 2. Higher granularity $k$ β .leads to better performance. Therefore, it can be concluded that the proposed exploration method is robust to hyperparameter changes in comparison to the baseline, and that the best parameter settings can obtained from a relatively coarse-grained grid search. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            595
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "State and state-action counting Continuing the results in Table 6, the performance of state-action counting is studied using the same experimental setup, summarized in Table 7. In particular, a bonus reward $\\begin{array} { r } { r ^ { + } = \\frac { \\beta } { \\sqrt { n ( s , a ) } } } \\end{array}$ instead of $\\begin{array} { r } { \\bar { r } ^ { + } = \\frac { \\beta } { \\sqrt { n ( s ) } } } \\end{array}$ is assigned. These results show that the relative ,performance of state counting compared to state-action counting depends highly on the selected hyperparameter settings. However, we notice that the best performance is achieved using state counting with $k = 2 5 6$ and $\\beta = 0 . 2$ . ",
+        "bbox": [
+            173,
+            609,
+            825,
+            700
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "table",
+        "img_path": "images/da16c1e69e4b3ab939c097718db795bb4308239e8606a5d7a4190fbcd69fa701.jpg",
+        "table_caption": [
+            "Table 7: Performance comparison between state counting (left of the slash) and state-action counting (right of the slash) using TRPO-RAM-SimHash on Frostbite "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"8\">β</td></tr><tr><td>0.01</td><td>0.05</td><td>0.1</td><td>0.2</td><td></td><td>0.4</td><td>0.8</td><td>1.6</td></tr><tr><td>64</td><td>879/976</td><td>2464/1491</td><td>2243/3954</td><td>2489 /5523</td><td>1587 /5985</td><td>1107/2052</td><td></td><td>441/742</td></tr><tr><td>128</td><td>1475/808</td><td>4248/4302</td><td>2801/4802</td><td>3239 /7291</td><td></td><td>3621/4243</td><td>1543/1941</td><td>395/362</td></tr><tr><td>256</td><td>2583 /1584</td><td>4497 /5402</td><td>4437 /5431</td><td>7849 /4872</td><td>3516/3175</td><td></td><td>2260/1238</td><td>374/96</td></tr></table>",
+        "bbox": [
+            222,
+            752,
+            776,
+            864
+        ],
+        "page_idx": 17
+    }
+]

parse/train/rJgBd2NYPH/rJgBd2NYPH.md

@@ -0,0 +1,370 @@
+# LEARNING DEEP GRAPH MATCHING VIA CHANNELINDEPENDENT EMBEDDING AND HUNGARIAN ATTENTION
+
+Tianshu $\mathbf { V } \mathbf { u } ^ { \dagger }$ , Runzhong Wang‡, Junchi Yan‡, Baoxin Li†
+
+†Arizona State University   
+‡Shanghai Jiao Tong University   
+{tianshuy,baoxin.li}@asu.edu   
+{runzhong.wang,yanjunchi}@sjtu.edu.cn
+
+# ABSTRACT
+
+Graph matching aims to establishing node-wise correspondence between two graphs, which is a classic combinatorial problem and in general NP-complete. Until very recently, deep graph matching methods start to resort to deep networks to achieve unprecedented matching accuracy. Along this direction, this paper makes two complementary contributions which can also be reused as plugin in existing works: i) a novel node and edge embedding strategy which stimulates the multihead strategy in attention models and allows the information in each channel to be merged independently. In contrast, only node embedding is accounted in previous works; ii) a general masking mechanism over the loss function is devised to improve the smoothness of objective learning for graph matching. Using Hungarian algorithm, it dynamically constructs a structured and sparsely connected layer, taking into account the most contributing matching pairs as hard attention. Our approach performs competitively, and can also improve state-of-the-art methods as plugin, regarding with matching accuracy on three public benchmarks.
+
+# 1 INTRODUCTION
+
+Without loss of generality, we consider the bijection problem for graph matching: given graph $\mathcal { G } _ { 1 }$ and $\mathcal { G } _ { 2 }$ of equal size $n$ , graph matching seeks to find the one-vs-one node correspondence1:
+
+$$
+\operatorname* { m a x } _ { \mathbf { x } } \mathbf { x } ^ { \top } \mathbf { K } \mathbf { x } \qquad \mathrm { s . t . } \quad \mathbf { P } \mathbf { x } = \mathbf { 1 }
+$$
+
+where $\mathbf { x } = \mathrm { v e c } ( \mathbf { X } ) \in \{ 0 , 1 \} ^ { n ^ { 2 } }$ which is the column-wise vectorized form of the permutation ma$\mathbf { X }$ $\mathbf { \bar { K } } \in \mathcal { R } _ { + } ^ { n ^ { 2 } \times n ^ { 2 } }$ is the so-called affinity matrix2, respectively. Note $\mathbf { P }$ is a selection matrix encoding the one-to-one correspondence constraint. This problem is called Lawler’s QAP (Lawler, 1963) and has attracted enormous attention for its generally NP-complete (Hartmanis, 1982) challenge, as well as a wide spectrum of applications in computer vision, graphics, machine learning and operational research etc. In particular, Koopmans-Beckmann’s QAP (Loiola et al., 2007) with objective $\operatorname { t r } ( \mathbf { X } ^ { \top } \mathbf { F } _ { 1 } \mathbf { X } \mathbf { F } _ { 2 } )$ is a special case of Eq. (1), which can be converted to Lawler’s QAP by $\mathbf { K } = \mathbf { F } _ { 2 } \otimes \mathbf { F } _ { 1 }$ and $\mathbf { F } _ { i }$ refers to the weighted adjacency matrix. A series of solvers haven been developed to solve graph matching problem (Leordeanu & Hebert, 2005; Cho et al., 2010; Bernard et al., 2018; Yan et al., 2015; Yu et al., 2018). All these methods are based on deterministic optimization, which are conditioned with pre-defined affinity matrix and no learning paradigm is involved. This fact greatly limits the performance and broad application w.r.t. different problem settings considering its NP-hard nature.
+
+Recently, the seminal work namely deep graph matching (DGM) (Zanfir & Sminchisescu, 2018) is proposed to exploit the high capacity of deep networks for graph matching, which achieves stateof-the-art performance. This is in contrast to some early works which incorporate learning strategy separately in local stages (Caetano et al., 2009; Cho et al., 2013). On the other hand, Graph Convolutional Networks (GCN) (Kipf & Welling, 2017) brings about new capability on tasks over graph-like data, as it naturally integrates the intrinsic graph structure in a general updating rule:
+
+$$
+\mathbf { H } ^ { ( l + 1 ) } = \sigma \left( \hat { \mathbf { A } } \mathbf { H } ^ { ( l ) } \mathbf { W } ^ { ( l ) } \right)
+$$
+
+where $\hat { \bf A }$ is the normalized connectivity matrix. $\mathbf { H } ^ { ( l ) }$ and $\mathbf { W } ^ { ( l ) }$ are the features and weights at layer $l$ , respectively. Node embedding is updated by aggregation from 1-neighboring nodes, which is akin to the convolution operator in CNN. By taking advantages of both DGM and GCN, Wang et al. (2019) and Zhang & Lee (2019) incorporate permutation loss instead of displacement loss in (Zanfir & Sminchisescu, 2018), with notable improvement across both synthetic and real data.
+
+Note that Eq. (1) involves both node and edge information, which exactly correspond to the diagonal and off-diagonal elements in $\mathbf { K }$ , respectively. Edges can carry informative multi-dimensional attributes (namely weights) which are fundamental to graph matching. However existing embedding based graph matching methods (Wang et al., 2019; Xu et al., 2019) are focused on the explicit modeling of node level features, whereby the edges are only used as topological node connection for message passing in GCN. Besides, edge attributes are neither well modeled in the embedding-free model (Zanfir & Sminchisescu, 2018) since the edge information is derived from the concatenation of node features. To our best knowledge, there is no deep graph matching method explicitly incorporating edge attributes. In contrast, edge attributes e.g. length and orientation are widely used in traditional graph matching models (Cho et al., 2010; Yan et al., 2015; Yu et al., 2018) for constructing the affinity matrix K. Such a gap shall be filled in the deep graph matching pipeline.
+
+Another important consideration refers to the design of loss function. There are mainly two forms in existing deep graph matching works: i) displacement loss (Zanfir & Sminchisescu, 2018) similar to the use in optical flow estimation (Ren et al., 2017); ii) the so-called permutation loss (Wang et al., 2019) involving iterative Sinkhorn procedure followed by a cross-entropy loss. Results in (Wang et al., 2019) show the latter is an effective improvement against the former regression based loss. However, we argue that the continuous Sinkhorn procedure (in training stage) is yet an unnatural approximation to Hungarian sampling (in testing stage) for discretization. If the network is equipped with a continuous loss function (e.g. cross-entropy), we argue that the training process will make a great “meaningless effort” to enforce some network output digits of the final matching matrix into binary and neglect the resting digits which might have notable impact on accuracy.
+
+This paper strikes an endeavor on the above two gaps and makes the following main contributions:
+
+i) We propose a new approach for edge embedding via channel-wise operation, namely channelindependent embedding (CIE). The hope is to effectively explore the edge attribute and simulate the multi-head strategy in attention models (Velickovi ˇ c et al., 2018) by decoupling the calculations ´ parallel and orthogonal to channel direction. In fact, edge attribute information has not been considered in existing embedding based graph matching methods (Wang et al., 2019; Xu et al., 2019).
+
+ii) We devise a new mechanism to adjust the loss function based on the Hungarian method which is widely used for linear assignment problem, as termed by Hungarian attention. It resorts to dynamically generating sparse matching mask according to Hungarian sampling during training, rather than approximating Hungarian sampling with a differentiable function. As such, the Hungarian attention introduces higher smoothness against traditional loss functions to ease the training.
+
+iii) The empirical results on three public benchmarks shows that the two proposed techniques are orthogonal and beneficial to existing techniques. Specifically, on the one hand, our CIE module can effectively boost the accuracy by exploring the edge attributes which otherwise are not considered in state-of-the-art deep graph matching methods; on the other hand, our Hungarian attention mechanism also shows generality and it is complementary to existing graph matching loss.
+
+# 2 RELATED WORKS
+
+Graph embedding. To handle graph-like data, early works adopt recursive neural networks (RNNs) treating input as directed acyclic graphs (Sperduti & Starita, 1997; Frasconi et al., 1998). Gori et al. (2005); Scarselli et al. (2008) generalized early models to graph neural networks (GNNs) so as to be directly applied on cyclic, directed or undirected graphs. Li et al. (2016) further improved this line of model by replacing standard RNNs with gated recurrent units (GRUs) (Cho et al., 2013). Inspired by the great success of convolutional neural networks (CNNs) (Simonyan & Zisserman, 2014; He et al., 2016), researchers have made tremendous effort on applying convolution operator to graphs (Bruna et al., 2014; Kipf & Welling, 2017; Gong & Cheng, 2019). Bruna et al. (2014) defined a convolution operator in Fourier domain which is obtained by performing eigen-decomposition on graph Laplacian. However, such convolution will affect the whole spatial domain once taking inverse Fourier transformation. This method was improved by Chebyshev expansion to approximate filters (Defferrard et al., 2016). Kipf & Welling (2017) propose a graph convolutional operator over 1-neighbor nodes derived from graph spectral theory, which is invariant to node permutation and achieved significant performance on semi-supervised learning tasks. There are series of works following GCN, such as GraphSAGE (Hamilton et al., 2017), GAT (Velickovi ˇ c et al., 2018) and ´ MPNN (Gilmer et al., 2017). Refer to (Cai et al., 2018) for a more comprehensive survey.
+
+While the aforementioned models are focused on learning node state/embedding, a parallel line of work seek to learn edge embedding by taking into account the information carried on edges (Li et al., 2016; Gilmer et al., 2017; Gong & Cheng, 2019). Edges are intrinsic portion of graphs, and thus edge embedding can be essential to reveal the relation among nodes. Gilmer et al. (2017) introduce a general embedding network incorporating edge information and node-edge information merging, and a serious of works fall into this framework e.g. Gated GNN (Li et al., 2016), Tensor GNN (Schutt et al., 2017) and EGNN (Gong & Cheng, 2019). An improved version is devised in Chen ¨ et al. (2019) by interpreting this framework as maximizing mutual information across layers.
+
+Loss for combinatorial learning. For the relatively easy linear assignment problem, it has been known that Sinkhorn algorithm (Sinkhorn, 1964) is the approximate and differentiable version of Hungarian algorithm (Mena et al., 2017). The Sinkhorn Network (Adams & Zemel, 2011) is developed given known assignment cost, whereby doubly-stochastic regulation is performed on input non-negative square matrix. Patrini et al. (2018) devise the Sinkhorn AutoEncoder to minimize Wasserstein distance, and Emami & Ranka (2018) propose to learning a linear assignment solver via reinforcement learning. For permutation prediction, DeepPermNet (Santa Cruz et al., 2018) adopts the Sinkhorn layer on top of a deep convolutional network. However this method cannot be directly applied for graph matching as it is not invariant to input permutations which is conditioned on a predefined node permutation as reference. In particular, existing supervised methods on combinatorial learning are generally cross-entropy-based. Pointer Net (Vinyals et al., 2015) incorporates cross-entropy loss on learning heuristics for combinatorial problems. Milan et al. (2017) propose an objective-based loss, where the gradients are only updated if the objective improves after update.
+
+Learning for graph matching. The early effort (Caetano et al., 2009) aims to incorporate learning to graph matching. The key is to learn a more effective affinity function with given correspondence as supervision. While the ability by only learning affinity is limited, Cho et al. (2013) propose a matching function learning paradigm using histogram-based attributes with Structured-SVM (Tsochantaridis et al., 2005). A recent work (Zanfir & Sminchisescu, 2018) is a breakthrough to introduce deep learning paradigm into graph matching task, which utilizes a neural network to learn the affinity function. The learning procedure is explicitly derived from the factorization of affinity matrix (Zhou & De la Torre, 2012), which makes the interpretation of the network behavior possible. However, the displacement loss in (Zanfir & Sminchisescu, 2018) measures the pixel-wise translation which is similar to optical-flow (Dosovitskiy et al., 2015), being essentially a regression task instead of combinaotiral optimization. Seeing this limitation, Wang et al. (2019) employ elementwise binary cross-entropy, termed as permutation loss. This loss has proved capable of capturing the combinatorial nature rather than pixel offset, and achieves improvement over displacement loss. Node embedding is also used in (Wang et al., 2019) to explore the structure information.
+
+# 3 THE PROPOSED LEARNING APPROACH FOR GRAPH MATCHING
+
+# 3.1 APPROACH OVERVIEW
+
+An overall structure of our approach is illustrated in Fig. 1. In line with (Wang et al., 2019), we employ VGG16 (Simonyan & Zisserman, 2014) to extract features from input images and bi-linearly interpolate the features at key points (provided by datasets). We concatenate lower-level (Relu4 2) and higher-level (Relu5 1) features to incorporate local and contextual information. For an image with $k$ key points, the feature is denoted as $\mathbf { \bar { H } } \in \mathcal { R } ^ { k \times d }$ , where $d$ is the feature dimension. Unless otherwise specified, the adjacency matrix $\mathbf { A } \in \mathcal { R } ^ { k \times k }$ is consequentially constructed via Delaunay triangulation (Delaunay et al., 1934), which is a widely adopted strategy to produce sparsely connected graph. To introduce more rich edge information, we also generate $k \times k m$ -dimensional edge features $\dot { \mathbf { E } } \in \mathcal { R } ^ { m \times k \times k }$ . $E$ can be initialized with some basic edge information (e.g. length and angle and other attributes) or a commutative function $\mathbf E _ { i j } = p ( \mathbf H _ { i } , \mathbf H _ { j } ) = p ( \mathbf H _ { j } , \mathbf H _ { i } ) \in \mathcal { R } ^ { m }$ , where $\mathbf { H } _ { i }$ refers to the feature of node $i$ . Note for directed graph, the commutative property is not required.
+
+![](images/267255b09253042737ddb258c97d1928c580274268e1a0f652999670954f3306.jpg)  
+Figure 1: Architecture overview of the proposed deep graph matching networks that consist of the proposed channel-independent embedding and Hungarian attention layer over the loss function.
+
+The features $\mathbf { H }$ and $\mathbf { E }$ , together with the adjacency A, are then fed into GNN module. Pairs of features are processed in a Siamese fashion (Bromley et al., 1994). Standard GCN’s message passing rule simply updates node embedding as shown in Eq. (2). In contrast, each GNN layer in our model computes a new pair of node and edge embeddings simultaneously:
+
+$$
+\mathbf { H } ^ { ( l + 1 ) } = f _ { i } ( \mathbf { H } ^ { ( l ) } , \mathbf { E } ^ { ( l ) } , \mathbf { A } ; W _ { 0 } ^ { l } ) , \quad \mathbf { E } ^ { ( l + 1 ) } = g ( \mathbf { H } ^ { ( l ) } , \mathbf { E } ^ { ( l ) } , \mathbf { A } ; W _ { 1 } ^ { l } )
+$$
+
+where $W _ { 0 } ^ { l }$ and $W _ { 1 } ^ { l }$ are the learnable parameters at layer $l$ . The edge information is essential to provide structural feature enhancing graph matching. We initialize $\mathbf { H } ^ { ( 0 ) } = \mathbf { H }$ and $\mathbf { E } ^ { ( 0 ) } = \mathbf { E }$ in our setting. We will discuss the details of functions $f$ and $g$ in Sec. 3.2. Following state-of-the-art work (Wang et al., 2019), we also compute the cross-graph affinity followed by a column/row-wise softmax activation and a Sinkhorn layer (Adams & Zemel, 2011):
+
+$$
+\mathbf { M } _ { i j } = \exp \left( \tau \mathbf { H } _ { ( 1 ) i } ^ { \top } \boldsymbol { \Lambda } \mathbf { H } _ { ( 2 ) j } \right) , \quad \mathbf { S } = \mathrm { S i n k h o r n } ( \mathbf { M } )
+$$
+
+Note here $\mathbf { M } \in \mathbb { R } ^ { k \times k }$ is the node-level similarity matrix encoding similarity between two graphs, differing from the edege-level affinity matrix $\mathbf { K }$ in Eq. 1. $\tau$ is the weighting parameter of similarity, $\pmb { \Lambda }$ contains learnable parameters and ${ \bf H } _ { ( 1 ) i }$ is the node $i$ ’s embedding from graph $\mathcal { G } _ { 1 }$ . The output $\mathbf { S } \in [ 0 , 1 ] ^ { k \times k } , \mathbf { S 1 } = \mathbf { 1 } , \mathbf { S } ^ { \top } \mathbf { 1 } = \mathbf { 1 }$ is a so-called doubly-stochastic matrix. Here Sinkhorn $( \cdot )$ denotes the following update iteratively to project $\mathbf { M }$ into doubly stochastic polygon:
+
+$$
+\mathbf { M } ^ { ( t + 1 ) } = \mathbf { M } ^ { ( t ) } - \frac { 1 } { n } \mathbf { M } ^ { ( t ) } \mathbf { 1 } \mathbf { 1 } ^ { \top } - \frac { 1 } { n } \mathbf { 1 } \mathbf { 1 } ^ { \top } \mathbf { M } ^ { ( t ) } + \frac { 1 } { n ^ { 2 } } \mathbf { 1 } \mathbf { 1 } ^ { \top } \mathbf { M } ^ { ( t ) } \mathbf { 1 } \mathbf { 1 } ^ { \top } - \frac { 1 } { n } \mathbf { 1 } \mathbf { 1 } ^ { \top }
+$$
+
+The Sinkhorn layer is shown to be an approximation of Hungarian algorithm which produces discrete matching output (Kuhn, 1955). As there are only matrix multiplication and normalization operators involved in Sinkhorn layer, it is differentiable. In practice, Eq. (5) converges rapidly within 10 iterations for decades of nodes. Less iterations involved, more precise back-propagated gradients can be achieved. We employ a cross-graph node embedding strategy following (Wang et al., 2019):
+
+$$
+\mathbf { H } _ { ( 1 ) } ^ { ( l ) } = f _ { c } \left( \mathrm { c a t } ( \mathbf { H } _ { ( 1 ) } ^ { ( l ) } , \mathbf { S } \mathbf { H } _ { ( 2 ) } ^ { ( l ) } ) \right) , \quad \mathbf { H } _ { ( 2 ) } ^ { ( l ) } = f _ { c } \left( \mathrm { c a t } ( \mathbf { H } _ { ( 2 ) } ^ { ( l ) } , \mathbf { S } ^ { \top } \mathbf { H } _ { ( 2 ) } ^ { ( l ) } ) \right)
+$$
+
+where $f _ { c }$ is a network and $\cot ( \cdot , \cdot )$ is the concatenation operator. $\mathbf { H } _ { ( i ) }$ is the node feature of graph $i$ . This procedure seeks to merge similar features from another graph into the node feature in current graph. It is similar to the feature transfer strategy in (Aberman et al., 2018) for sparse correspondence, which employs a feature merging method analogous to style transfer (Li et al., 2017).
+
+As Sinkhorn layer does not necessarily output binary digits, we employ Hungarian algorithm (Kuhn, 1955) to discretize matching output S in testing. The testing differs from the training due to the Hungarian discretization. We introduce a novel attention-like mechanism termed as Hungarian attention, along with existing loss functions (will be detailed in Sec. 3.3). The final training loss is as follows, where ${ \bf S } ^ { \mathrm { G } }$ and $\mathcal { H }$ correspond to binary true matching and Hungarian attention loss.
+
+$$
+\operatorname* { m i n } \mathcal { H } ( \mathbf { S } , \mathbf { S } ^ { \mathrm { G } } )
+$$
+
+![](images/301dc06ba29ec62523c5784b4b59304b6998228650416da031d678be87b81dcf.jpg)  
+Figure 2: Illustration of the proposed CIE layer for embedding based deep graph matching. The operation “Linear” refers to the linear mapping, e.g. $\mathbf { H } _ { w } ^ { ( l ) } \to \bar { \mathbf { W } _ { 2 } ^ { ( l ) } } \mathbf { H } _ { w } ^ { ( l ) }$ in Eq (9).
+
+# 3.2 CHANNEL-INDEPENDENT EMBEDDING
+
+We detail the updating rule in Eq. (3). We propose a method to merge edge features into node features and perform matching on nodes. Edge information acts an important role in modeling relational data, whereby such relation can be complex thus should be encoded with high-dimensional feature. To this end, Gilmer et al. (2017) introduce a general embedding layer, which takes node and edge features and outputs a message to node $v$ , then fuses the message and the current embedding:
+
+$$
+\mathbf { m } _ { v } ^ { ( l ) } = \sigma \left( \sum _ { w \in \mathcal { N } _ { v } } f _ { t } \left( \mathbf { E } _ { v w } \right) \mathbf { H } _ { w } ^ { ( l ) } + \mathbf { W } ^ { ( l ) } \mathbf { H } ^ { ( l ) } \right) , \quad \mathbf { H } _ { v } ^ { ( t + 1 ) } = u _ { t } \left( \mathbf { H } _ { v } ^ { ( t ) } , \mathbf { m } _ { v } ^ { ( l ) } \right)
+$$
+
+where $\mathbf { E } _ { v w }$ is the feature corresponding to edge $( v , w )$ . In the realization of Eq. (8) (Gilmer et al., 2017), m(l)v and $\mathbf { H } _ { v } ^ { ( l ) }$ are fed to GRU (Cho et al., 2014) as a sequential input. There are several variants which take into account specific tasks (Li et al., 2016; Schutt et al., 2017; Chen et al., 2019). ¨ Among these, Li et al. (2016) generates a transformation matrix for each edge and Schutt et al. ¨ (2017) resorts to merge embedding via fully connected neural networks. While edge-wise merging is straightforward, the representation ability is also limited. On the other hand, fully connected merging strategy will result in high computational cost and instability for back-propagation. To address these issues, we propose to merge embedding in a channel-wise fashion, which is termed as Channel-Independent Embedding (CIE). Concretely, the updating rule is written as:
+
+$$
+\begin{array} { r } { \mathbf { H } _ { v } ^ { ( l + 1 ) } = \sigma \left( \underset { w \in \mathcal { N } _ { v } } { \sum } \underset { \mathrm { N } } { \underbrace { \Gamma _ { \mathrm { N } } \left( \mathbf { W } _ { 1 } ^ { ( l ) } \mathbf { E } _ { v w } ^ { ( l ) } \circ \mathbf { W } _ { 2 } ^ { ( l ) } \mathbf { H } _ { w } ^ { ( l ) } \right) } } \right) + \sigma \left( \mathbf { W } _ { 0 } ^ { ( l ) } \mathbf { H } _ { v } ^ { ( l ) } \right) } \\ { \mathbf { E } _ { v w } ^ { ( l + 1 ) } = \sigma \left( \mathbf { W } _ { 1 } ^ { ( l ) } \mathbf { E } _ { v w } ^ { ( l ) } \right) } \end{array}
+$$
+
+where $\Gamma _ { \mathrm { N } } ( \cdot \circ \cdot )$ is a channel-wise operator/function (above the underbrace), and it performs calculation per-channel and the output channel dimension is the same as input. The second $\sigma ( \cdot )$ term is the message a node passes to itself, which is necessary in keeping the node information contextually consistent through each CIE layer. In this fashion, CIE is thus a procedure to aggregate node and edge embedding in each channel independently, which requires the dimensions of node $( \mathbf { W } _ { 2 } ^ { ( l ) } \mathbf { H } _ { w } ^ { ( l ) } )$ and edge $( \mathbf { W } _ { 1 } ^ { ( l ) } \mathbf { E } _ { v w } ^ { ( l ) } )$ representations to be equal. Similarly, we also propose an corresponding updating rule of edge embedding by substituting Eq. (10):
+
+$$
+\mathbf { E } _ { v w } ^ { ( l + 1 ) } = \sigma \left( \Gamma _ { \mathrm { E } } \left( \mathbf { W } _ { 1 } ^ { ( l ) } \mathbf { E } _ { v w } ^ { ( l ) } \circ h \left( \mathbf { H } _ { v } ^ { ( l ) } , \mathbf { H } _ { w } ^ { ( l ) } \right) \right) \right) + \sigma \left( \mathbf { W } _ { 1 } ^ { ( l ) } \mathbf { E } _ { v w } ^ { ( l ) } \right)
+$$
+
+where $h ( \cdot , \cdot )$ is commutative $h ( \mathbf { X } , \mathbf { Y } ) = h ( \mathbf { Y } , \mathbf { X } )$ . Eq. (11) is supplementary to Eq. (9).
+
+Fig. 2 shows a schematic diagram of CIE layer, which is motivated from two perspectives. First, CIE is motivated by counterparts in CNN (Qiu et al., 2017; Tran et al., 2018) which decouple a 3D convolution into two 2D ones (e.g. a $3 \times 3 \times 3$ convolution can be decomposed to a $1 \times 3 \times 3$ and a $3 \times 1 \times 1$ convolutions). In this sense, the number of parameters can be significantly reduced. As shown in Fig. 2, node and edge embedding is first manipulated along the channel direction via a linear layer, then operated via $\Gamma _ { \mathrm { N } }$ and $\Gamma _ { \mathrm { E } }$ orthogonal to the channel direction. Instead of merging node and edge as a whole, CIE layer decouples it into two operations. Second, CIE is also motivated by the triumph of multi-head structure (e.g. graph attention (Velickovi ˇ c et al., 2018)), the key of ´ which is to conduct unit calculation multiple times and concatenate the results. Multi-head proved effective to further improve the performance since it is capable of capturing information at different scales or aspects. Traditional neural node-edge message passing algorithms (Gilmer et al., 2017; Li et al., 2016; Schutt et al., 2017) typically produce a unified transformation matrix for all the channels. ¨ On the other hand, in Eq. (9) (10) and (11), one can consider that the basic operator in each channel is repeated $d$ times in a multi-head fashion. The cross-channel information exchange, as signified in Eq. (9) (10) and (11), only happens before the channel-wise operator (i.e. weights $\mathbf { W } _ { i } ^ { ( l ) }$ as the crosschannel matrices). The main difference between CIE and traditional multi-head approaches e.g. (Velickovi ˇ c et al., 2018) is that CIE assumes the channel-independence of two embedded features ´ (node and edge), while traditional ones only take one input under head-independence assumption.
+
+![](images/75a7a84da844e6c9da9fc1c6c589263364677f200a8999ef3bddde0726ba292e.jpg)  
+Figure 3: A working example illustrating of our proposed Hungarian attention pipeline starting from similarity matrix. Sinkhorn algorithm solves similarity matrix into a doubly-stochastic matrix in a differentiable way. A discrete permutation matrix is further obtained via Hungarian algorithm. Our proposed Hungarian attention, taking the ground truth matching matrix into account, focuses on the “important” digits either labeled true or being mis-classified. The output matrix is obtained by attention pooling from doubly-stochastic matrix, where we compute a loss on it.
+
+# 3.3 HUNGARIAN ATTENTION MECHANISM
+
+For most graph matching algorithms, the output is in a continuous domain. Though there are some alternatives that deliver discrete solutions by adding more constraints or introducing numerical continuation (Zhou & De la Torre, 2012; Yu et al., 2018), the main line of methods is to incorporate a sampling procedure (e.g. winner-take-all and Hungarian). Among them, the Hungarian algorithm (Kuhn, 1955) is a widely adopted, for its efficiency and theoretical optimality.
+
+However, the Hungarian algorithm incurs a gap between training (loss function) and testing stages (Hungarian sampling). We compare the permutation loss (Wang et al., 2019) for concrete analysis:
+
+$$
+\mathcal { L } _ { \mathrm { C E } } = - \sum _ { i \in \mathcal { G } _ { 1 } , j \in \mathcal { G } _ { 2 } } \left( \mathbf { S } _ { i j } ^ { \mathrm { G } } \log \mathbf { S } _ { i j } + \left( 1 - \mathbf { S } _ { i j } ^ { \mathrm { G } } \right) \log \left( 1 - \mathbf { S } _ { i j } \right) \right)
+$$
+
+Note Eq. (12) is an element-wise version of binary cross-entropy. During training, this loss tends to drag the digits in S into binary format and is likely trapped to local optima. This is because this loss will back-propagate the gradients of training samples that are easy to learn in the early training stage. In later iterations, this loss is then hard to give up the digits that have become binary. In fact, the similar phenomenon is also investigated in the focal loss (Lin et al., 2017) in comparison to the traditional cross-entropy loss. During the testing stage, however, the Hungarian algorithm has no preference on the case if digits in S are close to $0 - 1$ or not. It binarizes S anyway. Therefore, the effort of Eq. (12) to drag S into binary might be meaningless.
+
+This issue is likely to be solved by integrating Hungarian algorithm during the training stage. Unfortunately, Hungarian algorithm is undifferentiable and its behavior is difficult to mimic with a differentiable counterpart. In this paper, instead of finding a continuous approximation of Hungarian algorithm, we treat it as a black box and dynamically generate network structure (sparse link)
+
+Table 1: Accuracy on Pascal VOC (best in bold). White and gray background refer to results on testing and training, respectively. Compared methods include GMN (Zanfir & Sminchisescu, 2018), GAT (Velickovi ˇ c et al., 2018), EPN (Gong & Cheng, 2019), PCA/PIA (Wang et al., 2019). ´   
+
+<table><tr><td>method</td><td>aero bike bird boat bottle bus car catchair cow table dog</td><td></td><td></td><td></td><td></td><td>horsembike</td><td></td><td></td><td></td><td>person plant sheep sofa train tv</td><td>Ave</td></tr><tr><td rowspan="5">GMN-D GMN-P</td><td>31.947.251.9 40.8 68.772.2 53.6 52.8 34.6 48.6</td><td></td><td></td><td></td><td>72.3 47.7</td><td>54.8 51.0</td><td>38.6</td><td>75.1</td><td>49.5</td><td>45.0 83.0 86.3</td><td>55.3</td></tr><tr><td>31.1 46.2 58.2 45.9 70.6 76.4 61.2 61.7 35.5 53.7</td><td></td><td></td><td></td><td>58.9 57.5</td><td>56.9</td><td>49.3</td><td>34.1 77.5</td><td>57.1</td><td>53.6 83.2 88.6</td><td>57.9</td></tr><tr><td>GAT-P 46.4 60.5 60.9 51.8 79.0</td><td></td><td>70.9 62.7 70.1</td><td>39.7 63.9</td><td>66.2 63.8</td><td>65.8</td><td>62.8</td><td>39.5</td><td>82.0 66.9</td><td>50.1 78.5 90.3</td><td>63.6</td></tr><tr><td>GAT-H 47.2 61.6 63.2 53.3</td><td>79.7</td><td>70.1 65.3 70.5 38.4 64.7</td><td></td><td>62.9 65.1</td><td>66.2</td><td>62.5</td><td>41.1</td><td>78.8 67.1</td><td>61.6 81.4 91.0</td><td>64.6</td></tr><tr><td>EPN-P 47.6 65.2 62.2 52.7</td><td>77.8</td><td>69.5 63.4 69.6</td><td>37.8 62.8</td><td>63.6 63.9</td><td>64.6</td><td>61.9</td><td>39.9</td><td>80.5 66.7</td><td>45.5 77.6 90.6</td><td>63.2</td></tr><tr><td rowspan="4">PIA-D PIA-P PCA-P</td><td>39.7 57.7 58.6 47.2</td><td>74.0</td><td>74.5 62.1 66.6 33.6 61.7</td><td>65.4</td><td>58.0 67.1</td><td>58.9</td><td>41.9</td><td>77.7</td><td>64.7</td><td>50.5 81.8 89.9</td><td>61.6</td></tr><tr><td>41.5 55.8 60.9 51.9</td><td>75.0</td><td>75.8 59.6 65.2 33.3 65.9</td><td></td><td>62.8 62.7</td><td>67.7</td><td>62.1</td><td>42.9</td><td>80.2 64.3</td><td>59.5 82.7 90.1</td><td>63.0</td></tr><tr><td>40.9 55.0 65.8 47.9</td><td>76.9</td><td>77.9 63.5 67.4</td><td>33.7 65.5</td><td>63.6 61.3</td><td>68.9</td><td>62.8</td><td>44.9</td><td>77.5 67.4</td><td>57.5 86.7 90.9</td><td>63.8</td></tr><tr><td>PCA-H 49.8 60.7 63.9 52.6 79.8 72.5 63.8 71.2 38.4 62.5</td><td></td><td></td><td></td><td>71.7 65.4</td><td>66.6</td><td>62.5</td><td>40.5</td><td>84.7 66.1</td><td>47.9 80.5 91.1</td><td>64.6</td></tr><tr><td rowspan="4">PCA+-P CIE2-P</td><td>46.6 61.0 62.3 53.9</td><td>78.2</td><td>72.5 64.4 70.539.0 63.5</td><td>74.8</td><td>65.2 65.0</td><td>61.6</td><td>40.8</td><td>83.2</td><td>67.1</td><td>50.5 79.6 91.6</td><td>64.6</td></tr><tr><td>50.9 65.5 68.057.081.0</td><td></td><td>75.970.373.441.1 66.7</td><td></td><td>53.2 68.3</td><td>68.4</td><td>63.5</td><td>45.3</td><td>84.8 69.7</td><td>57.2 79.8 91.6</td><td>66.9</td></tr><tr><td>CIE2-H 51.2 68.4 69.5 57.3 82.5 73.5 69.5 74.0 40.3 67.8 60.0</td><td></td><td></td><td></td><td></td><td>69.7 70.3</td><td>65.1</td><td>44.7</td><td>86.9 70.7</td><td>57.3 84.2 92.2</td><td>67.4</td></tr><tr><td>CIE-P 52.1 69.4 69.9 58.9</td><td></td><td>80.6 76.3 71.0 74.2 41.1 68.0</td><td></td><td>60.4 69.7</td><td>70.7</td><td>65.1</td><td>46.1</td><td>85.1 70.4</td><td>61.6 80.7 91.7</td><td>68.1</td></tr><tr><td>CIE-H</td><td>51.2 69.2 70.1 55.0 82.8 72.8 69.0 74.2 39.6 68.871.8 70.0</td><td></td><td></td><td></td><td></td><td>71.8 66.8</td><td>44.8</td><td>85.2</td><td>69.9</td><td>65.4 85.2 92.4</td><td>68.9</td></tr><tr><td>PCA-P</td><td>75.8 99.2 83.374.7 98.7 96.374.3 87.8 80.9 85.7 100.083.7 83.8</td><td></td><td></td><td></td><td></td><td></td><td>98.7</td><td>66.5</td><td>99.1 80.7</td><td></td><td></td></tr><tr><td>CIE-P</td><td></td><td></td><td></td><td>56.5 84.0 73.5 58.0 91.5 81.1 67.8 76.8 46.4 72.2 98.0 73.9 73.6</td><td></td><td></td><td>77.9</td><td>46.1</td><td>94.8 72.7</td><td>99.7 98.2 97.0 93.6 93.7 91.6</td><td>88.2</td></tr><tr><td></td><td></td><td></td><td></td><td>CIEt-H59.4 88.1 75.9 58.0 94.3 81.9 69.4 78.9 49.5 78.2 99.7 78.1 78.0</td><td></td><td></td><td>82.1</td><td>47.4</td><td>95.8 75.7</td><td>97.6 96.0 91.1</td><td>76.2 78.7</td></tr></table>
+
+according to its output. Concretely, the sparse link is calculated as:
+
+$$
+\mathbf { Z } = \mathrm { A t t e n } \left( \mathrm { H u n g a r i a n } ( \mathbf { S } ) , \mathbf { S } ^ { \mathrm { G } } \right) = \mathcal { P } \cup \mathcal { Q }
+$$
+
+where the attention mechanism Atten is fulfilled by an element-wise “logic OR” function. Fig. 3 shows an example of Hungarian attention procedure, and Eq. (13) highlights the most contributing digit locations: positive digits $\mathcal { P } = \mathbf { S }$ where Hungarian agrees with the ground-truth; negative digits $\bar { \mathcal { Q } } ^ { - } = \operatorname { H u n g a r i a n } ( \mathbf { S } ) \ \backslash \ \mathbf { S } ^ { \mathrm { G } }$ where Hungarian differs from ground-truth. While GT (positive digits) naturally points out the digits that must be considered, negative ones indicate the digits that most hinder the matching (most impeding ones among all mis-matchings). Thus we need only minimize the loss at $\mathbf { Z }$ , without considering the rest of digits. As we note that this mechanism only focuses on a small portion of the matching matrix which is analogous to producing hard attention, we term it Hungarian attention. Now that with the attention mask $\mathbf { Z }$ , the Hungarian attention loss becomes:
+
+$$
+\mathcal { H } _ { \mathrm { C E } } = - \sum _ { i \in \mathcal { G } _ { 1 } , j \in \mathcal { G } _ { 2 } } \mathbf { Z } _ { i j } \left( \mathbf { S } _ { i j } ^ { \mathrm { G } } \log \mathbf { S } _ { i j } + \left( 1 - \mathbf { S } _ { i j } ^ { \mathrm { G } } \right) \log \left( 1 - \mathbf { S } _ { i j } \right) \right)
+$$
+
+Note that Hungarian attention mechanism can also be applied to other loss functions once the matching score is calculated in an element-wise fashion. Our experiment also studies Hungarian attention loss when casted on focal loss (Lin et al., 2017) and a specifically designed margin loss.
+
+Finally we give a brief qualitative analysis on why Hungarian attention can improve matching loss. As discrete graph matching problem is actually built upon Delta function over permutation vertices (1 at ground-truth matching and 0 otherwise) (Yu et al., 2018), learning of graph matching with permutation loss is actually to approximate such functions with continuous counterparts. Unfortunately, more precise approximation to Delta function will result in higher non-smoothness, as discussed in Yu et al. (2018). For highly non-smooth objective, the network is more likely trapped at local optima. Hungarian attention, however, focuses on a small portion of the output locations, thus does not care about if most of the output digits are in $\{ 0 , 1 \}$ . In this sense, Hungarian attention allows moderate smoothness of the objective, thus optimizer with momentum is likely to avoid local optima.
+
+# 4 EXPERIMENTS
+
+Experiments are conducted on three benchmarks widely used for learning-based graph matching: CUB2011 dataset (Welinder et al., 2010) following the protocol in (Choy et al., 2016), Pascal VOC keypoint matching (Everingham et al., 2010; Bourdev & Malik, 2009) which is challenging and Willow Object Class dataset (Cho et al., 2013). Mean matching accuracy is adopted for evaluation:
+
+$$
+\operatorname { A c c } = \frac { 1 } { k } \sum _ { i \in \mathcal { G } _ { 1 } , j \in \mathcal { G } _ { 2 } } \operatorname { A N D } \left( \operatorname { H u n g a r i a n } ( \mathbf { S } ) _ { i j } , \mathbf { S } _ { i j } ^ { \mathrm { G } } \right)
+$$
+
+The algorithm abbreviation is in the form “X-Y”, where “X” and “Y” refer to the network structure (e.g. CIE) and loss function (e.g. Hungarian attention loss), respectively. Specifically, D, $\mathbf { P }$ and $\mathbf { H }$ correspond to displacement used in (Zanfir & Sminchisescu, 2018), permutation as adopted in (Wang et al., 2019) and Hungarian attention over permutation loss devised by this paper, respectively.
+
+Peer methods. We compare our method with the following selected counterparts: 1) HARG (Cho et al., 2013). This shallow learning method is based on hand-crafted feature and Structured SVM; 2) GMN (Zanfir & Sminchisescu, 2018). This is a seminal work incorporating graph matching and deep learning, and the solver is upon spectral matching (Leordeanu & Hebert, 2005). While the loss of this method is displacement loss, we also report the results of GMN by replacing its loss with permutation loss (GMN-P); 3) PIA/PCA (Wang et al., 2019). PCA and PIA correspond to the algorithms with and without cross-graph node embedding, respectively. Readers are referred to Wang et al. (2019) for more details; We further replace the GNN layer in our framework with: 4) GAT (Velickovi ˇ c et al., 2018). Graph attention network is an attention mechanism on graphs, ´ which reweights the embedding according to attention score; 5) EPN (Gong & Cheng, 2019). This method exploits multi-dimensional edge embedding and can further be applied on directed graphs. The edge dimension is set to 32 in our experiments. Finally, we term our network structure CIE for short. To investigate the capacity of edge embedding update, we also devise a version without edge embedding, in which connectivity is initialized as reciprocal of the edge length then normalized, rather than A. This model is called $\mathbf { P C A } +$ since the node embedding strategy follows PCA.
+
+Implementation details. As the node number of each graph might vary, we add dummy nodes for each graph pair such that the node number reaches the maximal graph size in a mini-batch in line with the protocol in (Wang et al., 2019). In either training or testing stages, these dummy nodes will not be updated or counted. The activation function in Eq. (9) (10) and (11) is set as Relu (Nair & Hinton, 2010) in all experiments. Specifically, the node and edge embedding is implemented by:
+
+$$
+\mathbf { H } _ { \cdot q } ^ { ( l + 1 ) } = \sigma \left( \left( \mathbf { A } \odot \left( \mathbf { W } _ { 1 } ^ { ( l ) } \mathbf { E } ^ { ( l ) } \right) _ { \cdot q } \right) \left( \mathbf { W } _ { 2 } ^ { ( l ) } \mathbf { H } ^ { ( l ) } \right) _ { \cdot q } \right) + \sigma \left( \left( \mathbf { W } _ { 0 } ^ { ( l ) } \mathbf { H } ^ { ( l ) } \right) _ { \cdot q } \right)
+$$
+
+$$
+\mathbf { E } _ { \cdot q } ^ { ( l + 1 ) } = \sigma \left( \left| \left( \mathbf { W } _ { 0 } ^ { ( l ) } \mathbf { H } ^ { ( l ) } \right) _ { \cdot q } \Theta \left( \mathbf { W } _ { 0 } ^ { ( l ) } \mathbf { H } ^ { ( l ) } \right) _ { \cdot q } ^ { \top } \right| \odot \mathbf { E } _ { \cdot q } ^ { ( l ) } \right) + \sigma \left( \left( \mathbf { W } _ { 1 } ^ { ( l ) } \mathbf { E } ^ { ( l ) } \right) _ { \cdot q } \right)
+$$
+
+where $\odot$ and $\ominus$ refer to element-wise product and pairwise difference, respectively. $\mathbf { H } _ { \cdot q }$ is the qth channel of $\mathbf { H }$ . In $\mathbf { C I } \mathbf { E } _ { 1 }$ setting, only node-level merging Eq. (16a) is considered and the edge feature is updated as Eq. (10). In $\mathbf { { C I } } \mathbf { { E } } _ { 2 }$ setting, we also replace the edge update Eq. (11) with Eq. (16b). Note edge embedding is used in both $\mathbf { C I } \mathbf { E } _ { 1 }$ and $\mathbf { { C I } } \mathbf { { E } } _ { 2 }$ and note PCA-H can be regarded as the pure node embedding version of our approach. The edge feature is initiated as reciprocal of the edge length. For training, batch size is set to 8. We employ SGD optimizer (Bottou, 2010) with momentum 0.9. Two CIE layers are stacked after VGG16.
+
+CUB2011 test CUB2011 consists of 11,788 images from 200 kinds of birds with 15 annotated parts. We randomly sample image pairs from the dataset following the implementation released by Choy et al. (2016). We do not use the pre-alignment of poses during testing, because their alignment result is not publicly available. Therefore, there exists significant variation in pose, articulation and appearance across images, in both training and testing phase. Images are cropped around bounding box and resized to $2 5 6 \times 2 5 6$ before fed into the network. Instead of evaluating the performance in a retrieval fashion (Zanfir & Sminchisescu, 2018), we directly evaluate the matching accuracy since the semantic key-points are pre-given. We test two settings: 1) intra-class. During training, we randomly sample images, with each pair sampled from the same category (out of 200 bird categories). In testing, 2,000 image pairs (100 pairs for each category) are sampled; 2) cross-class. We analogously sample image pairs without considering the category information and 5,000 randomly sampled image pairs are employed for testing. While the first setting is for a class-aware situation, the second setting is considered for testing the class-agnostic case. Results are shown in Table 3.
+
+We see our method surpasses all the competing methods in terms of matching accuracy. Besides, almost all the selected algorithms can reach over $9 0 \%$ accuracy, indicating that this dataset contains mostly “easy” learning samples. In this case, the Hungarian attention can slightly improve the performance since easy gradients agree with descending trend of the loss on the whole dataset.
+
+Pascal VOC test The Pascal VOC dataset with Key-point annotation (Bourdev & Malik, 2009) contains 7,020 training images and 1,682 testing images with 20 classes in total. To the best of our knowledge, this is the largest and most challenging dataset for graph matching in computer vision. Each image is cropped around its object bounding box and is resized to $2 5 6 \times 2 5 6$ . The node
+
+![](images/c8d9b9e1f995a1cc878942ca464f0eb90ffb13b074da62ef704af2069adf88e1.jpg)  
+(a) Accuracy/loss vs. training epoch.
+
+![](images/19ed5da35d238352f86d7bbe1fe6919ac6415510c5a713062e3e7e3a9dd22c1d.jpg)  
+(b) Ablation study by Hungarian attention.
+
+Figure 4: Performance study on Pascal VOC. Note in (a) the loss is calculated on all matching digits for both $\mathrm { C I E } _ { 1 }$ -P and $\mathrm { C I E } _ { 1 }$ -H. Note around 10th epoch, the accuracy of $\mathrm { C I E } _ { 1 }$ -P almost reaches the highest, but the loss keeps descending until 30th epoch. This indicates that in most of the latter epochs, P-loss performs “meaningless” back-propagation to drag the output to binary. H-loss, by accommodating smoothness, can emphasize most contributing digits and achieves higher accuracy. size of this dataset varies from 6 to 23 and there are various scale, pose and illumination perturbations. Experimental results are summarized in Table 1. We see in either setting, CIE significantly outperforms all peer algorithms. Specifically, $\mathrm { C I E } _ { 1 } .$ -H achieves the best performance and has $0 . 8 \dot { \% }$ improvement w.r.t. average accuracy over $\mathrm { C I E } _ { 1 }$ -P. For each class, $\mathrm { C I E } _ { 1 }$ -H and $\mathrm { C I E } _ { 1 }$ -P carve up most of the top performance. We also note that $\mathrm { C I E } _ { 1 }$ -H has a close performance on “table” compared with GMN-D. Since P-loss is naturally not as robust as D-loss on symmetric objects, P-loss showed great degradation over D-loss on “table” (as discussed in (Wang et al., 2019)). However, with the help of Hungarian link, H-loss can maintain relatively high accuracy despite natural flaw of P-loss. This observation indicates that H-loss can focus on “difficult” examples. We also note that $\mathrm { C I E } _ { 1 }$ produces better results against $\mathrm { C I E } _ { 2 }$ , which implies that updating edge embedding is less effective compared to a singleton node updating strategy. We can also see from Table 1 that PCA-P has much higher performance on training samples than $\mathrm { C I E } _ { 1 }$ -H, which is to the contrary of the result on testing samples. This might indicate that PCA-P overfits the training samples.
+
+Accuracy/loss vs. training epoch. We further show the typical training behavior of P-loss and Hloss on Pascal VOC dataset in Fig. 4. 30 epochs are involved in a whole training process. Accuracy is evaluated on testing samples after each epoch while loss is the average loss value within each epoch. In the early training stage, the loss of $\mathrm { C I E } _ { 1 }$ -P immediately drops. On the other hand, $\mathrm { C I E } _ { 1 }$ -H hesitates for several epochs to find the most effective descending direction. On the late stage, we observe that even though P-loss (Eq. (12)) calculates much more digits than H-loss (Eq. (14)), the loss values are opposite. This counter-intuitive fact strongly indicates that P-loss makes meaningless effort, which is not helpful to improve the performance, at late stage. The proposed H-loss, on the other hand, is capable of avoiding easy but meaningless gradients.
+
+Effect of Hungarian attention mechanism. We also conduct experiments to show the improvement of Hungarian attention over several loss functions (with and without Hungarian attention): Hungarian attention is applied on Focal loss (Focal) (Lin et al., 2017) as:
+
+$$
+\mathcal { L } _ { \mathrm { f o c a l } } = \left\{ \begin{array} { l l } { - \alpha \mathbf { Z } _ { i j } ( 1 - \mathbf { S } _ { i j } ) ^ { \gamma } \log ( \mathbf { S } _ { i j } ) , } & { \mathbf { S } _ { i j } ^ { \mathrm { G } } = 1 } \\ { - ( 1 - \alpha ) \mathbf { Z } _ { i j } \mathbf { S } _ { i j } ^ { \gamma } \log ( 1 - \mathbf { S } _ { i j } ) , } & { \mathbf { S } _ { i j } ^ { \mathrm { G } } = 0 } \end{array} \right.
+$$
+
+where controlling parameters $\alpha = 0 . 7 5$ and $\gamma = 2$ in our setting. We also design a margin loss (Margin) with Hungarian attention under a max-margin rule. Note we insert the Hungarian attention mask $\mathbf { Z } _ { i j }$ into Eq. (17) and Eq. (18) based on the vanilla forms.
+
+$$
+\mathcal { L } _ { \mathrm { m a r g i n } } = \left\{ \begin{array} { l l } { \mathbf { Z } _ { i j } \times \operatorname* { m a x } ( 1 - \mathbf { S } _ { i j } - \beta , 0 ) , } & { \mathbf { S } _ { i j } ^ { \mathbf { G } } = 1 } \\ { \mathbf { Z } _ { i j } \times \operatorname* { m a x } ( \mathbf { S } _ { i j } - \beta , 0 ) , } & { \mathbf { S } _ { i j } ^ { \mathbf { G } } = 0 } \end{array} \right.
+$$
+
+where we set the margin value $\beta \ : = \ : 0 . 2$ . Loss of Eq. (18) is valid because after Softmax and Sinkhorn operations, $\mathbf { S } _ { i j } ~ \in ~ [ 0 , 1 ]$ . We also show permutation loss (Perm) (Wang et al., 2019). Result can be found in Fig. 4 (b) whereby the average accuracy on Pascal VOC is reported. All the settings are under $\mathrm { C I E } _ { 1 }$ . For either loss, the proposed Hungarian attention can further enhance the accuracy, which is further visualized by a pair of matching results under P-loss and H-loss in Fig. 5.
+
+![](images/b40a9251d7c8edb6df2b7b8344078fcf061652721ebd0223b72030de79b33362.jpg)  
+Figure 5: Visualization of a matching result: 10 key points in each image with 7 and 8 correct matchings dispalyed, respectively. Different colors across images indicate node correspondence. The larger size of dot, the larger is the predicted value $\mathbf { S } _ { i j }$ . (a) The reference image. (b) Result on the target image from $\mathrm { C I E } _ { 1 }$ -P. (c) Result on the target image from $\mathrm { C I E } _ { 1 }$ -H. We see though H-loss i.e. Hungarian attention loss outputs smaller predicted values, it delivers a more accurate matching.
+
+Table 2: Accuracy $( \% )$ on Willow Object.   
+
+<table><tr><td>method</td><td>face</td><td>mbike</td><td>car</td><td>duck</td><td>wbottle</td></tr><tr><td>HARG</td><td>91.2</td><td>44.4</td><td>58.4</td><td>55.2</td><td>66.6</td></tr><tr><td>GMN-V</td><td>98.1</td><td>65.0</td><td>72.9</td><td>74.3</td><td>70.5</td></tr><tr><td>GMN-W</td><td>99.3</td><td>71.4</td><td>74.3</td><td>82.8</td><td>76.7</td></tr><tr><td>PCA-V</td><td>100.0</td><td>69.8</td><td>78.6</td><td>82.4</td><td>95.1</td></tr><tr><td>PCA-W</td><td>100.0</td><td>76.7</td><td>84.0</td><td>93.5</td><td>96.9</td></tr><tr><td>CIE-V</td><td>99.9</td><td>71.5</td><td>75.4</td><td>73.2</td><td>97.6</td></tr><tr><td>CIE-W</td><td>100.0</td><td>90.0</td><td>82.2</td><td>81.2</td><td>97.6</td></tr></table>
+
+Table 3: Accuracy $( \% )$ on CUB.   
+
+<table><tr><td>method</td><td>intra-class</td><td>cross-class</td></tr><tr><td>GMN-D</td><td>89.6</td><td>89.9</td></tr><tr><td>GMN-P</td><td>90.4</td><td>90.8</td></tr><tr><td>GAT-P</td><td>93.2</td><td>93.4</td></tr><tr><td>PCA-P</td><td>92.9</td><td>93.5</td></tr><tr><td>PCA-H</td><td>93.7</td><td>93.5</td></tr><tr><td>CIE-P</td><td>94.1</td><td>93.8</td></tr><tr><td>CIE-H</td><td>94.4</td><td>94.2</td></tr></table>
+
+Willow Object Class test We test the transfer ability on Willow Object Class (Cho et al., 2013). It contains 256 images3 of 5 categories in total, with three categories (face, duck and winebottle) collected from Caltech-256 and resting two (car and motorbike) from Pascal VOC 2007. This dataset is considered to have bias compared with Pascal VOC since images in the same category are with relatively fixed pose and background is much cleaner. We crop the object inside its bounding box and resize it to $2 5 6 \times 2 5 6$ as CNN input. While HARG is trained from scratch following the protocol in (Cho et al., 2013), all the resting counterparts are either directly pre-trained from the previous section or fine-tuned upon the pre-trained models. We term the method “X-V” or “X-W” to indicate pre-trained model on Pascal VOC or fine-tuned on Willow, respectively. CIE refers to $\mathrm { C I E } _ { 1 }$ -H for short. Results in Table 2 suggest that our method is competitive to state-of-the-art.
+
+# 5 CONCLUSION
+
+We have presented a novel and effective approach for learning based graph matching. On one hand, the novelty of our method partially lies in the development of the Hungarian attention, which intrinsically adapts the matching problem. It is further observed from the experiments that Hungarian attention can improve several matching-oriented loss functions, which might bring about potential for a series of combinatorial problems. On the other hand, we also devise the channel independent embedding (CIE) technique for deep graph matching, which decouples the basic merging operations and is shown robust in learning effective graph representation. Extensive experimental results on multiple matching benchmarks show the leading performance of our solver, and highlight the orthogonal contribution of the two proposed components on top of existing techniques.
+
+# ACKNOWLEDGMENTS
+
+Tianshu Yu and Baoxin Li were supported in part by a grant from ONR. Any opinions expressed in this material are those of the authors and do not necessarily reflect the views of ONR. Runzhong Wang and Junchi Yan were supported in part by NSFC 61972250 and U19B2035.
+
+# REFERENCES
+
+Kfir Aberman, Jing Liao, Mingyi Shi, Dani Lischinski, Baoquan Chen, and Daniel Cohen-Or. Neural best-buddies: Sparse cross-domain correspondence. SIGGRAPH, 2018.
+
+Ryan Prescott Adams and Richard S Zemel. Ranking via sinkhorn propagation. arXiv:1106.1925, 2011.
+
+Florian Bernard, Christian Theobalt, and Michael Moeller. Ds\*: Tighter lifting-free convex relaxations for quadratic matching problems. In CVPR, 2018.
+
+Leon Bottou. Large-scale machine learning with stochastic gradient descent. In ´ COMPSTAT. 2010.
+
+Lubomir Bourdev and Jitendra Malik. Poselets: Body part detectors trained using 3d human pose annotations. In ICCV, 2009.
+
+Jane Bromley, Isabelle Guyon, Yann LeCun, Eduard Sackinger, and Roopak Shah. Signature verifi- ¨ cation using a “siamese” time delay neural network. In NIPS, 1994.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. In ICLR, 2014.
+
+Tiberio S Caetano, Julian J McAuley, Li Cheng, Quoc V Le, and Alex J Smola. Learning graph ´ matching. PAMI, 31(6):1048–1058, 2009.
+
+Hongyun Cai, Vincent W Zheng, and Kevin Chen-Chuan Chang. A comprehensive survey of graph embedding: Problems, techniques, and applications. TKDE, 30(9):1616–1637, 2018.
+
+Pengfei Chen, Weiwen Liu, Chang-Yu Hsieh, Guangyong Chen, and Shengyu Zhang. Utilizing edge features in graph neural networks via variational information maximization. arXiv preprint arXiv:1906.05488, 2019.
+
+Kyunghyun Cho, Bart Van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014.
+
+Minsu Cho, Jungmin Lee, and Kyoung Mu Lee. Reweighted random walks for graph matching. In ECCV, 2010.
+
+Minsu Cho, Karteek Alahari, and Jean Ponce. Learning graphs to match. In CVPR, 2013.
+
+Christopher B Choy, JunYoung Gwak, Silvio Savarese, and Manmohan Chandraker. Universal correspondence network. In NIPS, 2016.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In NIPS, 2016.
+
+Boris Delaunay et al. Sur la sphere vide. Izv. Akad. Nauk SSSR, Otdelenie Matematicheskii i Estestvennyka Nauk, 7(793-800):1–2, 1934.
+
+Alexey Dosovitskiy, Philipp Fischer, Eddy Ilg, Philip Hausser, Caner Hazirbas, Vladimir Golkov, Patrick Van Der Smagt, Daniel Cremers, and Thomas Brox. Flownet: Learning optical flow with convolutional networks. In ICCV, 2015.
+
+Patrick Emami and Sanjay Ranka. Learning permutations with sinkhorn policy gradient. arXiv:1805.07010, 2018.
+
+Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. IJCV, 88(2):303–338, 2010.
+
+Paolo Frasconi, Marco Gori, and Alessandro Sperduti. A general framework for adaptive processing of data structures. TNN, 9(5):768–786, 1998.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In ICML, 2017.
+
+Liyu Gong and Qiang Cheng. Exploiting edge features for graph neural networks. In CVPR, 2019.
+
+Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In IJCNN, 2005.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NIPS, 2017.
+
+Juris Hartmanis. Computers and intractability: a guide to the theory of np-completeness (michael r. garey and david s. johnson). Siam Review, 24(1):90, 1982.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.
+
+Harold W Kuhn. The hungarian method for the assignment problem. Naval research logistics quarterly, 2(1-2):83–97, 1955.
+
+Eugene L Lawler. The quadratic assignment problem. Management science, 9(4):586–599, 1963.
+
+Marius Leordeanu and Martial Hebert. A spectral technique for correspondence problems using pairwise constraints. In ICCV, 2005.
+
+Yijun Li, Chen Fang, Jimei Yang, Zhaowen Wang, Xin Lu, and Ming-Hsuan Yang. Universal style transfer via feature transforms. In NIPS, 2017.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In ICLR, 2016.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In ICCV, 2017.
+
+Eliane Maria Loiola, Nair Maria Maia de Abreu, Paulo Oswaldo Boaventura-Netto, Peter Hahn, and Tania Querido. A survey for the quadratic assignment problem. European journal of operational research, 176(2):657–690, 2007.
+
+Gonzalo Mena, David Belanger, Gonzalo Munoz, and Jasper Snoek. Sinkhorn networks: Using ˜ optimal transport techniques to learn permutations. NIPS Workshop in Optimal Transport and Machine Learning, 2017.
+
+Anton Milan, Seyed Hamid Rezatofighi, Ravi Garg, Anthony R. Dick, and Ian D. Reid. Data-driven approximations to np-hard problems. In AAAI, 2017.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010.
+
+Giorgio Patrini, Marcello Carioni, Patrick Forre, Samarth Bhargav, Max Welling, Rianne van den Berg, Tim Genewein, and Frank Nielsen. Sinkhorn autoencoders. arXiv:1810.01118, 2018.
+
+Zhaofan Qiu, Ting Yao, and Tao Mei. Learning spatio-temporal representation with pseudo-3d residual networks. In ICCV, 2017.
+
+Zhe Ren, Junchi Yan, Bingbing Ni, Bin Liu, Xiaokang Yang, and Hongyuan Zha. Unsupervised deep learning for optical flow estimation. In AAAI, 2017.
+
+Rodrigo Santa Cruz, Basura Fernando, Anoop Cherian, and Stephen Gould. Visual permutation learning. TPAMI, 2018.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. TNN, 20(1):61–80, 2008.
+
+Kristof T Schutt, Farhad Arbabzadah, Stefan Chmiela, Klaus R M ¨ uller, and Alexandre Tkatchenko. ¨ Quantum-chemical insights from deep tensor neural networks. Nature communications, 8:13890, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Richard Sinkhorn. A relationship between arbitrary positive matrices and doubly stochastic matrices. AoMS, 1964.
+
+Alessandro Sperduti and Antonina Starita. Supervised neural networks for the classification of structures. TNN, 8(3):714–735, 1997.
+
+Du Tran, Heng Wang, Lorenzo Torresani, Jamie Ray, Yann LeCun, and Manohar Paluri. A closer look at spatiotemporal convolutions for action recognition. In CVPR, 2018.
+
+Ioannis Tsochantaridis, Thorsten Joachims, Thomas Hofmann, and Yasemin Altun. Large margin methods for structured and interdependent output variables. JMLR, 6(Sep):1453–1484, 2005.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li ´ o, and Yoshua \` Bengio. Graph attention networks. In ICLR, 2018.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In NIPS, 2015.
+
+Runzhong Wang, Junchi Yan, and Xiaokang Yang. Learning combinatorial embedding networks for deep graph matching. In ICCV, 2019.
+
+P. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010.
+
+Hongteng Xu, Dixin Luo, and Lawrence Carin. Gromov-wasserstein learning for graph matching and node embedding. In ICML, 2019.
+
+Junchi Yan, Chao Zhang, Hongyuan Zha, Wei Liu, Xiaokang Yang, and Stephen M Chu. Discrete hyper-graph matching. In CVPR, 2015.
+
+Tianshu Yu, Junchi Yan, Yilin Wang, Wei Liu, and Baoxin Li. Generalizing graph matching beyond quadratic assignment model. In NIPS, 2018.
+
+Andrei Zanfir and Cristian Sminchisescu. Deep learning of graph matching. In CVPR, 2018.
+
+Zhen Zhang and Wee Sun Lee. Deep graphical feature learning for the feature matching problem. In ICCV, 2019.
+
+Feng Zhou and Fernando De la Torre. Factorized graph matching. In CVPR, 2012.
+
+# A APPENDIX
+
+# A.1 SYNTHETIC TEST
+
+Synthetic graphs are generated for training and testing following the protocol in (Cho et al., 2010). Specifically, $K _ { p t }$ keypoints are generated for a pair of graphs with a 1024-dimensional random feature for each node, which is sampled from uniform distribution $\mathcal { U } ( - 1 , 1 )$ . Disturbance is also applied to graph pairs including: Gaussian node feature noise from $\mathcal { N } ( 0 , \sigma _ { f t } ^ { 2 } )$ ; random affine transformation $\left[ \begin{array} { c c c } { s \cos \theta } & { - s \sin \theta } & { t _ { x } } \\ { s \sin \theta } & { s \cos \theta } & { t _ { y } } \\ { 0 } & { 0 } & { 1 } \end{array} \right] \mathrm { w i t h } s \sim \mathcal { U } ( 0 . 8 , 1 . 2 ) , \theta \sim \mathcal { U } ( - 6 0 , 6 0 ) , t _ { x } , t _ { y } \sim \mathcal { U } ( - 1 0 , 1 0 )$ ) followed by Gaussian coordinate position noise $\mathcal { N } ( 0 , \sigma _ { c o } ^ { 2 } )$ . By default we assign $K _ { p t } = 2 5 , \sigma _ { f t } =$ $1 . 5 , \sigma _ { c o } = 5$ . Two graphs share the same structure. We generate 10 random distributions for each test. Results are shown in Fig. 6. The performance of PCA and CIE is reported. We see our method significantly outperformed PCA. It can further be noticed that Hungarian attention can help to achieve an even higher accuracy. Readers are referred to Wang et al. (2019) for some other results on synthetic test.
+
+However, we also notice that the way to generate synthetic graphs is much different from the distribution of real-world data. For real-world data, on one hand, there is strong correlation on the neighboring node features. This is the reason why the message passing from nearby node features works. However, the features of synthetic data are randomly generated and there is no correlation between neighboring node features. Therefore, message passing mechanism is not very effective to reveal the relation or pattern among local nodes for synthetic data. On the other hand, features of real-world data typically lie on a manifold embedded in high dimensional space, hence is low dimensional. However, randomly generated features will span the whole space and show no patterns.
+
+![](images/0bdc47cf84fa82623f197589bb25d188aadce99a4aae6bb0f564975f37535b81.jpg)  
+Figure 6: Results on synthetic test where two different loss functions are compared in ablative study.
+
+Taking into account the aforementioned factors, we believe there is a demand for a novel strategy to generate more reasonable synthetic data. This can be one of the future works.
+
+# A.2 COMPARISON OF PASCAL VOC AND WILLOW
+
+As we claim that Willow dataset is biased compared with Pascal VOC dataset, we qualitatively show some randomly selected examples in Fig. 7. We select several images with the same class “car” from both datasets. We also choose images with “bird” from Pascal VOC and “duck” from Willow since they somewhat share similar semantic information. We see in either case, Pascal VOC contains more variation and degradation compared with Willow in terms of pose, scale, appearance, etc. In general, Willow dataset is easier for algorithms to learn. While there is a significant performance gap of PCA over these two datasets, the performance of CIE on Willow without fine-tune (Table 2) is consistent to the performance on Pascal VOC (Table 1). As such, we infer the performance degradation of CIE on “duck” in Willow test (Table 2) is due to such bias. The pre-trained CIE on Pascal VOC tends to produce more stable and higher average accuracy on all types of images, rather than focusing on “easy-to-learn” samples by PCA. This is a different learning strategy from PCA.
+
+![](images/18cf48c3d41aebd319e375e71f705827d516d774adb2765e95eed33d4761c7f8.jpg)  
+Figure 7: Image examples from Pascal VOC and Willow.

parse/train/rJgBd2NYPH/rJgBd2NYPH_content_list.json

@@ -0,0 +1,1915 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING DEEP GRAPH MATCHING VIA CHANNELINDEPENDENT EMBEDDING AND HUNGARIAN ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tianshu $\\mathbf { V } \\mathbf { u } ^ { \\dagger }$ , Runzhong Wang‡, Junchi Yan‡, Baoxin Li† ",
+        "bbox": [
+            184,
+            194,
+            578,
+            210
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "†Arizona State University   \n‡Shanghai Jiao Tong University   \n{tianshuy,baoxin.li}@asu.edu   \n{runzhong.wang,yanjunchi}@sjtu.edu.cn ",
+        "bbox": [
+            184,
+            212,
+            544,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            304,
+            544,
+            319
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph matching aims to establishing node-wise correspondence between two graphs, which is a classic combinatorial problem and in general NP-complete. Until very recently, deep graph matching methods start to resort to deep networks to achieve unprecedented matching accuracy. Along this direction, this paper makes two complementary contributions which can also be reused as plugin in existing works: i) a novel node and edge embedding strategy which stimulates the multihead strategy in attention models and allows the information in each channel to be merged independently. In contrast, only node embedding is accounted in previous works; ii) a general masking mechanism over the loss function is devised to improve the smoothness of objective learning for graph matching. Using Hungarian algorithm, it dynamically constructs a structured and sparsely connected layer, taking into account the most contributing matching pairs as hard attention. Our approach performs competitively, and can also improve state-of-the-art methods as plugin, regarding with matching accuracy on three public benchmarks. ",
+        "bbox": [
+            233,
+            333,
+            764,
+            527
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            336,
+            565
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Without loss of generality, we consider the bijection problem for graph matching: given graph $\\mathcal { G } _ { 1 }$ and $\\mathcal { G } _ { 2 }$ of equal size $n$ , graph matching seeks to find the one-vs-one node correspondence1: ",
+        "bbox": [
+            173,
+            580,
+            820,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b795910bcda9528966f2033a71b93865cd6e688bd4c48c6af27e17196b2db75.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\mathbf { x } } \\mathbf { x } ^ { \\top } \\mathbf { K } \\mathbf { x } \\qquad \\mathrm { s . t . } \\quad \\mathbf { P } \\mathbf { x } = \\mathbf { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            611,
+            602,
+            635
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { x } = \\mathrm { v e c } ( \\mathbf { X } ) \\in \\{ 0 , 1 \\} ^ { n ^ { 2 } }$ which is the column-wise vectorized form of the permutation ma$\\mathbf { X }$ $\\mathbf { \\bar { K } } \\in \\mathcal { R } _ { + } ^ { n ^ { 2 } \\times n ^ { 2 } }$ is the so-called affinity matrix2, respectively. Note $\\mathbf { P }$ is a selection matrix encoding the one-to-one correspondence constraint. This problem is called Lawler’s QAP (Lawler, 1963) and has attracted enormous attention for its generally NP-complete (Hartmanis, 1982) challenge, as well as a wide spectrum of applications in computer vision, graphics, machine learning and operational research etc. In particular, Koopmans-Beckmann’s QAP (Loiola et al., 2007) with objective $\\operatorname { t r } ( \\mathbf { X } ^ { \\top } \\mathbf { F } _ { 1 } \\mathbf { X } \\mathbf { F } _ { 2 } )$ is a special case of Eq. (1), which can be converted to Lawler’s QAP by $\\mathbf { K } = \\mathbf { F } _ { 2 } \\otimes \\mathbf { F } _ { 1 }$ and $\\mathbf { F } _ { i }$ refers to the weighted adjacency matrix. A series of solvers haven been developed to solve graph matching problem (Leordeanu & Hebert, 2005; Cho et al., 2010; Bernard et al., 2018; Yan et al., 2015; Yu et al., 2018). All these methods are based on deterministic optimization, which are conditioned with pre-defined affinity matrix and no learning paradigm is involved. This fact greatly limits the performance and broad application w.r.t. different problem settings considering its NP-hard nature. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            827
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, the seminal work namely deep graph matching (DGM) (Zanfir & Sminchisescu, 2018) is proposed to exploit the high capacity of deep networks for graph matching, which achieves stateof-the-art performance. This is in contrast to some early works which incorporate learning strategy separately in local stages (Caetano et al., 2009; Cho et al., 2013). On the other hand, Graph Convolutional Networks (GCN) (Kipf & Welling, 2017) brings about new capability on tasks over graph-like data, as it naturally integrates the intrinsic graph structure in a general updating rule: ",
+        "bbox": [
+            174,
+            833,
+            825,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/86414d85ee2b3686f4946828aafda32288b5f16cc47087388b0bf6203c03bd14.jpg",
+        "text": "$$\n\\mathbf { H } ^ { ( l + 1 ) } = \\sigma \\left( \\hat { \\mathbf { A } } \\mathbf { H } ^ { ( l ) } \\mathbf { W } ^ { ( l ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            152,
+            591,
+            179
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { \\bf A }$ is the normalized connectivity matrix. $\\mathbf { H } ^ { ( l ) }$ and $\\mathbf { W } ^ { ( l ) }$ are the features and weights at layer $l$ , respectively. Node embedding is updated by aggregation from 1-neighboring nodes, which is akin to the convolution operator in CNN. By taking advantages of both DGM and GCN, Wang et al. (2019) and Zhang & Lee (2019) incorporate permutation loss instead of displacement loss in (Zanfir & Sminchisescu, 2018), with notable improvement across both synthetic and real data. ",
+        "bbox": [
+            174,
+            186,
+            823,
+            258
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that Eq. (1) involves both node and edge information, which exactly correspond to the diagonal and off-diagonal elements in $\\mathbf { K }$ , respectively. Edges can carry informative multi-dimensional attributes (namely weights) which are fundamental to graph matching. However existing embedding based graph matching methods (Wang et al., 2019; Xu et al., 2019) are focused on the explicit modeling of node level features, whereby the edges are only used as topological node connection for message passing in GCN. Besides, edge attributes are neither well modeled in the embedding-free model (Zanfir & Sminchisescu, 2018) since the edge information is derived from the concatenation of node features. To our best knowledge, there is no deep graph matching method explicitly incorporating edge attributes. In contrast, edge attributes e.g. length and orientation are widely used in traditional graph matching models (Cho et al., 2010; Yan et al., 2015; Yu et al., 2018) for constructing the affinity matrix K. Such a gap shall be filled in the deep graph matching pipeline. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            419
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another important consideration refers to the design of loss function. There are mainly two forms in existing deep graph matching works: i) displacement loss (Zanfir & Sminchisescu, 2018) similar to the use in optical flow estimation (Ren et al., 2017); ii) the so-called permutation loss (Wang et al., 2019) involving iterative Sinkhorn procedure followed by a cross-entropy loss. Results in (Wang et al., 2019) show the latter is an effective improvement against the former regression based loss. However, we argue that the continuous Sinkhorn procedure (in training stage) is yet an unnatural approximation to Hungarian sampling (in testing stage) for discretization. If the network is equipped with a continuous loss function (e.g. cross-entropy), we argue that the training process will make a great “meaningless effort” to enforce some network output digits of the final matching matrix into binary and neglect the resting digits which might have notable impact on accuracy. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper strikes an endeavor on the above two gaps and makes the following main contributions: ",
+        "bbox": [
+            174,
+            571,
+            816,
+            585
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "i) We propose a new approach for edge embedding via channel-wise operation, namely channelindependent embedding (CIE). The hope is to effectively explore the edge attribute and simulate the multi-head strategy in attention models (Velickovi ˇ c et al., 2018) by decoupling the calculations ´ parallel and orthogonal to channel direction. In fact, edge attribute information has not been considered in existing embedding based graph matching methods (Wang et al., 2019; Xu et al., 2019). ",
+        "bbox": [
+            174,
+            593,
+            823,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ii) We devise a new mechanism to adjust the loss function based on the Hungarian method which is widely used for linear assignment problem, as termed by Hungarian attention. It resorts to dynamically generating sparse matching mask according to Hungarian sampling during training, rather than approximating Hungarian sampling with a differentiable function. As such, the Hungarian attention introduces higher smoothness against traditional loss functions to ease the training. ",
+        "bbox": [
+            174,
+            669,
+            823,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "iii) The empirical results on three public benchmarks shows that the two proposed techniques are orthogonal and beneficial to existing techniques. Specifically, on the one hand, our CIE module can effectively boost the accuracy by exploring the edge attributes which otherwise are not considered in state-of-the-art deep graph matching methods; on the other hand, our Hungarian attention mechanism also shows generality and it is complementary to existing graph matching loss. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            815
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            349,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph embedding. To handle graph-like data, early works adopt recursive neural networks (RNNs) treating input as directed acyclic graphs (Sperduti & Starita, 1997; Frasconi et al., 1998). Gori et al. (2005); Scarselli et al. (2008) generalized early models to graph neural networks (GNNs) so as to be directly applied on cyclic, directed or undirected graphs. Li et al. (2016) further improved this line of model by replacing standard RNNs with gated recurrent units (GRUs) (Cho et al., 2013). Inspired by the great success of convolutional neural networks (CNNs) (Simonyan & Zisserman, 2014; He et al., 2016), researchers have made tremendous effort on applying convolution operator to graphs (Bruna et al., 2014; Kipf & Welling, 2017; Gong & Cheng, 2019). Bruna et al. (2014) defined a convolution operator in Fourier domain which is obtained by performing eigen-decomposition on graph Laplacian. However, such convolution will affect the whole spatial domain once taking inverse Fourier transformation. This method was improved by Chebyshev expansion to approximate filters (Defferrard et al., 2016). Kipf & Welling (2017) propose a graph convolutional operator over 1-neighbor nodes derived from graph spectral theory, which is invariant to node permutation and achieved significant performance on semi-supervised learning tasks. There are series of works following GCN, such as GraphSAGE (Hamilton et al., 2017), GAT (Velickovi ˇ c et al., 2018) and ´ MPNN (Gilmer et al., 2017). Refer to (Cai et al., 2018) for a more comprehensive survey. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the aforementioned models are focused on learning node state/embedding, a parallel line of work seek to learn edge embedding by taking into account the information carried on edges (Li et al., 2016; Gilmer et al., 2017; Gong & Cheng, 2019). Edges are intrinsic portion of graphs, and thus edge embedding can be essential to reveal the relation among nodes. Gilmer et al. (2017) introduce a general embedding network incorporating edge information and node-edge information merging, and a serious of works fall into this framework e.g. Gated GNN (Li et al., 2016), Tensor GNN (Schutt et al., 2017) and EGNN (Gong & Cheng, 2019). An improved version is devised in Chen ¨ et al. (2019) by interpreting this framework as maximizing mutual information across layers. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Loss for combinatorial learning. For the relatively easy linear assignment problem, it has been known that Sinkhorn algorithm (Sinkhorn, 1964) is the approximate and differentiable version of Hungarian algorithm (Mena et al., 2017). The Sinkhorn Network (Adams & Zemel, 2011) is developed given known assignment cost, whereby doubly-stochastic regulation is performed on input non-negative square matrix. Patrini et al. (2018) devise the Sinkhorn AutoEncoder to minimize Wasserstein distance, and Emami & Ranka (2018) propose to learning a linear assignment solver via reinforcement learning. For permutation prediction, DeepPermNet (Santa Cruz et al., 2018) adopts the Sinkhorn layer on top of a deep convolutional network. However this method cannot be directly applied for graph matching as it is not invariant to input permutations which is conditioned on a predefined node permutation as reference. In particular, existing supervised methods on combinatorial learning are generally cross-entropy-based. Pointer Net (Vinyals et al., 2015) incorporates cross-entropy loss on learning heuristics for combinatorial problems. Milan et al. (2017) propose an objective-based loss, where the gradients are only updated if the objective improves after update. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning for graph matching. The early effort (Caetano et al., 2009) aims to incorporate learning to graph matching. The key is to learn a more effective affinity function with given correspondence as supervision. While the ability by only learning affinity is limited, Cho et al. (2013) propose a matching function learning paradigm using histogram-based attributes with Structured-SVM (Tsochantaridis et al., 2005). A recent work (Zanfir & Sminchisescu, 2018) is a breakthrough to introduce deep learning paradigm into graph matching task, which utilizes a neural network to learn the affinity function. The learning procedure is explicitly derived from the factorization of affinity matrix (Zhou & De la Torre, 2012), which makes the interpretation of the network behavior possible. However, the displacement loss in (Zanfir & Sminchisescu, 2018) measures the pixel-wise translation which is similar to optical-flow (Dosovitskiy et al., 2015), being essentially a regression task instead of combinaotiral optimization. Seeing this limitation, Wang et al. (2019) employ elementwise binary cross-entropy, termed as permutation loss. This loss has proved capable of capturing the combinatorial nature rather than pixel offset, and achieves improvement over displacement loss. Node embedding is also used in (Wang et al., 2019) to explore the structure information. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE PROPOSED LEARNING APPROACH FOR GRAPH MATCHING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            797,
+            715,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 APPROACH OVERVIEW",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            370,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An overall structure of our approach is illustrated in Fig. 1. In line with (Wang et al., 2019), we employ VGG16 (Simonyan & Zisserman, 2014) to extract features from input images and bi-linearly interpolate the features at key points (provided by datasets). We concatenate lower-level (Relu4 2) and higher-level (Relu5 1) features to incorporate local and contextual information. For an image with $k$ key points, the feature is denoted as $\\mathbf { \\bar { H } } \\in \\mathcal { R } ^ { k \\times d }$ , where $d$ is the feature dimension. Unless otherwise specified, the adjacency matrix $\\mathbf { A } \\in \\mathcal { R } ^ { k \\times k }$ is consequentially constructed via Delaunay triangulation (Delaunay et al., 1934), which is a widely adopted strategy to produce sparsely connected graph. To introduce more rich edge information, we also generate $k \\times k m$ -dimensional edge features $\\dot { \\mathbf { E } } \\in \\mathcal { R } ^ { m \\times k \\times k }$ . $E$ can be initialized with some basic edge information (e.g. length and angle and other attributes) or a commutative function $\\mathbf E _ { i j } = p ( \\mathbf H _ { i } , \\mathbf H _ { j } ) = p ( \\mathbf H _ { j } , \\mathbf H _ { i } ) \\in \\mathcal { R } ^ { m }$ , where $\\mathbf { H } _ { i }$ refers to the feature of node $i$ . Note for directed graph, the commutative property is not required. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/267255b09253042737ddb258c97d1928c580274268e1a0f652999670954f3306.jpg",
+        "image_caption": [
+            "Figure 1: Architecture overview of the proposed deep graph matching networks that consist of the proposed channel-independent embedding and Hungarian attention layer over the loss function. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            97,
+            777,
+            241
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            275,
+            825,
+            361
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The features $\\mathbf { H }$ and $\\mathbf { E }$ , together with the adjacency A, are then fed into GNN module. Pairs of features are processed in a Siamese fashion (Bromley et al., 1994). Standard GCN’s message passing rule simply updates node embedding as shown in Eq. (2). In contrast, each GNN layer in our model computes a new pair of node and edge embeddings simultaneously: ",
+        "bbox": [
+            173,
+            366,
+            825,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d2bd16880b1f8978eb6d1bc90ad530e733fa6a1c51b8c4e287870ed4ebfee34.jpg",
+        "text": "$$\n\\mathbf { H } ^ { ( l + 1 ) } = f _ { i } ( \\mathbf { H } ^ { ( l ) } , \\mathbf { E } ^ { ( l ) } , \\mathbf { A } ; W _ { 0 } ^ { l } ) , \\quad \\mathbf { E } ^ { ( l + 1 ) } = g ( \\mathbf { H } ^ { ( l ) } , \\mathbf { E } ^ { ( l ) } , \\mathbf { A } ; W _ { 1 } ^ { l } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            425,
+            718,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { 0 } ^ { l }$ and $W _ { 1 } ^ { l }$ are the learnable parameters at layer $l$ . The edge information is essential to provide structural feature enhancing graph matching. We initialize $\\mathbf { H } ^ { ( 0 ) } = \\mathbf { H }$ and $\\mathbf { E } ^ { ( 0 ) } = \\mathbf { E }$ in our setting. We will discuss the details of functions $f$ and $g$ in Sec. 3.2. Following state-of-the-art work (Wang et al., 2019), we also compute the cross-graph affinity followed by a column/row-wise softmax activation and a Sinkhorn layer (Adams & Zemel, 2011): ",
+        "bbox": [
+            173,
+            446,
+            825,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/789627b3f760465ae7c69df1192877fd90ea029cac5e263e4da2cddd0e119219.jpg",
+        "text": "$$\n\\mathbf { M } _ { i j } = \\exp \\left( \\tau \\mathbf { H } _ { ( 1 ) i } ^ { \\top } \\boldsymbol { \\Lambda } \\mathbf { H } _ { ( 2 ) j } \\right) , \\quad \\mathbf { S } = \\mathrm { S i n k h o r n } ( \\mathbf { M } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            522,
+            674,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note here $\\mathbf { M } \\in \\mathbb { R } ^ { k \\times k }$ is the node-level similarity matrix encoding similarity between two graphs, differing from the edege-level affinity matrix $\\mathbf { K }$ in Eq. 1. $\\tau$ is the weighting parameter of similarity, $\\pmb { \\Lambda }$ contains learnable parameters and ${ \\bf H } _ { ( 1 ) i }$ is the node $i$ ’s embedding from graph $\\mathcal { G } _ { 1 }$ . The output $\\mathbf { S } \\in [ 0 , 1 ] ^ { k \\times k } , \\mathbf { S 1 } = \\mathbf { 1 } , \\mathbf { S } ^ { \\top } \\mathbf { 1 } = \\mathbf { 1 }$ is a so-called doubly-stochastic matrix. Here Sinkhorn $( \\cdot )$ denotes the following update iteratively to project $\\mathbf { M }$ into doubly stochastic polygon: ",
+        "bbox": [
+            173,
+            553,
+            825,
+            626
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a1ebd53cd2e0904938ad52b161112811c5357e730d57d7d08f166e74f8cbb0ab.jpg",
+        "text": "$$\n\\mathbf { M } ^ { ( t + 1 ) } = \\mathbf { M } ^ { ( t ) } - \\frac { 1 } { n } \\mathbf { M } ^ { ( t ) } \\mathbf { 1 } \\mathbf { 1 } ^ { \\top } - \\frac { 1 } { n } \\mathbf { 1 } \\mathbf { 1 } ^ { \\top } \\mathbf { M } ^ { ( t ) } + \\frac { 1 } { n ^ { 2 } } \\mathbf { 1 } \\mathbf { 1 } ^ { \\top } \\mathbf { M } ^ { ( t ) } \\mathbf { 1 } \\mathbf { 1 } ^ { \\top } - \\frac { 1 } { n } \\mathbf { 1 } \\mathbf { 1 } ^ { \\top }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            628,
+            750,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Sinkhorn layer is shown to be an approximation of Hungarian algorithm which produces discrete matching output (Kuhn, 1955). As there are only matrix multiplication and normalization operators involved in Sinkhorn layer, it is differentiable. In practice, Eq. (5) converges rapidly within 10 iterations for decades of nodes. Less iterations involved, more precise back-propagated gradients can be achieved. We employ a cross-graph node embedding strategy following (Wang et al., 2019): ",
+        "bbox": [
+            173,
+            667,
+            825,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/78326ff599982868e6146d1983d1e8de1496b1800f1fdbaf080b1155d79f3cfb.jpg",
+        "text": "$$\n\\mathbf { H } _ { ( 1 ) } ^ { ( l ) } = f _ { c } \\left( \\mathrm { c a t } ( \\mathbf { H } _ { ( 1 ) } ^ { ( l ) } , \\mathbf { S } \\mathbf { H } _ { ( 2 ) } ^ { ( l ) } ) \\right) , \\quad \\mathbf { H } _ { ( 2 ) } ^ { ( l ) } = f _ { c } \\left( \\mathrm { c a t } ( \\mathbf { H } _ { ( 2 ) } ^ { ( l ) } , \\mathbf { S } ^ { \\top } \\mathbf { H } _ { ( 2 ) } ^ { ( l ) } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            741,
+            725,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { c }$ is a network and $\\cot ( \\cdot , \\cdot )$ is the concatenation operator. $\\mathbf { H } _ { ( i ) }$ is the node feature of graph $i$ . This procedure seeks to merge similar features from another graph into the node feature in current graph. It is similar to the feature transfer strategy in (Aberman et al., 2018) for sparse correspondence, which employs a feature merging method analogous to style transfer (Li et al., 2017). ",
+        "bbox": [
+            173,
+            770,
+            825,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As Sinkhorn layer does not necessarily output binary digits, we employ Hungarian algorithm (Kuhn, 1955) to discretize matching output S in testing. The testing differs from the training due to the Hungarian discretization. We introduce a novel attention-like mechanism termed as Hungarian attention, along with existing loss functions (will be detailed in Sec. 3.3). The final training loss is as follows, where ${ \\bf S } ^ { \\mathrm { G } }$ and $\\mathcal { H }$ correspond to binary true matching and Hungarian attention loss. ",
+        "bbox": [
+            173,
+            833,
+            825,
+            904
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cda630f072ef79a384fd581e7c9b7b35e3b60597822b2ba0b79dbd91aff9a6dc.jpg",
+        "text": "$$\n\\operatorname* { m i n } \\mathcal { H } ( \\mathbf { S } , \\mathbf { S } ^ { \\mathrm { G } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            450,
+            907,
+            549,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/301dc06ba29ec62523c5784b4b59304b6998228650416da031d678be87b81dcf.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of the proposed CIE layer for embedding based deep graph matching. The operation “Linear” refers to the linear mapping, e.g. $\\mathbf { H } _ { w } ^ { ( l ) } \\to \\bar { \\mathbf { W } _ { 2 } ^ { ( l ) } } \\mathbf { H } _ { w } ^ { ( l ) }$ in Eq (9). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            99,
+            740,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 CHANNEL-INDEPENDENT EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            252,
+            480,
+            267
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We detail the updating rule in Eq. (3). We propose a method to merge edge features into node features and perform matching on nodes. Edge information acts an important role in modeling relational data, whereby such relation can be complex thus should be encoded with high-dimensional feature. To this end, Gilmer et al. (2017) introduce a general embedding layer, which takes node and edge features and outputs a message to node $v$ , then fuses the message and the current embedding: ",
+        "bbox": [
+            173,
+            277,
+            825,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2138549f1e308ac3baa118261f53a6229c52ef65704cf2644e0e154b48d86a04.jpg",
+        "text": "$$\n\\mathbf { m } _ { v } ^ { ( l ) } = \\sigma \\left( \\sum _ { w \\in \\mathcal { N } _ { v } } f _ { t } \\left( \\mathbf { E } _ { v w } \\right) \\mathbf { H } _ { w } ^ { ( l ) } + \\mathbf { W } ^ { ( l ) } \\mathbf { H } ^ { ( l ) } \\right) , \\quad \\mathbf { H } _ { v } ^ { ( t + 1 ) } = u _ { t } \\left( \\mathbf { H } _ { v } ^ { ( t ) } , \\mathbf { m } _ { v } ^ { ( l ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            353,
+            754,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { E } _ { v w }$ is the feature corresponding to edge $( v , w )$ . In the realization of Eq. (8) (Gilmer et al., 2017), m(l)v and $\\mathbf { H } _ { v } ^ { ( l ) }$ are fed to GRU (Cho et al., 2014) as a sequential input. There are several variants which take into account specific tasks (Li et al., 2016; Schutt et al., 2017; Chen et al., 2019). ¨ Among these, Li et al. (2016) generates a transformation matrix for each edge and Schutt et al. ¨ (2017) resorts to merge embedding via fully connected neural networks. While edge-wise merging is straightforward, the representation ability is also limited. On the other hand, fully connected merging strategy will result in high computational cost and instability for back-propagation. To address these issues, we propose to merge embedding in a channel-wise fashion, which is termed as Channel-Independent Embedding (CIE). Concretely, the updating rule is written as: ",
+        "bbox": [
+            173,
+            410,
+            826,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d9bfb65e88ef705181cd16ae4f97dc4a899a1623bb9227f1a5dc60fedf003c0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { H } _ { v } ^ { ( l + 1 ) } = \\sigma \\left( \\underset { w \\in \\mathcal { N } _ { v } } { \\sum } \\underset { \\mathrm { N } } { \\underbrace { \\Gamma _ { \\mathrm { N } } \\left( \\mathbf { W } _ { 1 } ^ { ( l ) } \\mathbf { E } _ { v w } ^ { ( l ) } \\circ \\mathbf { W } _ { 2 } ^ { ( l ) } \\mathbf { H } _ { w } ^ { ( l ) } \\right) } } \\right) + \\sigma \\left( \\mathbf { W } _ { 0 } ^ { ( l ) } \\mathbf { H } _ { v } ^ { ( l ) } \\right) } \\\\ { \\mathbf { E } _ { v w } ^ { ( l + 1 ) } = \\sigma \\left( \\mathbf { W } _ { 1 } ^ { ( l ) } \\mathbf { E } _ { v w } ^ { ( l ) } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            546,
+            725,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\Gamma _ { \\mathrm { N } } ( \\cdot \\circ \\cdot )$ is a channel-wise operator/function (above the underbrace), and it performs calculation per-channel and the output channel dimension is the same as input. The second $\\sigma ( \\cdot )$ term is the message a node passes to itself, which is necessary in keeping the node information contextually consistent through each CIE layer. In this fashion, CIE is thus a procedure to aggregate node and edge embedding in each channel independently, which requires the dimensions of node $( \\mathbf { W } _ { 2 } ^ { ( l ) } \\mathbf { H } _ { w } ^ { ( l ) } )$ and edge $( \\mathbf { W } _ { 1 } ^ { ( l ) } \\mathbf { E } _ { v w } ^ { ( l ) } )$ representations to be equal. Similarly, we also propose an corresponding updating rule of edge embedding by substituting Eq. (10): ",
+        "bbox": [
+            173,
+            646,
+            825,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8febf43772da54810bb816270e5a7aed82becbbce7bf1c8ed88176ff85fdad38.jpg",
+        "text": "$$\n\\mathbf { E } _ { v w } ^ { ( l + 1 ) } = \\sigma \\left( \\Gamma _ { \\mathrm { E } } \\left( \\mathbf { W } _ { 1 } ^ { ( l ) } \\mathbf { E } _ { v w } ^ { ( l ) } \\circ h \\left( \\mathbf { H } _ { v } ^ { ( l ) } , \\mathbf { H } _ { w } ^ { ( l ) } \\right) \\right) \\right) + \\sigma \\left( \\mathbf { W } _ { 1 } ^ { ( l ) } \\mathbf { E } _ { v w } ^ { ( l ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            757,
+            717,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $h ( \\cdot , \\cdot )$ is commutative $h ( \\mathbf { X } , \\mathbf { Y } ) = h ( \\mathbf { Y } , \\mathbf { X } )$ . Eq. (11) is supplementary to Eq. (9). ",
+        "bbox": [
+            173,
+            790,
+            751,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fig. 2 shows a schematic diagram of CIE layer, which is motivated from two perspectives. First, CIE is motivated by counterparts in CNN (Qiu et al., 2017; Tran et al., 2018) which decouple a 3D convolution into two 2D ones (e.g. a $3 \\times 3 \\times 3$ convolution can be decomposed to a $1 \\times 3 \\times 3$ and a $3 \\times 1 \\times 1$ convolutions). In this sense, the number of parameters can be significantly reduced. As shown in Fig. 2, node and edge embedding is first manipulated along the channel direction via a linear layer, then operated via $\\Gamma _ { \\mathrm { N } }$ and $\\Gamma _ { \\mathrm { E } }$ orthogonal to the channel direction. Instead of merging node and edge as a whole, CIE layer decouples it into two operations. Second, CIE is also motivated by the triumph of multi-head structure (e.g. graph attention (Velickovi ˇ c et al., 2018)), the key of ´ which is to conduct unit calculation multiple times and concatenate the results. Multi-head proved effective to further improve the performance since it is capable of capturing information at different scales or aspects. Traditional neural node-edge message passing algorithms (Gilmer et al., 2017; Li et al., 2016; Schutt et al., 2017) typically produce a unified transformation matrix for all the channels. ¨ On the other hand, in Eq. (9) (10) and (11), one can consider that the basic operator in each channel is repeated $d$ times in a multi-head fashion. The cross-channel information exchange, as signified in Eq. (9) (10) and (11), only happens before the channel-wise operator (i.e. weights $\\mathbf { W } _ { i } ^ { ( l ) }$ as the crosschannel matrices). The main difference between CIE and traditional multi-head approaches e.g. (Velickovi ˇ c et al., 2018) is that CIE assumes the channel-independence of two embedded features ´ (node and edge), while traditional ones only take one input under head-independence assumption. ",
+        "bbox": [
+            173,
+            810,
+            825,
+            925
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/75a7a84da844e6c9da9fc1c6c589263364677f200a8999ef3bddde0726ba292e.jpg",
+        "image_caption": [
+            "Figure 3: A working example illustrating of our proposed Hungarian attention pipeline starting from similarity matrix. Sinkhorn algorithm solves similarity matrix into a doubly-stochastic matrix in a differentiable way. A discrete permutation matrix is further obtained via Hungarian algorithm. Our proposed Hungarian attention, taking the ground truth matching matrix into account, focuses on the “important” digits either labeled true or being mis-classified. The output matrix is obtained by attention pooling from doubly-stochastic matrix, where we compute a loss on it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            101,
+            723,
+            320
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            409,
+            825,
+            551
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 HUNGARIAN ATTENTION MECHANISM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            569,
+            478,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For most graph matching algorithms, the output is in a continuous domain. Though there are some alternatives that deliver discrete solutions by adding more constraints or introducing numerical continuation (Zhou & De la Torre, 2012; Yu et al., 2018), the main line of methods is to incorporate a sampling procedure (e.g. winner-take-all and Hungarian). Among them, the Hungarian algorithm (Kuhn, 1955) is a widely adopted, for its efficiency and theoretical optimality. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            665
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, the Hungarian algorithm incurs a gap between training (loss function) and testing stages (Hungarian sampling). We compare the permutation loss (Wang et al., 2019) for concrete analysis: ",
+        "bbox": [
+            173,
+            671,
+            823,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dab091a490732a2d749727ef92edf8bba1599f2ce8ee009b6e7ef01afe6a150f.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { C E } } = - \\sum _ { i \\in \\mathcal { G } _ { 1 } , j \\in \\mathcal { G } _ { 2 } } \\left( \\mathbf { S } _ { i j } ^ { \\mathrm { G } } \\log \\mathbf { S } _ { i j } + \\left( 1 - \\mathbf { S } _ { i j } ^ { \\mathrm { G } } \\right) \\log \\left( 1 - \\mathbf { S } _ { i j } \\right) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            707,
+            692,
+            743
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note Eq. (12) is an element-wise version of binary cross-entropy. During training, this loss tends to drag the digits in S into binary format and is likely trapped to local optima. This is because this loss will back-propagate the gradients of training samples that are easy to learn in the early training stage. In later iterations, this loss is then hard to give up the digits that have become binary. In fact, the similar phenomenon is also investigated in the focal loss (Lin et al., 2017) in comparison to the traditional cross-entropy loss. During the testing stage, however, the Hungarian algorithm has no preference on the case if digits in S are close to $0 - 1$ or not. It binarizes S anyway. Therefore, the effort of Eq. (12) to drag S into binary might be meaningless. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            862
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This issue is likely to be solved by integrating Hungarian algorithm during the training stage. Unfortunately, Hungarian algorithm is undifferentiable and its behavior is difficult to mimic with a differentiable counterpart. In this paper, instead of finding a continuous approximation of Hungarian algorithm, we treat it as a black box and dynamically generate network structure (sparse link) ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0bfb567978b2c8c0e754e8dc1a95d6a554f3305930d4de421fad0d852b0fa56.jpg",
+        "table_caption": [
+            "Table 1: Accuracy on Pascal VOC (best in bold). White and gray background refer to results on testing and training, respectively. Compared methods include GMN (Zanfir & Sminchisescu, 2018), GAT (Velickovi ˇ c et al., 2018), EPN (Gong & Cheng, 2019), PCA/PIA (Wang et al., 2019). ´ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>method</td><td>aero bike bird boat bottle bus car catchair cow table dog</td><td></td><td></td><td></td><td></td><td>horsembike</td><td></td><td></td><td></td><td>person plant sheep sofa train tv</td><td>Ave</td></tr><tr><td rowspan=\"5\">GMN-D GMN-P</td><td>31.947.251.9 40.8 68.772.2 53.6 52.8 34.6 48.6</td><td></td><td></td><td></td><td>72.3 47.7</td><td>54.8 51.0</td><td>38.6</td><td>75.1</td><td>49.5</td><td>45.0 83.0 86.3</td><td>55.3</td></tr><tr><td>31.1 46.2 58.2 45.9 70.6 76.4 61.2 61.7 35.5 53.7</td><td></td><td></td><td></td><td>58.9 57.5</td><td>56.9</td><td>49.3</td><td>34.1 77.5</td><td>57.1</td><td>53.6 83.2 88.6</td><td>57.9</td></tr><tr><td>GAT-P 46.4 60.5 60.9 51.8 79.0</td><td></td><td>70.9 62.7 70.1</td><td>39.7 63.9</td><td>66.2 63.8</td><td>65.8</td><td>62.8</td><td>39.5</td><td>82.0 66.9</td><td>50.1 78.5 90.3</td><td>63.6</td></tr><tr><td>GAT-H 47.2 61.6 63.2 53.3</td><td>79.7</td><td>70.1 65.3 70.5 38.4 64.7</td><td></td><td>62.9 65.1</td><td>66.2</td><td>62.5</td><td>41.1</td><td>78.8 67.1</td><td>61.6 81.4 91.0</td><td>64.6</td></tr><tr><td>EPN-P 47.6 65.2 62.2 52.7</td><td>77.8</td><td>69.5 63.4 69.6</td><td>37.8 62.8</td><td>63.6 63.9</td><td>64.6</td><td>61.9</td><td>39.9</td><td>80.5 66.7</td><td>45.5 77.6 90.6</td><td>63.2</td></tr><tr><td rowspan=\"4\">PIA-D PIA-P PCA-P</td><td>39.7 57.7 58.6 47.2</td><td>74.0</td><td>74.5 62.1 66.6 33.6 61.7</td><td>65.4</td><td>58.0 67.1</td><td>58.9</td><td>41.9</td><td>77.7</td><td>64.7</td><td>50.5 81.8 89.9</td><td>61.6</td></tr><tr><td>41.5 55.8 60.9 51.9</td><td>75.0</td><td>75.8 59.6 65.2 33.3 65.9</td><td></td><td>62.8 62.7</td><td>67.7</td><td>62.1</td><td>42.9</td><td>80.2 64.3</td><td>59.5 82.7 90.1</td><td>63.0</td></tr><tr><td>40.9 55.0 65.8 47.9</td><td>76.9</td><td>77.9 63.5 67.4</td><td>33.7 65.5</td><td>63.6 61.3</td><td>68.9</td><td>62.8</td><td>44.9</td><td>77.5 67.4</td><td>57.5 86.7 90.9</td><td>63.8</td></tr><tr><td>PCA-H 49.8 60.7 63.9 52.6 79.8 72.5 63.8 71.2 38.4 62.5</td><td></td><td></td><td></td><td>71.7 65.4</td><td>66.6</td><td>62.5</td><td>40.5</td><td>84.7 66.1</td><td>47.9 80.5 91.1</td><td>64.6</td></tr><tr><td rowspan=\"4\">PCA+-P CIE2-P</td><td>46.6 61.0 62.3 53.9</td><td>78.2</td><td>72.5 64.4 70.539.0 63.5</td><td>74.8</td><td>65.2 65.0</td><td>61.6</td><td>40.8</td><td>83.2</td><td>67.1</td><td>50.5 79.6 91.6</td><td>64.6</td></tr><tr><td>50.9 65.5 68.057.081.0</td><td></td><td>75.970.373.441.1 66.7</td><td></td><td>53.2 68.3</td><td>68.4</td><td>63.5</td><td>45.3</td><td>84.8 69.7</td><td>57.2 79.8 91.6</td><td>66.9</td></tr><tr><td>CIE2-H 51.2 68.4 69.5 57.3 82.5 73.5 69.5 74.0 40.3 67.8 60.0</td><td></td><td></td><td></td><td></td><td>69.7 70.3</td><td>65.1</td><td>44.7</td><td>86.9 70.7</td><td>57.3 84.2 92.2</td><td>67.4</td></tr><tr><td>CIE-P 52.1 69.4 69.9 58.9</td><td></td><td>80.6 76.3 71.0 74.2 41.1 68.0</td><td></td><td>60.4 69.7</td><td>70.7</td><td>65.1</td><td>46.1</td><td>85.1 70.4</td><td>61.6 80.7 91.7</td><td>68.1</td></tr><tr><td>CIE-H</td><td>51.2 69.2 70.1 55.0 82.8 72.8 69.0 74.2 39.6 68.871.8 70.0</td><td></td><td></td><td></td><td></td><td>71.8 66.8</td><td>44.8</td><td>85.2</td><td>69.9</td><td>65.4 85.2 92.4</td><td>68.9</td></tr><tr><td>PCA-P</td><td>75.8 99.2 83.374.7 98.7 96.374.3 87.8 80.9 85.7 100.083.7 83.8</td><td></td><td></td><td></td><td></td><td></td><td>98.7</td><td>66.5</td><td>99.1 80.7</td><td></td><td></td></tr><tr><td>CIE-P</td><td></td><td></td><td></td><td>56.5 84.0 73.5 58.0 91.5 81.1 67.8 76.8 46.4 72.2 98.0 73.9 73.6</td><td></td><td></td><td>77.9</td><td>46.1</td><td>94.8 72.7</td><td>99.7 98.2 97.0 93.6 93.7 91.6</td><td>88.2</td></tr><tr><td></td><td></td><td></td><td></td><td>CIEt-H59.4 88.1 75.9 58.0 94.3 81.9 69.4 78.9 49.5 78.2 99.7 78.1 78.0</td><td></td><td></td><td>82.1</td><td>47.4</td><td>95.8 75.7</td><td>97.6 96.0 91.1</td><td>76.2 78.7</td></tr></table>",
+        "bbox": [
+            176,
+            155,
+            825,
+            353
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "according to its output. Concretely, the sparse link is calculated as: ",
+        "bbox": [
+            173,
+            359,
+            612,
+            373
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f34da80d6bdc128580760fed1a08f8546caf21c39bbcaea736e164bf93d14fa6.jpg",
+        "text": "$$\n\\mathbf { Z } = \\mathrm { A t t e n } \\left( \\mathrm { H u n g a r i a n } ( \\mathbf { S } ) , \\mathbf { S } ^ { \\mathrm { G } } \\right) = \\mathcal { P } \\cup \\mathcal { Q }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            378,
+            643,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where the attention mechanism Atten is fulfilled by an element-wise “logic OR” function. Fig. 3 shows an example of Hungarian attention procedure, and Eq. (13) highlights the most contributing digit locations: positive digits $\\mathcal { P } = \\mathbf { S }$ where Hungarian agrees with the ground-truth; negative digits $\\bar { \\mathcal { Q } } ^ { - } = \\operatorname { H u n g a r i a n } ( \\mathbf { S } ) \\ \\backslash \\ \\mathbf { S } ^ { \\mathrm { G } }$ where Hungarian differs from ground-truth. While GT (positive digits) naturally points out the digits that must be considered, negative ones indicate the digits that most hinder the matching (most impeding ones among all mis-matchings). Thus we need only minimize the loss at $\\mathbf { Z }$ , without considering the rest of digits. As we note that this mechanism only focuses on a small portion of the matching matrix which is analogous to producing hard attention, we term it Hungarian attention. Now that with the attention mask $\\mathbf { Z }$ , the Hungarian attention loss becomes: ",
+        "bbox": [
+            173,
+            400,
+            825,
+            526
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0446dd1edb9ae3fe8afb5eeec79ae3ba66abceaf4ca4c8420725595308ba317c.jpg",
+        "text": "$$\n\\mathcal { H } _ { \\mathrm { C E } } = - \\sum _ { i \\in \\mathcal { G } _ { 1 } , j \\in \\mathcal { G } _ { 2 } } \\mathbf { Z } _ { i j } \\left( \\mathbf { S } _ { i j } ^ { \\mathrm { G } } \\log \\mathbf { S } _ { i j } + \\left( 1 - \\mathbf { S } _ { i j } ^ { \\mathrm { G } } \\right) \\log \\left( 1 - \\mathbf { S } _ { i j } \\right) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            529,
+            707,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Note that Hungarian attention mechanism can also be applied to other loss functions once the matching score is calculated in an element-wise fashion. Our experiment also studies Hungarian attention loss when casted on focal loss (Lin et al., 2017) and a specifically designed margin loss. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            611
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally we give a brief qualitative analysis on why Hungarian attention can improve matching loss. As discrete graph matching problem is actually built upon Delta function over permutation vertices (1 at ground-truth matching and 0 otherwise) (Yu et al., 2018), learning of graph matching with permutation loss is actually to approximate such functions with continuous counterparts. Unfortunately, more precise approximation to Delta function will result in higher non-smoothness, as discussed in Yu et al. (2018). For highly non-smooth objective, the network is more likely trapped at local optima. Hungarian attention, however, focuses on a small portion of the output locations, thus does not care about if most of the output digits are in $\\{ 0 , 1 \\}$ . In this sense, Hungarian attention allows moderate smoothness of the objective, thus optimizer with momentum is likely to avoid local optima. ",
+        "bbox": [
+            173,
+            616,
+            825,
+            743
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            762,
+            326,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experiments are conducted on three benchmarks widely used for learning-based graph matching: CUB2011 dataset (Welinder et al., 2010) following the protocol in (Choy et al., 2016), Pascal VOC keypoint matching (Everingham et al., 2010; Bourdev & Malik, 2009) which is challenging and Willow Object Class dataset (Cho et al., 2013). Mean matching accuracy is adopted for evaluation: ",
+        "bbox": [
+            173,
+            792,
+            825,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98fdc275abd7dcbd901b16a59e141537885bb4930b7947c96b07b984b626d942.jpg",
+        "text": "$$\n\\operatorname { A c c } = \\frac { 1 } { k } \\sum _ { i \\in \\mathcal { G } _ { 1 } , j \\in \\mathcal { G } _ { 2 } } \\operatorname { A N D } \\left( \\operatorname { H u n g a r i a n } ( \\mathbf { S } ) _ { i j } , \\mathbf { S } _ { i j } ^ { \\mathrm { G } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            853,
+            660,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The algorithm abbreviation is in the form “X-Y”, where “X” and “Y” refer to the network structure (e.g. CIE) and loss function (e.g. Hungarian attention loss), respectively. Specifically, D, $\\mathbf { P }$ and $\\mathbf { H }$ correspond to displacement used in (Zanfir & Sminchisescu, 2018), permutation as adopted in (Wang et al., 2019) and Hungarian attention over permutation loss devised by this paper, respectively. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Peer methods. We compare our method with the following selected counterparts: 1) HARG (Cho et al., 2013). This shallow learning method is based on hand-crafted feature and Structured SVM; 2) GMN (Zanfir & Sminchisescu, 2018). This is a seminal work incorporating graph matching and deep learning, and the solver is upon spectral matching (Leordeanu & Hebert, 2005). While the loss of this method is displacement loss, we also report the results of GMN by replacing its loss with permutation loss (GMN-P); 3) PIA/PCA (Wang et al., 2019). PCA and PIA correspond to the algorithms with and without cross-graph node embedding, respectively. Readers are referred to Wang et al. (2019) for more details; We further replace the GNN layer in our framework with: 4) GAT (Velickovi ˇ c et al., 2018). Graph attention network is an attention mechanism on graphs, ´ which reweights the embedding according to attention score; 5) EPN (Gong & Cheng, 2019). This method exploits multi-dimensional edge embedding and can further be applied on directed graphs. The edge dimension is set to 32 in our experiments. Finally, we term our network structure CIE for short. To investigate the capacity of edge embedding update, we also devise a version without edge embedding, in which connectivity is initialized as reciprocal of the edge length then normalized, rather than A. This model is called $\\mathbf { P C A } +$ since the node embedding strategy follows PCA. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            347
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Implementation details. As the node number of each graph might vary, we add dummy nodes for each graph pair such that the node number reaches the maximal graph size in a mini-batch in line with the protocol in (Wang et al., 2019). In either training or testing stages, these dummy nodes will not be updated or counted. The activation function in Eq. (9) (10) and (11) is set as Relu (Nair & Hinton, 2010) in all experiments. Specifically, the node and edge embedding is implemented by: ",
+        "bbox": [
+            174,
+            353,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62e4544257eec868a234dd1f7f0c16d32011bb84327660e312074958db298d6d.jpg",
+        "text": "$$\n\\mathbf { H } _ { \\cdot q } ^ { ( l + 1 ) } = \\sigma \\left( \\left( \\mathbf { A } \\odot \\left( \\mathbf { W } _ { 1 } ^ { ( l ) } \\mathbf { E } ^ { ( l ) } \\right) _ { \\cdot q } \\right) \\left( \\mathbf { W } _ { 2 } ^ { ( l ) } \\mathbf { H } ^ { ( l ) } \\right) _ { \\cdot q } \\right) + \\sigma \\left( \\left( \\mathbf { W } _ { 0 } ^ { ( l ) } \\mathbf { H } ^ { ( l ) } \\right) _ { \\cdot q } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            426,
+            753,
+            460
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c23c250390b4fa1e0a913f4bf0002272378d238f2f0e2dc66be355492681e3a.jpg",
+        "text": "$$\n\\mathbf { E } _ { \\cdot q } ^ { ( l + 1 ) } = \\sigma \\left( \\left| \\left( \\mathbf { W } _ { 0 } ^ { ( l ) } \\mathbf { H } ^ { ( l ) } \\right) _ { \\cdot q } \\Theta \\left( \\mathbf { W } _ { 0 } ^ { ( l ) } \\mathbf { H } ^ { ( l ) } \\right) _ { \\cdot q } ^ { \\top } \\right| \\odot \\mathbf { E } _ { \\cdot q } ^ { ( l ) } \\right) + \\sigma \\left( \\left( \\mathbf { W } _ { 1 } ^ { ( l ) } \\mathbf { E } ^ { ( l ) } \\right) _ { \\cdot q } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            464,
+            741,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ and $\\ominus$ refer to element-wise product and pairwise difference, respectively. $\\mathbf { H } _ { \\cdot q }$ is the qth channel of $\\mathbf { H }$ . In $\\mathbf { C I } \\mathbf { E } _ { 1 }$ setting, only node-level merging Eq. (16a) is considered and the edge feature is updated as Eq. (10). In $\\mathbf { { C I } } \\mathbf { { E } } _ { 2 }$ setting, we also replace the edge update Eq. (11) with Eq. (16b). Note edge embedding is used in both $\\mathbf { C I } \\mathbf { E } _ { 1 }$ and $\\mathbf { { C I } } \\mathbf { { E } } _ { 2 }$ and note PCA-H can be regarded as the pure node embedding version of our approach. The edge feature is initiated as reciprocal of the edge length. For training, batch size is set to 8. We employ SGD optimizer (Bottou, 2010) with momentum 0.9. Two CIE layers are stacked after VGG16. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            594
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CUB2011 test CUB2011 consists of 11,788 images from 200 kinds of birds with 15 annotated parts. We randomly sample image pairs from the dataset following the implementation released by Choy et al. (2016). We do not use the pre-alignment of poses during testing, because their alignment result is not publicly available. Therefore, there exists significant variation in pose, articulation and appearance across images, in both training and testing phase. Images are cropped around bounding box and resized to $2 5 6 \\times 2 5 6$ before fed into the network. Instead of evaluating the performance in a retrieval fashion (Zanfir & Sminchisescu, 2018), we directly evaluate the matching accuracy since the semantic key-points are pre-given. We test two settings: 1) intra-class. During training, we randomly sample images, with each pair sampled from the same category (out of 200 bird categories). In testing, 2,000 image pairs (100 pairs for each category) are sampled; 2) cross-class. We analogously sample image pairs without considering the category information and 5,000 randomly sampled image pairs are employed for testing. While the first setting is for a class-aware situation, the second setting is considered for testing the class-agnostic case. Results are shown in Table 3. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            790
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We see our method surpasses all the competing methods in terms of matching accuracy. Besides, almost all the selected algorithms can reach over $9 0 \\%$ accuracy, indicating that this dataset contains mostly “easy” learning samples. In this case, the Hungarian attention can slightly improve the performance since easy gradients agree with descending trend of the loss on the whole dataset. ",
+        "bbox": [
+            174,
+            797,
+            823,
+            853
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Pascal VOC test The Pascal VOC dataset with Key-point annotation (Bourdev & Malik, 2009) contains 7,020 training images and 1,682 testing images with 20 classes in total. To the best of our knowledge, this is the largest and most challenging dataset for graph matching in computer vision. Each image is cropped around its object bounding box and is resized to $2 5 6 \\times 2 5 6$ . The node ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c8d9b9e1f995a1cc878942ca464f0eb90ffb13b074da62ef704af2069adf88e1.jpg",
+        "image_caption": [
+            "(a) Accuracy/loss vs. training epoch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            99,
+            482,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/19ed5da35d238352f86d7bbe1fe6919ac6415510c5a713062e3e7e3a9dd22c1d.jpg",
+        "image_caption": [
+            "(b) Ablation study by Hungarian attention. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            102,
+            767,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 4: Performance study on Pascal VOC. Note in (a) the loss is calculated on all matching digits for both $\\mathrm { C I E } _ { 1 }$ -P and $\\mathrm { C I E } _ { 1 }$ -H. Note around 10th epoch, the accuracy of $\\mathrm { C I E } _ { 1 }$ -P almost reaches the highest, but the loss keeps descending until 30th epoch. This indicates that in most of the latter epochs, P-loss performs “meaningless” back-propagation to drag the output to binary. H-loss, by accommodating smoothness, can emphasize most contributing digits and achieves higher accuracy. size of this dataset varies from 6 to 23 and there are various scale, pose and illumination perturbations. Experimental results are summarized in Table 1. We see in either setting, CIE significantly outperforms all peer algorithms. Specifically, $\\mathrm { C I E } _ { 1 } .$ -H achieves the best performance and has $0 . 8 \\dot { \\% }$ improvement w.r.t. average accuracy over $\\mathrm { C I E } _ { 1 }$ -P. For each class, $\\mathrm { C I E } _ { 1 }$ -H and $\\mathrm { C I E } _ { 1 }$ -P carve up most of the top performance. We also note that $\\mathrm { C I E } _ { 1 }$ -H has a close performance on “table” compared with GMN-D. Since P-loss is naturally not as robust as D-loss on symmetric objects, P-loss showed great degradation over D-loss on “table” (as discussed in (Wang et al., 2019)). However, with the help of Hungarian link, H-loss can maintain relatively high accuracy despite natural flaw of P-loss. This observation indicates that H-loss can focus on “difficult” examples. We also note that $\\mathrm { C I E } _ { 1 }$ produces better results against $\\mathrm { C I E } _ { 2 }$ , which implies that updating edge embedding is less effective compared to a singleton node updating strategy. We can also see from Table 1 that PCA-P has much higher performance on training samples than $\\mathrm { C I E } _ { 1 }$ -H, which is to the contrary of the result on testing samples. This might indicate that PCA-P overfits the training samples. ",
+        "bbox": [
+            173,
+            272,
+            826,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Accuracy/loss vs. training epoch. We further show the typical training behavior of P-loss and Hloss on Pascal VOC dataset in Fig. 4. 30 epochs are involved in a whole training process. Accuracy is evaluated on testing samples after each epoch while loss is the average loss value within each epoch. In the early training stage, the loss of $\\mathrm { C I E } _ { 1 }$ -P immediately drops. On the other hand, $\\mathrm { C I E } _ { 1 }$ -H hesitates for several epochs to find the most effective descending direction. On the late stage, we observe that even though P-loss (Eq. (12)) calculates much more digits than H-loss (Eq. (14)), the loss values are opposite. This counter-intuitive fact strongly indicates that P-loss makes meaningless effort, which is not helpful to improve the performance, at late stage. The proposed H-loss, on the other hand, is capable of avoiding easy but meaningless gradients. ",
+        "bbox": [
+            173,
+            530,
+            825,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of Hungarian attention mechanism. We also conduct experiments to show the improvement of Hungarian attention over several loss functions (with and without Hungarian attention): Hungarian attention is applied on Focal loss (Focal) (Lin et al., 2017) as: ",
+        "bbox": [
+            174,
+            662,
+            825,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e15fe7f9a8e760a2f30cbee72960adaab4d8eed42d40b5087b1ef616d0f15640.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { f o c a l } } = \\left\\{ \\begin{array} { l l } { - \\alpha \\mathbf { Z } _ { i j } ( 1 - \\mathbf { S } _ { i j } ) ^ { \\gamma } \\log ( \\mathbf { S } _ { i j } ) , } & { \\mathbf { S } _ { i j } ^ { \\mathrm { G } } = 1 } \\\\ { - ( 1 - \\alpha ) \\mathbf { Z } _ { i j } \\mathbf { S } _ { i j } ^ { \\gamma } \\log ( 1 - \\mathbf { S } _ { i j } ) , } & { \\mathbf { S } _ { i j } ^ { \\mathrm { G } } = 0 } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            712,
+            671,
+            753
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where controlling parameters $\\alpha = 0 . 7 5$ and $\\gamma = 2$ in our setting. We also design a margin loss (Margin) with Hungarian attention under a max-margin rule. Note we insert the Hungarian attention mask $\\mathbf { Z } _ { i j }$ into Eq. (17) and Eq. (18) based on the vanilla forms. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1162657a57c014f1954c03a98896c438d2625eaf1410a43953755f88e09e00b3.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { m a r g i n } } = \\left\\{ \\begin{array} { l l } { \\mathbf { Z } _ { i j } \\times \\operatorname* { m a x } ( 1 - \\mathbf { S } _ { i j } - \\beta , 0 ) , } & { \\mathbf { S } _ { i j } ^ { \\mathbf { G } } = 1 } \\\\ { \\mathbf { Z } _ { i j } \\times \\operatorname* { m a x } ( \\mathbf { S } _ { i j } - \\beta , 0 ) , } & { \\mathbf { S } _ { i j } ^ { \\mathbf { G } } = 0 } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            810,
+            669,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where we set the margin value $\\beta \\ : = \\ : 0 . 2$ . Loss of Eq. (18) is valid because after Softmax and Sinkhorn operations, $\\mathbf { S } _ { i j } ~ \\in ~ [ 0 , 1 ]$ . We also show permutation loss (Perm) (Wang et al., 2019). Result can be found in Fig. 4 (b) whereby the average accuracy on Pascal VOC is reported. All the settings are under $\\mathrm { C I E } _ { 1 }$ . For either loss, the proposed Hungarian attention can further enhance the accuracy, which is further visualized by a pair of matching results under P-loss and H-loss in Fig. 5. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b40a9251d7c8edb6df2b7b8344078fcf061652721ebd0223b72030de79b33362.jpg",
+        "image_caption": [
+            "Figure 5: Visualization of a matching result: 10 key points in each image with 7 and 8 correct matchings dispalyed, respectively. Different colors across images indicate node correspondence. The larger size of dot, the larger is the predicted value $\\mathbf { S } _ { i j }$ . (a) The reference image. (b) Result on the target image from $\\mathrm { C I E } _ { 1 }$ -P. (c) Result on the target image from $\\mathrm { C I E } _ { 1 }$ -H. We see though H-loss i.e. Hungarian attention loss outputs smaller predicted values, it delivers a more accurate matching. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            101,
+            805,
+            228
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/38d9c57658c5af4e82eac4229da67208dc2edf99eb8f728883f1418bfe7cd93a.jpg",
+        "table_caption": [
+            "Table 2: Accuracy $( \\% )$ on Willow Object. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>method</td><td>face</td><td>mbike</td><td>car</td><td>duck</td><td>wbottle</td></tr><tr><td>HARG</td><td>91.2</td><td>44.4</td><td>58.4</td><td>55.2</td><td>66.6</td></tr><tr><td>GMN-V</td><td>98.1</td><td>65.0</td><td>72.9</td><td>74.3</td><td>70.5</td></tr><tr><td>GMN-W</td><td>99.3</td><td>71.4</td><td>74.3</td><td>82.8</td><td>76.7</td></tr><tr><td>PCA-V</td><td>100.0</td><td>69.8</td><td>78.6</td><td>82.4</td><td>95.1</td></tr><tr><td>PCA-W</td><td>100.0</td><td>76.7</td><td>84.0</td><td>93.5</td><td>96.9</td></tr><tr><td>CIE-V</td><td>99.9</td><td>71.5</td><td>75.4</td><td>73.2</td><td>97.6</td></tr><tr><td>CIE-W</td><td>100.0</td><td>90.0</td><td>82.2</td><td>81.2</td><td>97.6</td></tr></table>",
+        "bbox": [
+            194,
+            353,
+            537,
+            457
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f23c79f44b83a256f993f058e931f5368abf982db63b022a922cfede85b7374.jpg",
+        "table_caption": [
+            "Table 3: Accuracy $( \\% )$ on CUB. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>method</td><td>intra-class</td><td>cross-class</td></tr><tr><td>GMN-D</td><td>89.6</td><td>89.9</td></tr><tr><td>GMN-P</td><td>90.4</td><td>90.8</td></tr><tr><td>GAT-P</td><td>93.2</td><td>93.4</td></tr><tr><td>PCA-P</td><td>92.9</td><td>93.5</td></tr><tr><td>PCA-H</td><td>93.7</td><td>93.5</td></tr><tr><td>CIE-P</td><td>94.1</td><td>93.8</td></tr><tr><td>CIE-H</td><td>94.4</td><td>94.2</td></tr></table>",
+        "bbox": [
+            565,
+            352,
+            802,
+            455
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Willow Object Class test We test the transfer ability on Willow Object Class (Cho et al., 2013). It contains 256 images3 of 5 categories in total, with three categories (face, duck and winebottle) collected from Caltech-256 and resting two (car and motorbike) from Pascal VOC 2007. This dataset is considered to have bias compared with Pascal VOC since images in the same category are with relatively fixed pose and background is much cleaner. We crop the object inside its bounding box and resize it to $2 5 6 \\times 2 5 6$ as CNN input. While HARG is trained from scratch following the protocol in (Cho et al., 2013), all the resting counterparts are either directly pre-trained from the previous section or fine-tuned upon the pre-trained models. We term the method “X-V” or “X-W” to indicate pre-trained model on Pascal VOC or fine-tuned on Willow, respectively. CIE refers to $\\mathrm { C I E } _ { 1 }$ -H for short. Results in Table 2 suggest that our method is competitive to state-of-the-art. ",
+        "bbox": [
+            173,
+            476,
+            825,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            318,
+            656
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have presented a novel and effective approach for learning based graph matching. On one hand, the novelty of our method partially lies in the development of the Hungarian attention, which intrinsically adapts the matching problem. It is further observed from the experiments that Hungarian attention can improve several matching-oriented loss functions, which might bring about potential for a series of combinatorial problems. On the other hand, we also devise the channel independent embedding (CIE) technique for deep graph matching, which decouples the basic merging operations and is shown robust in learning effective graph representation. Extensive experimental results on multiple matching benchmarks show the leading performance of our solver, and highlight the orthogonal contribution of the two proposed components on top of existing techniques. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            801
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            823,
+            326,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianshu Yu and Baoxin Li were supported in part by a grant from ONR. Any opinions expressed in this material are those of the authors and do not necessarily reflect the views of ONR. Runzhong Wang and Junchi Yan were supported in part by NSFC 61972250 and U19B2035. ",
+        "bbox": [
+            176,
+            848,
+            825,
+            890
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kfir Aberman, Jing Liao, Mingyi Shi, Dani Lischinski, Baoquan Chen, and Daniel Cohen-Or. Neural best-buddies: Sparse cross-domain correspondence. SIGGRAPH, 2018. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Prescott Adams and Richard S Zemel. Ranking via sinkhorn propagation. arXiv:1106.1925, 2011. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            193
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Florian Bernard, Christian Theobalt, and Michael Moeller. Ds\\*: Tighter lifting-free convex relaxations for quadratic matching problems. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            200,
+            823,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Leon Bottou. Large-scale machine learning with stochastic gradient descent. In ´ COMPSTAT. 2010. ",
+        "bbox": [
+            174,
+            238,
+            821,
+            255
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lubomir Bourdev and Jitendra Malik. Poselets: Body part detectors trained using 3d human pose annotations. In ICCV, 2009. ",
+        "bbox": [
+            174,
+            262,
+            821,
+            292
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jane Bromley, Isabelle Guyon, Yann LeCun, Eduard Sackinger, and Roopak Shah. Signature verifi- ¨ cation using a “siamese” time delay neural network. In NIPS, 1994. ",
+        "bbox": [
+            173,
+            300,
+            823,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. In ICLR, 2014. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            368
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tiberio S Caetano, Julian J McAuley, Li Cheng, Quoc V Le, and Alex J Smola. Learning graph ´ matching. PAMI, 31(6):1048–1058, 2009. ",
+        "bbox": [
+            171,
+            376,
+            825,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hongyun Cai, Vincent W Zheng, and Kevin Chen-Chuan Chang. A comprehensive survey of graph embedding: Problems, techniques, and applications. TKDE, 30(9):1616–1637, 2018. ",
+        "bbox": [
+            171,
+            414,
+            823,
+            444
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pengfei Chen, Weiwen Liu, Chang-Yu Hsieh, Guangyong Chen, and Shengyu Zhang. Utilizing edge features in graph neural networks via variational information maximization. arXiv preprint arXiv:1906.05488, 2019. ",
+        "bbox": [
+            173,
+            452,
+            823,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014. ",
+        "bbox": [
+            174,
+            502,
+            823,
+            546
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minsu Cho, Jungmin Lee, and Kyoung Mu Lee. Reweighted random walks for graph matching. In ECCV, 2010. ",
+        "bbox": [
+            171,
+            554,
+            825,
+            584
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minsu Cho, Karteek Alahari, and Jean Ponce. Learning graphs to match. In CVPR, 2013. ",
+        "bbox": [
+            171,
+            592,
+            761,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher B Choy, JunYoung Gwak, Silvio Savarese, and Manmohan Chandraker. Universal correspondence network. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            616,
+            823,
+            646
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In NIPS, 2016. ",
+        "bbox": [
+            169,
+            655,
+            823,
+            684
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Boris Delaunay et al. Sur la sphere vide. Izv. Akad. Nauk SSSR, Otdelenie Matematicheskii i Estestvennyka Nauk, 7(793-800):1–2, 1934. ",
+        "bbox": [
+            169,
+            691,
+            825,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy, Philipp Fischer, Eddy Ilg, Philip Hausser, Caner Hazirbas, Vladimir Golkov, Patrick Van Der Smagt, Daniel Cremers, and Thomas Brox. Flownet: Learning optical flow with convolutional networks. In ICCV, 2015. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            773
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Patrick Emami and Sanjay Ranka. Learning permutations with sinkhorn policy gradient. arXiv:1805.07010, 2018. ",
+        "bbox": [
+            173,
+            781,
+            821,
+            810
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. IJCV, 88(2):303–338, 2010. ",
+        "bbox": [
+            174,
+            819,
+            820,
+            849
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Paolo Frasconi, Marco Gori, and Alessandro Sperduti. A general framework for adaptive processing of data structures. TNN, 9(5):768–786, 1998. ",
+        "bbox": [
+            173,
+            857,
+            820,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In ICML, 2017. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liyu Gong and Qiang Cheng. Exploiting edge features for graph neural networks. In CVPR, 2019. ",
+        "bbox": [
+            169,
+            103,
+            821,
+            119
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In IJCNN, 2005. ",
+        "bbox": [
+            171,
+            126,
+            821,
+            155
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NIPS, 2017. ",
+        "bbox": [
+            176,
+            162,
+            823,
+            193
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Juris Hartmanis. Computers and intractability: a guide to the theory of np-completeness (michael r. garey and david s. johnson). Siam Review, 24(1):90, 1982. ",
+        "bbox": [
+            174,
+            200,
+            821,
+            231
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            237,
+            821,
+            267
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            273,
+            823,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Harold W Kuhn. The hungarian method for the assignment problem. Naval research logistics quarterly, 2(1-2):83–97, 1955. ",
+        "bbox": [
+            174,
+            311,
+            821,
+            342
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eugene L Lawler. The quadratic assignment problem. Management science, 9(4):586–599, 1963. ",
+        "bbox": [
+            173,
+            348,
+            812,
+            364
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marius Leordeanu and Martial Hebert. A spectral technique for correspondence problems using pairwise constraints. In ICCV, 2005. ",
+        "bbox": [
+            173,
+            371,
+            820,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yijun Li, Chen Fang, Jimei Yang, Zhaowen Wang, Xin Lu, and Ming-Hsuan Yang. Universal style transfer via feature transforms. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            409,
+            821,
+            438
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            445,
+            823,
+            476
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            483,
+            821,
+            512
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eliane Maria Loiola, Nair Maria Maia de Abreu, Paulo Oswaldo Boaventura-Netto, Peter Hahn, and Tania Querido. A survey for the quadratic assignment problem. European journal of operational research, 176(2):657–690, 2007. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            563
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gonzalo Mena, David Belanger, Gonzalo Munoz, and Jasper Snoek. Sinkhorn networks: Using ˜ optimal transport techniques to learn permutations. NIPS Workshop in Optimal Transport and Machine Learning, 2017. ",
+        "bbox": [
+            173,
+            570,
+            823,
+            614
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Anton Milan, Seyed Hamid Rezatofighi, Ravi Garg, Anthony R. Dick, and Ian D. Reid. Data-driven approximations to np-hard problems. In AAAI, 2017. ",
+        "bbox": [
+            171,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010. ",
+        "bbox": [
+            173,
+            659,
+            821,
+            689
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Giorgio Patrini, Marcello Carioni, Patrick Forre, Samarth Bhargav, Max Welling, Rianne van den Berg, Tim Genewein, and Frank Nielsen. Sinkhorn autoencoders. arXiv:1810.01118, 2018. ",
+        "bbox": [
+            173,
+            695,
+            823,
+            726
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhaofan Qiu, Ting Yao, and Tao Mei. Learning spatio-temporal representation with pseudo-3d residual networks. In ICCV, 2017. ",
+        "bbox": [
+            171,
+            733,
+            821,
+            762
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhe Ren, Junchi Yan, Bingbing Ni, Bin Liu, Xiaokang Yang, and Hongyuan Zha. Unsupervised deep learning for optical flow estimation. In AAAI, 2017. ",
+        "bbox": [
+            171,
+            770,
+            823,
+            799
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rodrigo Santa Cruz, Basura Fernando, Anoop Cherian, and Stephen Gould. Visual permutation learning. TPAMI, 2018. ",
+        "bbox": [
+            173,
+            806,
+            823,
+            837
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. TNN, 20(1):61–80, 2008. ",
+        "bbox": [
+            174,
+            843,
+            820,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kristof T Schutt, Farhad Arbabzadah, Stefan Chmiela, Klaus R M ¨ uller, and Alexandre Tkatchenko. ¨ Quantum-chemical insights from deep tensor neural networks. Nature communications, 8:13890, 2017. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard Sinkhorn. A relationship between arbitrary positive matrices and doubly stochastic matrices. AoMS, 1964. ",
+        "bbox": [
+            173,
+            140,
+            821,
+            170
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Sperduti and Antonina Starita. Supervised neural networks for the classification of structures. TNN, 8(3):714–735, 1997. ",
+        "bbox": [
+            176,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Du Tran, Heng Wang, Lorenzo Torresani, Jamie Ray, Yann LeCun, and Manohar Paluri. A closer look at spatiotemporal convolutions for action recognition. In CVPR, 2018. ",
+        "bbox": [
+            174,
+            217,
+            823,
+            246
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ioannis Tsochantaridis, Thorsten Joachims, Thomas Hofmann, and Yasemin Altun. Large margin methods for structured and interdependent output variables. JMLR, 6(Sep):1453–1484, 2005. ",
+        "bbox": [
+            171,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li ´ o, and Yoshua \\` Bengio. Graph attention networks. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In NIPS, 2015. ",
+        "bbox": [
+            173,
+            329,
+            740,
+            345
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Runzhong Wang, Junchi Yan, and Xiaokang Yang. Learning combinatorial embedding networks for deep graph matching. In ICCV, 2019. ",
+        "bbox": [
+            174,
+            354,
+            823,
+            383
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "P. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010. ",
+        "bbox": [
+            173,
+            391,
+            823,
+            421
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hongteng Xu, Dixin Luo, and Lawrence Carin. Gromov-wasserstein learning for graph matching and node embedding. In ICML, 2019. ",
+        "bbox": [
+            173,
+            429,
+            823,
+            458
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Junchi Yan, Chao Zhang, Hongyuan Zha, Wei Liu, Xiaokang Yang, and Stephen M Chu. Discrete hyper-graph matching. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            497
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tianshu Yu, Junchi Yan, Yilin Wang, Wei Liu, and Baoxin Li. Generalizing graph matching beyond quadratic assignment model. In NIPS, 2018. ",
+        "bbox": [
+            173,
+            505,
+            823,
+            535
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Andrei Zanfir and Cristian Sminchisescu. Deep learning of graph matching. In CVPR, 2018. ",
+        "bbox": [
+            176,
+            542,
+            782,
+            559
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhen Zhang and Wee Sun Lee. Deep graphical feature learning for the feature matching problem. In ICCV, 2019. ",
+        "bbox": [
+            173,
+            566,
+            821,
+            595
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Feng Zhou and Fernando De la Torre. Factorized graph matching. In CVPR, 2012. ",
+        "bbox": [
+            176,
+            604,
+            715,
+            619
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            646,
+            299,
+            662
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 SYNTHETIC TEST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            678,
+            338,
+            691
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Synthetic graphs are generated for training and testing following the protocol in (Cho et al., 2010). Specifically, $K _ { p t }$ keypoints are generated for a pair of graphs with a 1024-dimensional random feature for each node, which is sampled from uniform distribution $\\mathcal { U } ( - 1 , 1 )$ . Disturbance is also applied to graph pairs including: Gaussian node feature noise from $\\mathcal { N } ( 0 , \\sigma _ { f t } ^ { 2 } )$ ; random affine transformation $\\left[ \\begin{array} { c c c } { s \\cos \\theta } & { - s \\sin \\theta } & { t _ { x } } \\\\ { s \\sin \\theta } & { s \\cos \\theta } & { t _ { y } } \\\\ { 0 } & { 0 } & { 1 } \\end{array} \\right] \\mathrm { w i t h } s \\sim \\mathcal { U } ( 0 . 8 , 1 . 2 ) , \\theta \\sim \\mathcal { U } ( - 6 0 , 6 0 ) , t _ { x } , t _ { y } \\sim \\mathcal { U } ( - 1 0 , 1 0 )$ ) followed by Gaussian coordinate position noise $\\mathcal { N } ( 0 , \\sigma _ { c o } ^ { 2 } )$ . By default we assign $K _ { p t } = 2 5 , \\sigma _ { f t } =$ $1 . 5 , \\sigma _ { c o } = 5$ . Two graphs share the same structure. We generate 10 random distributions for each test. Results are shown in Fig. 6. The performance of PCA and CIE is reported. We see our method significantly outperformed PCA. It can further be noticed that Hungarian attention can help to achieve an even higher accuracy. Readers are referred to Wang et al. (2019) for some other results on synthetic test. ",
+        "bbox": [
+            173,
+            703,
+            826,
+            888
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "However, we also notice that the way to generate synthetic graphs is much different from the distribution of real-world data. For real-world data, on one hand, there is strong correlation on the neighboring node features. This is the reason why the message passing from nearby node features works. However, the features of synthetic data are randomly generated and there is no correlation between neighboring node features. Therefore, message passing mechanism is not very effective to reveal the relation or pattern among local nodes for synthetic data. On the other hand, features of real-world data typically lie on a manifold embedded in high dimensional space, hence is low dimensional. However, randomly generated features will span the whole space and show no patterns. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/0bdc47cf84fa82623f197589bb25d188aadce99a4aae6bb0f564975f37535b81.jpg",
+        "image_caption": [
+            "Figure 6: Results on synthetic test where two different loss functions are compared in ablative study. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            101,
+            761,
+            262
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            304,
+            825,
+            388
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Taking into account the aforementioned factors, we believe there is a demand for a novel strategy to generate more reasonable synthetic data. This can be one of the future works. ",
+        "bbox": [
+            176,
+            395,
+            823,
+            424
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 COMPARISON OF PASCAL VOC AND WILLOW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            440,
+            534,
+            455
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As we claim that Willow dataset is biased compared with Pascal VOC dataset, we qualitatively show some randomly selected examples in Fig. 7. We select several images with the same class “car” from both datasets. We also choose images with “bird” from Pascal VOC and “duck” from Willow since they somewhat share similar semantic information. We see in either case, Pascal VOC contains more variation and degradation compared with Willow in terms of pose, scale, appearance, etc. In general, Willow dataset is easier for algorithms to learn. While there is a significant performance gap of PCA over these two datasets, the performance of CIE on Willow without fine-tune (Table 2) is consistent to the performance on Pascal VOC (Table 1). As such, we infer the performance degradation of CIE on “duck” in Willow test (Table 2) is due to such bias. The pre-trained CIE on Pascal VOC tends to produce more stable and higher average accuracy on all types of images, rather than focusing on “easy-to-learn” samples by PCA. This is a different learning strategy from PCA. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            621
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/18cf48c3d41aebd319e375e71f705827d516d774adb2765e95eed33d4761c7f8.jpg",
+        "image_caption": [
+            "Figure 7: Image examples from Pascal VOC and Willow. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            361,
+            808,
+            628
+        ],
+        "page_idx": 14
+    }
+]

parse/train/ryacTMZRZ/ryacTMZRZ.md

@@ -0,0 +1,256 @@
+# A CONVOLUTIONAL APPROACH TO LEARNING TIMESERIES SIMILARITY
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Computing distances between examples is at the core of many learning algorithms for time series. Consequently, a great deal of work has gone into designing effective time series distance measures. We present Jiffy, a simple and scalable distance metric for multivariate time series. Our approach is to reframe the task as a representation learning problem—rather than design an elaborate distance function, we use a CNN to learn an embedding such that the Euclidean distance is effective. By aggressively max-pooling and downsampling, we are able to construct this embedding using a highly compact neural network. Experiments on a diverse set of multivariate time series datasets show that our approach consistently outperforms existing methods.
+
+# 1 INTRODUCTION
+
+Measuring distances between examples is a fundamental component of many classification, clustering, segmentation and anomaly detection algorithms for time series (Rakthanmanon et al., 2012; Schafer, 2014; Begum et al., 2015; Dau et al., 2016). Because the distance measure used can have ¨ a significant effect on the quality of the results, there has been a great deal of work developing effective time series distance measures (Ganeshapillai & Guttag, 2011; Keogh et al., 2005; Bagnall et al., 2016; Begum et al., 2015; Ding et al., 2008). Historically, most of these measures have been hand-crafted. However, recent work has shown that a learning approach can often perform better than traditional techniques (Do et al., 2017; Mei et al., 2016; Che et al., 2017).
+
+We introduce a metric learning model for multivariate time series. Specifically, by learning to embed time series in Euclidean space, we obtain a metric that is both highly effective and simple to implement using modern machine learning libraries. Unlike many other deep metric learning approaches for time series, we use a convolutional, rather than a recurrent, neural network, to construct the embedding. This choice, in combination with aggressive maxpooling and downsampling, results in a compact, accurate network.
+
+Using a convolutional neural network for metric learning per se is not a novel idea (Oh Song et al., 2016; Schroff et al., 2015); however, time series present a set of challenges not seen together in other domains, and how best to embed them is far from obvious. In particular, time series suffer from:
+
+1. A lack of labeled data. Unlike text or images, time series cannot typically be annotated post-hoc by humans. This has given rise to efforts at unsupervised labeling (Blalock & Guttag, 2016), and is evidenced by the small size of most labeled time series datasets. Of the 85 datasets in the UCR archive (Chen et al., 2015), for example, the largest dataset has fewer than 17000 examples, and many have only a few hundred.   
+2. A lack of large corpora. In addition to the difficulty of obtaining labels, most researchers have no means of gathering even unlabeled time series at the same scale as images, videos, or text. Even the largest time series corpora, such as those on Physiobank (Goldberger et al., 2000), are tiny compared to the virtually limitless text, image, and video data available on the web.   
+3. Extraneous data. There is no guarantee that the beginning and end of a time series correspond to the beginning and end of any meaningful phenomenon. I.e., examples of the class or pattern of interest may take place in only a small interval within a much longer time series. The rest of the time series may be noise or transient phenomena between meaningful events (Rakthanmanon et al., 2011; Hao et al., 2013).
+
+4. Need for high speed. One consequence of the presence of extraneous data is that many time series algorithms compute distances using every window of data within a time series (Mueen et al., 2009; Blalock & Guttag, 2016; Rakthanmanon et al., 2011). A time series of length $T$ has $O ( T )$ windows of a given length, so it is essential that the operations done at each window be efficient.
+
+As a result of these challenges, an effective time series distance metric must exhibit the following properties:
+
+• Efficiency: Distance measurement must be fast, in terms of both training time and inference time. • Simplicity: As evidenced by the continued dominance of the Dynamic Time Warping (DTW) distance (Sakoe & Chiba, 1978) in the presence of more accurate but more complicated rivals, a distance measure must be simple to understand and implement. • Accuracy: Given a labeled dataset, the metric should yield a smaller distance between similarly labeled time series. This behavior should hold even for small training sets.
+
+Our primary contribution is a time series metric learning method, Jiffy, that exhibits all of these properties: it is fast at both training and inference time, simple to understand and implement, and consistently outperforms existing methods across a variety of datasets.
+
+We introduce the problem statement and the requisite definitions in Section 2. We summarize existing state-of-the-art approaches (both neural and non-neural) in Section 3 and go on to detail our own approach in Section 4. We then present our results in Section 5. The paper concludes with implications of our work and avenues for further research.
+
+# 2 PROBLEM DEFINITION
+
+We first define relevant terms, frame the problem, and state our assumptions.
+
+Definition 2.1. Time Series A $D$ -variable time series $X$ of length $T$ is a sequence of real-valued vectors ${ \bf x } _ { 1 } , \dots , { \bf x } _ { T } , { \bf x } _ { i } \in \mathbb { R } ^ { D }$ . If $D = 1$ , we call $X$ “univariate”, and if $D > 1$ , we call $X$ “multivariate.” We denote the space of possible $D$ -variable time series $\mathcal { T } ^ { D }$ .
+
+Definition 2.2. Distance Metric $A$ distance metric is defined a distance function $d : \mathcal { S } \times \mathcal { S }  \mathbb { R }$ over a set of objects $s$ such that, for any $x , y \in S$ , the following properties hold:
+
+• Symmetry: $d ( x , y ) = d ( y , x )$   
+• Non-negativity: $d ( x , y ) \geq 0$   
+• Triangle Inequality: $d ( x , z ) + d ( y , z ) \geq d ( x , z )$ • Identity of Indiscernibles: $x = y \Leftrightarrow d ( x , y ) = 0$
+
+Our approach to learning a metric is to first learn an embedding into a fixed-size vector space, and then use the Euclidean distance on the embedded vectors to measure similarity. Formally, we learn a function $f : \mathcal { T } ^ { D } \to \mathbb { R } ^ { N }$ and compute the distance between time series $X , Y \in \mathcal { T } ^ { D }$ as:
+
+$$
+d ( X , Y ) \triangleq \| f ( X ) - f ( Y ) \| _ { 2 }
+$$
+
+# 2.1 ASSUMPTIONS
+
+Jiffy depends on two assumptions about the time series being embedded. First, we assume that all time series are primarily “explained” by one class. This means that we do not consider multilabel tasks or tasks wherein only a small subsequence within each time series is associated with a particular label, while the rest is noise or phenomena for which we have no class label. This assumption is implicitly made by most existing work (Hu et al., 2013) and is satisfied whenever one has recordings of individual phenomena, such as gestures, heartbeats, or actions.
+
+The second assumption is that the time series dataset is not too small, in terms of either number of time series or their lengths. Specifically, we do not consider datasets in which the longest time series is of length $T < 4 0$ or the number of examples per class is less than 25. The former number is the smallest number such that our embedding will not be longer than the input in the univariate case, while the latter is the smallest number found in any of our experimental datasets (and therefore the smallest on which we can claim reasonable performance).
+
+For datasets too small to satisfy these constraints, we recommend using a traditional distance measure, such as Dynamic Time Warping, that does not rely on a learning phase.
+
+# 3 RELATED WORK
+
+# 3.1 HAND-CRAFTED DISTANCE MEASURES
+
+Historically, most work on distance measures between time series has consisted of hand-crafted algorithms designed to reflect prior knowledge about the nature of time series. By far the most prevalent is the Dynamic Time Warping (DTW) distance (Sakoe & Chiba, 1978). This is obtained by first aligning two time series using dynamic programming, and then computing the Euclidean distance between them. DTW requires time quadratic in the time series’ length in the worst case, but is effectively linear time when used for similarity search; this is thanks to numerous lower bounds that allow early abandoning of the computation in almost all cases (Rakthanmanon et al., 2012).
+
+Other handcrafted measures include the Uniform Scaling Distance (Keogh, 2003), the Scaled Warped Matching Distance (Fu et al., 2008), the Complexity-Invariant Distance (Batista et al., 2011), the Shotgun Distance (Schafer, 2014), and many variants of DTW, such as weighted DTW (Gane- ¨ shapillai & Guttag, 2011), DTW-A (Shokoohi-Yekta et al., 2015), and global alignment kernels (Cuturi, 2011). However, nearly all of these measures are defined only for univariate time series, and generalizing them to multivariate time series is not trivial (Shokoohi-Yekta et al., 2015).
+
+# 3.2 HAND-CRAFTED REPRESENTATIONS
+
+In addition to hand-crafted functions of raw time series, there are numerous hand-crafted representations of time series. Perhaps the most common are Symbolic Aggregate Approximation (SAX) (Lin et al., 2003) and its derivatives (Camerra et al., 2010; Senin & Malinchik, 2013). These are discretization techniques that low-pass filter, downsample, and quantize the time series so that they can be treated as strings. Slightly less lossy are Adaptive Piecewise Constant Approximation (Keogh et al., 2001a), Piecewise Aggregate Approximation (Keogh et al., 2001b), and related methods, which approximate time series as sequences of low-order polynomials.
+
+The most effective of these representations tend to be extremely complicated; the current state-ofthe-art (Schafer & Leser, 2017), for example, entails windowing, Fourier transformation, quantiza- ¨ tion, bigram extraction, and ANOVA F-tests, among other steps. Moreover, it is not obvious how to generalize them to multivariate time series.
+
+# 3.3 METRIC LEARNING FOR TIME SERIES
+
+A promising alternative to hand-crafted representations and distance functions for time series is metric learning. This can take the form of either learning a distance function directly or learning a representation that can be used with an existing distance function.
+
+Among the most well-known methods in the former category is that of (Ratanamahatana & Keogh, 2004a), which uses an iterative search to learn data-dependent constraints on DTW alignments. More recently, Mei et al. (2016) use a learned Mahalanobis distance to improve the accuracy of DTW. Both of these approaches yield only a pseudometric, which does not obey the triangle inequality. To come closer to a true metric, Che et al. (2017) combined a large-margin classification objective with a sampling step (even at test time) to create a DTW-like distance that obeys the triangle inequality with high probability as the sample size increases.
+
+In the second category are various works that learn to embed time series into Euclidean space. Pei et al. (2016) use recurrent neural networks in a Siamese architecture (Bromley et al., 1994) to learn an embedding; they optimize the embeddings to have positive inner products for time series of the same class but negative inner products for those of different classes. A similar approach that does not require class labels is that of Arnaud et al. (2017). This method trains a Siamese, single-layer
+
+CNN to embed time series in a space such that the pairwise Euclidean distances approximate the pairwise DTW distances. Lei et al. (2017) optimize a similar objective, but do so by sampling the pairwise distances and using matrix factorization to directly construct feature representations for the training set (i.e., with no model that could be applied to a separate test set).
+
+These methods seek to solve much the same problem as Jiffy but, as we show experimentally, produce metrics of much lower quality.
+
+# 4 METHOD
+
+We learn a metric by learning to embed time series into a vector space and comparing the resulting vectors with the Euclidean distance. Our embedding function is takes the form of a convolutional neural network, shown in Figure 1. The architecture rests on three basic layers: a convolutional layer, maxpooling layer, and a fully connected layer.
+
+The convolutional layer is included to learn the appropriate subsequences from the input. The network employs one-dimensional filters convolved over all time steps, in contrast to traditional twodimensional filters used with images. We opt for one-dimensional filters because time series data is characterized by infrequent sampling. Convolving over each of the variables at a given timestep has little intuitive meaning in developing an embedding when each step measurement has no coherent connection to time. For discussion regarding the mathematical connection between a learned convolutional filter and traditional subsequence-based analysis of time series, we direct the reader to (Cui et al., 2016).
+
+The maxpooling layer allows the network to be resilient to translational noise in the input time series. Unlike most existing neural network architectures, the windows over which we max pool are defined as percentages of the input length, not as constants. This level of pooling allows us to heavily downsample and denoise the input signal and is fed into the final fully connected layer.
+
+We downsample heavily after the filters are applied such that each time series is reduced to a fixed size. We do so primarily for efficiency—further discussion on parameter choice for Jiffy may be found in Section 6.
+
+We then train the network by appending a softmax layer and using cross-entropy loss with the ADAM (Kingma & Ba, 2014) optimizer. We experimented with more traditional metric learning loss functions, rather than a classification objective, but found that they made little or no difference while adding to the complexity of the training procedure; specific loss functions tested include several variations of Siamese networks (Bromley et al., 1994; Pei et al., 2016) and the triplet loss (Hoffer & Ailon, 2015).
+
+# 4.1 COMPLEXITY ANALYSIS
+
+For ease of comparison to more traditional distance measures, such as DTW, we present an analysis of Jiffy’s complexity.
+
+Let $T$ be the length of the $D$ -variable time series being embedded, let $F$ be the number of length $K$ filters used in the convolutional layer, and Let $L$ be the size of the final embedding. The time to apply the convolution and ReLU operations is $\Theta ( T D F K )$ . Following the convolutional layer, the maxpooling and downsampling require (T2DF) time if implemented naively, but (TDF) if an intelligent sliding max function is used, such as that of (Lemire, 2006). Finally, the fully connected layer, which constitutes the embedding, requires $\Theta ( T D F L )$ time.
+
+The total time to generate the embedding is therefore $\Theta ( T D F ( K + L ) )$ . Given the embeddings, computing the distance between two time series requires $\Theta ( L )$ time. Note that $T$ no longer appears in either expression thanks to the max pooling.
+
+With $F = 1 6$ , $K = 5$ , $L = 4 0$ , this computation is dominated by the fully connected layer. Consequently, when $L \ll T$ and embeddings can be generated ahead of time, this enables a significant speedup compared to operating on the original data. Such a situation would arise, e.g., when performing a similarity search between a new query and a fixed or slow-changing database (Blalock & Guttag, 2017). When both embeddings must be computed on-the-fly, our method is likely to be slower than DTW and other traditional approaches.
+
+![](images/dd1954eb73d7cbb7c7df34414e13bc50fe66598833624dcdda9f43e453658ede.jpg)  
+Figure 1: Architecture of the proposed model. A single convolutional layer extracts local features from the input, which a strided maxpool layer reduces to a fixed-size vector. A fully connected layer with ReLU activation carries out further, nonlinear dimensionality reduction to yield the embedding. A softmax layer is added at training time.
+
+# 5 EXPERIMENTS
+
+Before describing our experiments, we first note that, to ensure easy reproduction and extension of our work, all of our code is freely available.1 All of the datasets used are public, and we provide code to clean and operate on them.
+
+We evaluate Jiffy-produced embeddings through the task of 1-nearest-neighbor classification, which assesses the extent to which time series sharing the same label tend to be nearby in the embedded space. We choose this task because it is the most widely used benchmark for time series distance and similarity measures (Ding et al., 2008; Bagnall et al., 2016).
+
+# 5.1 DATASETS
+
+To enable direct comparison to existing methods, we benchmark Jiffy using datasets employed by Mei et al. (2016). These datasets are taken from various domains and exhibit high variability in the numbers of classes, examples, and variables. We briefly describe each dataset below, and summarize statistics about each in Table 1.
+
+Table 1: Summary of Multivariate Time Series Datasets.   
+
+<table><tr><td>Dataset</td><td>#Variables</td><td># Classes</td><td>Length</td><td># Time Series</td></tr><tr><td>Libras</td><td>2</td><td>15</td><td>45</td><td>360</td></tr><tr><td>AUSLAN</td><td>22</td><td>25</td><td>47-95</td><td>675</td></tr><tr><td>CharacterTrajectories</td><td>3</td><td>20</td><td>109-205</td><td>2858</td></tr><tr><td>ArabicDigits</td><td>13</td><td>10</td><td>4-93</td><td>8800</td></tr><tr><td>ECG</td><td>2</td><td>2</td><td>39 - 152</td><td>200</td></tr><tr><td>Wafer</td><td>6</td><td>2</td><td>104 - 198</td><td>1194</td></tr></table>
+
+• ECG: Electrical recordings of normal and abnormal heartbeats, as measured by two electrodes on the patients’ chests.
+
+• Wafer: Sensor data collected during the manufacture of semiconductor microelectronics, where the time series are labeled as normal or abnormal.
+
+• AUSLAN: Hand and finger positions during the performance of various signs in Australian Sign Language, measured via instrumented gloves.   
+• Trajectories: Recordings of pen (x,y) position and force application as different English characters are written with a pen.   
+• Libras: Hand and arm positions during the performance of various signs in Brazilian Sign Language, extracted from videos.   
+• ArabicDigits: Audio signals produced by utterances of Arabic digits, represented by MelFrequency Cepstral Coefficients.
+
+# 5.2 COMPARISON APPROACHES
+
+We compare to recent approaches to time series metric learning, as well as popular means of generalizing DTW to the multivariate case:
+
+1. MDDTW (Mei et al., 2016) - MDDTW compares time series using a combination of DTW and the Mahalanobis distance. It learns the precision matrix for the latter using a triplet loss.   
+2. Siamese RNN (Pei et al., 2016) - The Siamese RNN feeds each time series through a recurrent neural network and uses the hidden unit activations as the embedding. It trains by feeding pairs of time series through two copies of the network and computing errors based on their inner products in the embedded space.   
+3. Siamese CNN The Siamese CNN is similar to the Siamese RNN, but uses convolutional, rather than recurrent, neural networks. This approach has proven successful across several computer vision tasks (Bromley et al., 1994; Taigman et al., 2014).   
+4. DTW-I, DTW-D - As pointed out by Shokoohi-Yekta et al. (2015), there are two straightforward ways to generalize DTW to multivariate time series. The first is to treat the time series as $D$ independent sequences of scalars (DTW-I). In this case, one computes the DTW distance for each sequence separately, then sums the results. The second option is to treat the time series as one sequence of vectors (DTW-D). In this case, one runs DTW a single time, with elementwise distances equal to the squared Euclidean distances between the $D$ -dimensional elements.   
+5. Zero Padding - One means of obtaining a fixed-size vector representation of a multivariate time series is to zero-pad such that all time series are the same length, and then treat the “flattened” representation as a vector.   
+6. Upsampling - Like Zero Padding, but upsamples to the length of the longest time series rather than appending zeros. This approach is known to be effective for univariate time series (Ratanamahatana & Keogh, 2004b).
+
+# 5.3 ACCURACY
+
+As shown in Table 2, we match or exceed the performance of all comparison methods on each of the six datasets. Although it is not possible to claim statistical significance in the absence of more datasets (see Demsar (2006)), the average rank of our method compared to others is higher than its closest competitors at 1.16. The closest second, DTW-I, has an average rank of 3.33 over these six datasets.
+
+Not only does Jiffy attain higher classification accuracies than competing methods, but the method also remains consistent in its performance across datasets. This can most easily be seen through the standard deviation in classification accuracies across datasets for each method. Jiffy’s standard deviation in accuracy (0.026) is approximately a third of DTWI’s (0.071). The closest method in terms of variance is MDDTW with a standard deviation of 0.042 , which exhibits a much lower rank than our method. This consistency suggests that Jiffy generalizes well across domains, and would likely remain effective on other datasets not tested here.
+
+# 6 HYPERPARAMETER EFFECTS
+
+A natural question when considering the performance of a neural network is whether, or to what extent, the hyperparameters must be modified to achieve good performance on a new dataset. In this section, we explore the robustness of our approach with respect to the values of the two key parameters: embedding size and pooling percentage. We do this by learning metrics for a variety of parameter values for ten data sets from the UCR Time Series Archive (Chen et al., 2015), and evaluating how classification accuracy varies.
+
+Table 2: 1NN Classification Accuracy. The proposed method equals or exceeds the accuracies of all others on every dataset.   
+
+<table><tr><td>Dataset</td><td>Jiffy</td><td>MDDTW</td><td>DTW-D</td><td>DTW-I</td><td>Siamese CNN</td><td>Siamese RNN</td><td>Zero Pad</td><td>Upsample</td></tr><tr><td>ArabicDigits</td><td>0.974</td><td>0.969</td><td>0.963</td><td>0.974</td><td>0.851</td><td>0.375</td><td>0.967</td><td>0.898</td></tr><tr><td>AUSLAN</td><td>1.000</td><td>0.959</td><td>0.900</td><td>1.000</td><td>1.000</td><td>1.000</td><td>1.000</td><td>1.000</td></tr><tr><td>ECG</td><td>0.925</td><td>0.865</td><td>0.825</td><td>0.810</td><td>0.756</td><td>0.659</td><td>0.820</td><td>0.820</td></tr><tr><td>Libras</td><td>1.000</td><td>0.908</td><td>0.905</td><td>0.979</td><td>0.280</td><td>0.320</td><td>0.534</td><td>0.534</td></tr><tr><td>Trajectories</td><td>0.979</td><td>0.961</td><td>0.956</td><td>0.972</td><td>0.933</td><td>0.816</td><td>0.936</td><td>0.948</td></tr><tr><td>Wafer</td><td>0.992</td><td>0.988</td><td>0.984</td><td>0.861</td><td>0.968</td><td>0.954</td><td>0.945</td><td>0.936</td></tr><tr><td>MeanRank</td><td>1.67</td><td>3.67</td><td>4.67</td><td>3.33</td><td>6.0</td><td>6.5</td><td>4.17</td><td>4.5</td></tr></table>
+
+# 6.1 EMBEDDING SIZE
+
+![](images/5d090f858abf9f17907dd28fc9063688ca2988f9066150a93eb36e024d53a936.jpg)  
+Figure 2.left shows that even a few dozen neurons are sufficient to achieve peak accuracy. As a result, an embedding layer of 40 neurons is sufficient and leads to an architecture that is compact enough to run on a personal laptop.   
+Figure 2: Effect of fully connected layer size and degree of max pooling on model accuracy using held-out datasets. Even small fully connected layers and large amounts of max pooling— up to half of the length of the time series in some cases—have little or no effect on accuracy. For ease of visualization, each dataset’s accuracies are scaled such that the largest value is 1.0.
+
+# 6.2 POOLING PERCENTAGE
+
+The typical assumption in machine learning literature is that max pooling windows in convolutional architectures should be small to limit information loss. In contrast, time series algorithms often max pool globally across each example (e.g. (Grabocka et al., 2014)). Contrary to the implicit assumptions of both, we find that the level of pooling that results in the highest classification often falls in the $10 \%$ range, as shown by Figure 2.right
+
+# 7 CONCLUSION
+
+We present Jiffy, a simple and efficient metric learning approach to measuring multivariate time series similarity. We show that our method learns a metric that leads to consistent and accurate classification across a diverse range of multivariate time series. Jiffy’s resilience to hyperparameter choices and consistent performance across domains provide strong evidence for its utility on a wide range of time series datasets.
+
+Future work includes the extension of this approach to multi-label classification and unsupervised learning. There is also potential to further increase Jiffy’s speed by replacing the fully connected layer with a structured (Bojarski et al., 2016) or binarized (Rastegari et al., 2016) matrix.
+
+# REFERENCES
+
+Lods Arnaud, Simon Malinowski, Romain Tavenard, and Laurent Amsaleg. Learning dtwpreserving shapelets. In Sixteenth International Symposium on Intelligent Data Analysis (IDA 2017). Springer International Publishing, 2017.   
+Anthony Bagnall, Aaron Bostrom, James Large, and Jason Lines. The great time series classification bake off: An experimental evaluation of recently proposed algorithms. extended version. arXiv preprint arXiv:1602.01711, 2016.   
+Gustavo EAPA Batista, Xiaoyue Wang, and Eamonn J Keogh. A complexity-invariant distance measure for time series. In Proceedings of the 2011 SIAM International Conference on Data Mining, pp. 699–710. SIAM, 2011.   
+Nurjahan Begum, Liudmila Ulanova, Jun Wang, and Eamonn Keogh. Accelerating dynamic time warping clustering with a novel admissible pruning strategy. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 49–58. ACM, 2015.   
+Davis W Blalock and John V Guttag. Extract: Strong examples from weakly-labeled sensor data. In Data Mining (ICDM), 2016 IEEE 16th International Conference on, pp. 799–804. IEEE, 2016.   
+Davis W Blalock and John V Guttag. Bolt: Accelerated data mining with fast vector compression. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 727–735. ACM, 2017.   
+Mariusz Bojarski, Anna Choromanska, Krzysztof Choromanski, Francois Fagan, Cedric GouyPailler, Anne Morvan, Nouri Sakr, Tamas Sarlos, and Jamal Atif. Structured adaptive and random spinners for fast machine learning computations. arXiv preprint arXiv:1610.06209, 2016.   
+Jane Bromley, Isabelle Guyon, Yann LeCun, Eduard Sackinger, and Roopak Shah. Signature verifi- ¨ cation using a ”siamese” time delay neural network. In Advances in Neural Information Processing Systems, pp. 737–744, 1994.   
+Alessandro Camerra, Themis Palpanas, Jin Shieh, and Eamonn Keogh. isax 2.0: Indexing and mining one billion time series. In Data Mining (ICDM), 2010 IEEE 10th International Conference on, pp. 58–67. IEEE, 2010.   
+Zhengping Che, Xinran He, Ke Xu, and Yan Liu. Decade: A deep metric learning model for multivariate time series. 2017.   
+Yanping Chen, Eamonn Keogh, Bing Hu, Nurjahan Begum, Anthony Bagnall, Abdullah Mueen, and Gustavo Batista. The ucr time series classification archive, July 2015. www.cs.ucr.edu/ ˜eamonn/time_series_data/.   
+Zhicheng Cui, Wenlin Chen, and Yixin Chen. Multi-scale convolutional neural networks for time series classification. arXiv preprint arXiv:1603.06995, 2016.   
+Marco Cuturi. Fast global alignment kernels. In Proceedings of the 28th international conference on machine learning (ICML-11), pp. 929–936, 2011.
+
+Hoang Anh Dau, Nurjahan Begum, and Eamonn Keogh. Semi-supervision dramatically improves time series clustering under dynamic time warping. In Proceedings of the 25th ACM International on Conference on Information and Knowledge Management, pp. 999–1008. ACM, 2016.
+
+Janez Demsar. Statistical comparisons of classifiers over multiple data sets. Journal of Machine learning research, 7(Jan):1–30, 2006.
+
+Hui Ding, Goce Trajcevski, Peter Scheuermann, Xiaoyue Wang, and Eamonn Keogh. Querying and mining of time series data: experimental comparison of representations and distance measures. Proceedings of the VLDB Endowment, 1(2):1542–1552, 2008.
+
+Cao-Tri Do, Ahlame Douzal-Chouakria, Sylvain Marie, Mich ´ ele Rombaut, and Saeed Varasteh.\` Multi-modal and multi-scale temporal metric learning for a robust time series nearest neighbors classification. Information Sciences, 418:272–285, 2017.
+
+Ada Wai-Chee Fu, Eamonn Keogh, Leo Yung Lau, Chotirat Ann Ratanamahatana, and Raymond Chi-Wing Wong. Scaling and time warping in time series querying. The VLDB JournalThe International Journal on Very Large Data Bases, 17(4):899–921, 2008.
+
+Gartheeban Ganeshapillai and John V Guttag. Weighted time warping for temporal segmentation of multi-parameter physiological signals. 2011.
+
+Ary L Goldberger, Luis AN Amaral, Leon Glass, Jeffrey M Hausdorff, Plamen Ch Ivanov, Roger G Mark, Joseph E Mietus, George B Moody, Chung-Kang Peng, and H Eugene Stanley. Physiobank, physiotoolkit, and physionet. Circulation, 101(23):e215–e220, 2000.
+
+Josif Grabocka, Nicolas Schilling, Martin Wistuba, and Lars Schmidt-Thieme. Learning time-series shapelets. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 392–401. ACM, 2014.
+
+Yuan Hao, Yanping Chen, Jesin Zakaria, Bing Hu, Thanawin Rakthanmanon, and Eamonn Keogh. Towards never-ending learning from time series streams. In Proceedings of the 19th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 874–882. ACM, 2013.
+
+Elad Hoffer and Nir Ailon. Deep metric learning using triplet network. In International Workshop on Similarity-Based Pattern Recognition, pp. 84–92. Springer, 2015.
+
+Bing Hu, Yanping Chen, and Eamonn Keogh. Time series classification under more realistic assumptions. In Proceedings of the 2013 SIAM International Conference on Data Mining, pp. 578–586. SIAM, 2013.
+
+Eamonn Keogh. Efficiently finding arbitrarily scaled patterns in massive time series databases. In European Conference on Principles of Data Mining and Knowledge Discovery, pp. 253–265. Springer, 2003.
+
+Eamonn Keogh, Kaushik Chakrabarti, Michael Pazzani, and Sharad Mehrotra. Locally adaptive dimensionality reduction for indexing large time series databases. ACM Sigmod Record, 30(2): 151–162, 2001a.
+
+Eamonn Keogh, Kaushik Chakrabarti, Michael Pazzani, and Sharad Mehrotra. Dimensionality reduction for fast similarity search in large time series databases. Knowledge and information Systems, 3(3):263–286, 2001b.
+
+Eamonn Keogh, Jessica Lin, and Ada Fu. Hot sax: Efficiently finding the most unusual time series subsequence. In Data mining, fifth IEEE international conference on, pp. 8–pp. Ieee, 2005.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Qi Lei, Jinfeng Yi, Roman Vaculin, Lingfei Wu, and Inderjit S Dhillon. Similarity preserving representation learning for time series analysis. arXiv preprint arXiv:1702.03584, 2017.
+
+Daniel Lemire. Streaming maximum-minimum filter using no more than three comparisons per element. arXiv preprint cs/0610046, 2006.
+
+Jessica Lin, Eamonn Keogh, Stefano Lonardi, and Bill Chiu. A symbolic representation of time series, with implications for streaming algorithms. In Proceedings of the 8th ACM SIGMOD workshop on Research issues in data mining and knowledge discovery, pp. 2–11. ACM, 2003.
+
+Jiangyuan Mei, Meizhu Liu, Yuan-Fang Wang, and Huijun Gao. Learning a mahalanobis distancebased dynamic time warping measure for multivariate time series classification. IEEE transactions on Cybernetics, 46(6):1363–1374, 2016.
+
+Abdullah Mueen, Eamonn Keogh, Qiang Zhu, Sydney Cash, and Brandon Westover. Exact discovery of time series motifs. In Proceedings of the 2009 SIAM International Conference on Data Mining, pp. 473–484. SIAM, 2009.
+
+Hyun Oh Song, Yu Xiang, Stefanie Jegelka, and Silvio Savarese. Deep metric learning via lifted structured feature embedding. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4004–4012, 2016.
+
+Wenjie Pei, David MJ Tax, and Laurens van der Maaten. Modeling time series similarity with siamese recurrent networks. arXiv preprint arXiv:1603.04713, 2016.
+
+Thanawin Rakthanmanon, Eamonn J Keogh, Stefano Lonardi, and Scott Evans. Time series epenthesis: Clustering time series streams requires ignoring some data. In Data Mining (ICDM), 2011 IEEE 11th International Conference on, pp. 547–556. IEEE, 2011.
+
+Thanawin Rakthanmanon, Bilson Campana, Abdullah Mueen, Gustavo Batista, Brandon Westover, Qiang Zhu, Jesin Zakaria, and Eamonn Keogh. Searching and mining trillions of time series subsequences under dynamic time warping. In Proceedings of the 18th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 262–270. ACM, 2012.
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, pp. 525–542. Springer, 2016.
+
+Chotirat Ann Ratanamahatana and Eamonn Keogh. Making time-series classification more accurate using learned constraints. In Proceedings of the 2004 SIAM International Conference on Data Mining, pp. 11–22. SIAM, 2004a.
+
+Chotirat Ann Ratanamahatana and Eamonn Keogh. Everything you know about dynamic time warping is wrong. In Third Workshop on Mining Temporal and Sequential Data, pp. 22–25. Citeseer, 2004b.
+
+Hiroaki Sakoe and Seibi Chiba. Dynamic programming algorithm optimization for spoken word recognition. IEEE transactions on acoustics, speech, and signal processing, 26(1):43–49, 1978.
+
+Patrick Schafer. Towards time series classification without human preprocessing. In ¨ International Workshop on Machine Learning and Data Mining in Pattern Recognition, pp. 228–242. Springer, 2014.
+
+Patrick Schafer and Ulf Leser. Fast and accurate time series classification with weasel. ¨ arXiv preprint arXiv:1701.07681, 2017.
+
+Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 815–823, 2015.
+
+Pavel Senin and Sergey Malinchik. Sax-vsm: Interpretable time series classification using sax and vector space model. In Data Mining (ICDM), 2013 IEEE 13th International Conference on, pp. 1175–1180. IEEE, 2013.
+
+Mohammad Shokoohi-Yekta, Jun Wang, and Eamonn Keogh. On the non-trivial generalization of dynamic time warping to the multi-dimensional case. In Proceedings of the 2015 SIAM International Conference on Data Mining, pp. 289–297. SIAM, 2015.
+
+Yaniv Taigman, Ming Yang, Marc’Aurelio Ranzato, and Lior Wolf. Deepface: Closing the gap to human-level performance in face verification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1701–1708, 2014.

parse/train/ryacTMZRZ/ryacTMZRZ_content_list.json

@@ -0,0 +1,1308 @@
+[
+    {
+        "type": "text",
+        "text": "A CONVOLUTIONAL APPROACH TO LEARNING TIMESERIES SIMILARITY",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Computing distances between examples is at the core of many learning algorithms for time series. Consequently, a great deal of work has gone into designing effective time series distance measures. We present Jiffy, a simple and scalable distance metric for multivariate time series. Our approach is to reframe the task as a representation learning problem—rather than design an elaborate distance function, we use a CNN to learn an embedding such that the Euclidean distance is effective. By aggressively max-pooling and downsampling, we are able to construct this embedding using a highly compact neural network. Experiments on a diverse set of multivariate time series datasets show that our approach consistently outperforms existing methods. ",
+        "bbox": [
+            191,
+            270,
+            807,
+            395
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            336,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Measuring distances between examples is a fundamental component of many classification, clustering, segmentation and anomaly detection algorithms for time series (Rakthanmanon et al., 2012; Schafer, 2014; Begum et al., 2015; Dau et al., 2016). Because the distance measure used can have ¨ a significant effect on the quality of the results, there has been a great deal of work developing effective time series distance measures (Ganeshapillai & Guttag, 2011; Keogh et al., 2005; Bagnall et al., 2016; Begum et al., 2015; Ding et al., 2008). Historically, most of these measures have been hand-crafted. However, recent work has shown that a learning approach can often perform better than traditional techniques (Do et al., 2017; Mei et al., 2016; Che et al., 2017). ",
+        "bbox": [
+            174,
+            464,
+            825,
+            575
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce a metric learning model for multivariate time series. Specifically, by learning to embed time series in Euclidean space, we obtain a metric that is both highly effective and simple to implement using modern machine learning libraries. Unlike many other deep metric learning approaches for time series, we use a convolutional, rather than a recurrent, neural network, to construct the embedding. This choice, in combination with aggressive maxpooling and downsampling, results in a compact, accurate network. ",
+        "bbox": [
+            174,
+            583,
+            823,
+            666
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Using a convolutional neural network for metric learning per se is not a novel idea (Oh Song et al., 2016; Schroff et al., 2015); however, time series present a set of challenges not seen together in other domains, and how best to embed them is far from obvious. In particular, time series suffer from: ",
+        "bbox": [
+            174,
+            672,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. A lack of labeled data. Unlike text or images, time series cannot typically be annotated post-hoc by humans. This has given rise to efforts at unsupervised labeling (Blalock & Guttag, 2016), and is evidenced by the small size of most labeled time series datasets. Of the 85 datasets in the UCR archive (Chen et al., 2015), for example, the largest dataset has fewer than 17000 examples, and many have only a few hundred.   \n2. A lack of large corpora. In addition to the difficulty of obtaining labels, most researchers have no means of gathering even unlabeled time series at the same scale as images, videos, or text. Even the largest time series corpora, such as those on Physiobank (Goldberger et al., 2000), are tiny compared to the virtually limitless text, image, and video data available on the web.   \n3. Extraneous data. There is no guarantee that the beginning and end of a time series correspond to the beginning and end of any meaningful phenomenon. I.e., examples of the class or pattern of interest may take place in only a small interval within a much longer time series. The rest of the time series may be noise or transient phenomena between meaningful events (Rakthanmanon et al., 2011; Hao et al., 2013). ",
+        "bbox": [
+            168,
+            729,
+            826,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "4. Need for high speed. One consequence of the presence of extraneous data is that many time series algorithms compute distances using every window of data within a time series (Mueen et al., 2009; Blalock & Guttag, 2016; Rakthanmanon et al., 2011). A time series of length $T$ has $O ( T )$ windows of a given length, so it is essential that the operations done at each window be efficient. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As a result of these challenges, an effective time series distance metric must exhibit the following properties: ",
+        "bbox": [
+            174,
+            171,
+            823,
+            199
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Efficiency: Distance measurement must be fast, in terms of both training time and inference time. • Simplicity: As evidenced by the continued dominance of the Dynamic Time Warping (DTW) distance (Sakoe & Chiba, 1978) in the presence of more accurate but more complicated rivals, a distance measure must be simple to understand and implement. • Accuracy: Given a labeled dataset, the metric should yield a smaller distance between similarly labeled time series. This behavior should hold even for small training sets. ",
+        "bbox": [
+            176,
+            212,
+            826,
+            306
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our primary contribution is a time series metric learning method, Jiffy, that exhibits all of these properties: it is fast at both training and inference time, simple to understand and implement, and consistently outperforms existing methods across a variety of datasets. ",
+        "bbox": [
+            176,
+            318,
+            821,
+            359
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We introduce the problem statement and the requisite definitions in Section 2. We summarize existing state-of-the-art approaches (both neural and non-neural) in Section 3 and go on to detail our own approach in Section 4. We then present our results in Section 5. The paper concludes with implications of our work and avenues for further research. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PROBLEM DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            443,
+            393,
+            459
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first define relevant terms, frame the problem, and state our assumptions. ",
+        "bbox": [
+            173,
+            474,
+            676,
+            489
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.1. Time Series A $D$ -variable time series $X$ of length $T$ is a sequence of real-valued vectors ${ \\bf x } _ { 1 } , \\dots , { \\bf x } _ { T } , { \\bf x } _ { i } \\in \\mathbb { R } ^ { D }$ . If $D = 1$ , we call $X$ “univariate”, and if $D > 1$ , we call $X$ “multivariate.” We denote the space of possible $D$ -variable time series $\\mathcal { T } ^ { D }$ . ",
+        "bbox": [
+            174,
+            493,
+            825,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.2. Distance Metric $A$ distance metric is defined a distance function $d : \\mathcal { S } \\times \\mathcal { S }  \\mathbb { R }$ over a set of objects $s$ such that, for any $x , y \\in S$ , the following properties hold: ",
+        "bbox": [
+            168,
+            540,
+            823,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Symmetry: $d ( x , y ) = d ( y , x )$   \n• Non-negativity: $d ( x , y ) \\geq 0$   \n• Triangle Inequality: $d ( x , z ) + d ( y , z ) \\geq d ( x , z )$ • Identity of Indiscernibles: $x = y \\Leftrightarrow d ( x , y ) = 0$ ",
+        "bbox": [
+            176,
+            580,
+            508,
+            670
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our approach to learning a metric is to first learn an embedding into a fixed-size vector space, and then use the Euclidean distance on the embedded vectors to measure similarity. Formally, we learn a function $f : \\mathcal { T } ^ { D } \\to \\mathbb { R } ^ { N }$ and compute the distance between time series $X , Y \\in \\mathcal { T } ^ { D }$ as: ",
+        "bbox": [
+            174,
+            681,
+            823,
+            723
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/88bd1f20205b1e38f51cffd560f57dc33338c751ff72cfe030548b5b58417a23.jpg",
+        "text": "$$\nd ( X , Y ) \\triangleq \\| f ( X ) - f ( Y ) \\| _ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            731,
+            598,
+            751
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 ASSUMPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            765,
+            316,
+            779
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Jiffy depends on two assumptions about the time series being embedded. First, we assume that all time series are primarily “explained” by one class. This means that we do not consider multilabel tasks or tasks wherein only a small subsequence within each time series is associated with a particular label, while the rest is noise or phenomena for which we have no class label. This assumption is implicitly made by most existing work (Hu et al., 2013) and is satisfied whenever one has recordings of individual phenomena, such as gestures, heartbeats, or actions. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The second assumption is that the time series dataset is not too small, in terms of either number of time series or their lengths. Specifically, we do not consider datasets in which the longest time series is of length $T < 4 0$ or the number of examples per class is less than 25. The former number is the smallest number such that our embedding will not be longer than the input in the univariate case, while the latter is the smallest number found in any of our experimental datasets (and therefore the smallest on which we can claim reasonable performance). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For datasets too small to satisfy these constraints, we recommend using a traditional distance measure, such as Dynamic Time Warping, that does not rely on a learning phase. ",
+        "bbox": [
+            171,
+            152,
+            821,
+            181
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            203,
+            344,
+            219
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 HAND-CRAFTED DISTANCE MEASURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            234,
+            490,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Historically, most work on distance measures between time series has consisted of hand-crafted algorithms designed to reflect prior knowledge about the nature of time series. By far the most prevalent is the Dynamic Time Warping (DTW) distance (Sakoe & Chiba, 1978). This is obtained by first aligning two time series using dynamic programming, and then computing the Euclidean distance between them. DTW requires time quadratic in the time series’ length in the worst case, but is effectively linear time when used for similarity search; this is thanks to numerous lower bounds that allow early abandoning of the computation in almost all cases (Rakthanmanon et al., 2012). ",
+        "bbox": [
+            174,
+            262,
+            825,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Other handcrafted measures include the Uniform Scaling Distance (Keogh, 2003), the Scaled Warped Matching Distance (Fu et al., 2008), the Complexity-Invariant Distance (Batista et al., 2011), the Shotgun Distance (Schafer, 2014), and many variants of DTW, such as weighted DTW (Gane- ¨ shapillai & Guttag, 2011), DTW-A (Shokoohi-Yekta et al., 2015), and global alignment kernels (Cuturi, 2011). However, nearly all of these measures are defined only for univariate time series, and generalizing them to multivariate time series is not trivial (Shokoohi-Yekta et al., 2015). ",
+        "bbox": [
+            174,
+            366,
+            825,
+            449
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 HAND-CRAFTED REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            468,
+            467,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In addition to hand-crafted functions of raw time series, there are numerous hand-crafted representations of time series. Perhaps the most common are Symbolic Aggregate Approximation (SAX) (Lin et al., 2003) and its derivatives (Camerra et al., 2010; Senin & Malinchik, 2013). These are discretization techniques that low-pass filter, downsample, and quantize the time series so that they can be treated as strings. Slightly less lossy are Adaptive Piecewise Constant Approximation (Keogh et al., 2001a), Piecewise Aggregate Approximation (Keogh et al., 2001b), and related methods, which approximate time series as sequences of low-order polynomials. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The most effective of these representations tend to be extremely complicated; the current state-ofthe-art (Schafer & Leser, 2017), for example, entails windowing, Fourier transformation, quantiza- ¨ tion, bigram extraction, and ANOVA F-tests, among other steps. Moreover, it is not obvious how to generalize them to multivariate time series. ",
+        "bbox": [
+            174,
+            599,
+            823,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 METRIC LEARNING FOR TIME SERIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            674,
+            478,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A promising alternative to hand-crafted representations and distance functions for time series is metric learning. This can take the form of either learning a distance function directly or learning a representation that can be used with an existing distance function. ",
+        "bbox": [
+            176,
+            700,
+            825,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Among the most well-known methods in the former category is that of (Ratanamahatana & Keogh, 2004a), which uses an iterative search to learn data-dependent constraints on DTW alignments. More recently, Mei et al. (2016) use a learned Mahalanobis distance to improve the accuracy of DTW. Both of these approaches yield only a pseudometric, which does not obey the triangle inequality. To come closer to a true metric, Che et al. (2017) combined a large-margin classification objective with a sampling step (even at test time) to create a DTW-like distance that obeys the triangle inequality with high probability as the sample size increases. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the second category are various works that learn to embed time series into Euclidean space. Pei et al. (2016) use recurrent neural networks in a Siamese architecture (Bromley et al., 1994) to learn an embedding; they optimize the embeddings to have positive inner products for time series of the same class but negative inner products for those of different classes. A similar approach that does not require class labels is that of Arnaud et al. (2017). This method trains a Siamese, single-layer ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CNN to embed time series in a space such that the pairwise Euclidean distances approximate the pairwise DTW distances. Lei et al. (2017) optimize a similar objective, but do so by sampling the pairwise distances and using matrix factorization to directly construct feature representations for the training set (i.e., with no model that could be applied to a separate test set). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "These methods seek to solve much the same problem as Jiffy but, as we show experimentally, produce metrics of much lower quality. ",
+        "bbox": [
+            174,
+            166,
+            821,
+            195
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            213,
+            282,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We learn a metric by learning to embed time series into a vector space and comparing the resulting vectors with the Euclidean distance. Our embedding function is takes the form of a convolutional neural network, shown in Figure 1. The architecture rests on three basic layers: a convolutional layer, maxpooling layer, and a fully connected layer. ",
+        "bbox": [
+            174,
+            246,
+            823,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The convolutional layer is included to learn the appropriate subsequences from the input. The network employs one-dimensional filters convolved over all time steps, in contrast to traditional twodimensional filters used with images. We opt for one-dimensional filters because time series data is characterized by infrequent sampling. Convolving over each of the variables at a given timestep has little intuitive meaning in developing an embedding when each step measurement has no coherent connection to time. For discussion regarding the mathematical connection between a learned convolutional filter and traditional subsequence-based analysis of time series, we direct the reader to (Cui et al., 2016). ",
+        "bbox": [
+            174,
+            308,
+            825,
+            420
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The maxpooling layer allows the network to be resilient to translational noise in the input time series. Unlike most existing neural network architectures, the windows over which we max pool are defined as percentages of the input length, not as constants. This level of pooling allows us to heavily downsample and denoise the input signal and is fed into the final fully connected layer. ",
+        "bbox": [
+            174,
+            426,
+            823,
+            482
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We downsample heavily after the filters are applied such that each time series is reduced to a fixed size. We do so primarily for efficiency—further discussion on parameter choice for Jiffy may be found in Section 6. ",
+        "bbox": [
+            176,
+            489,
+            823,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We then train the network by appending a softmax layer and using cross-entropy loss with the ADAM (Kingma & Ba, 2014) optimizer. We experimented with more traditional metric learning loss functions, rather than a classification objective, but found that they made little or no difference while adding to the complexity of the training procedure; specific loss functions tested include several variations of Siamese networks (Bromley et al., 1994; Pei et al., 2016) and the triplet loss (Hoffer & Ailon, 2015). ",
+        "bbox": [
+            174,
+            537,
+            825,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 COMPLEXITY ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            666,
+            382,
+            680
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For ease of comparison to more traditional distance measures, such as DTW, we present an analysis of Jiffy’s complexity. ",
+        "bbox": [
+            171,
+            693,
+            823,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $T$ be the length of the $D$ -variable time series being embedded, let $F$ be the number of length $K$ filters used in the convolutional layer, and Let $L$ be the size of the final embedding. The time to apply the convolution and ReLU operations is $\\Theta ( T D F K )$ . Following the convolutional layer, the maxpooling and downsampling require (T2DF) time if implemented naively, but (TDF) if an intelligent sliding max function is used, such as that of (Lemire, 2006). Finally, the fully connected layer, which constitutes the embedding, requires $\\Theta ( T D F L )$ time. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            813
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The total time to generate the embedding is therefore $\\Theta ( T D F ( K + L ) )$ . Given the embeddings, computing the distance between two time series requires $\\Theta ( L )$ time. Note that $T$ no longer appears in either expression thanks to the max pooling. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With $F = 1 6$ , $K = 5$ , $L = 4 0$ , this computation is dominated by the fully connected layer. Consequently, when $L \\ll T$ and embeddings can be generated ahead of time, this enables a significant speedup compared to operating on the original data. Such a situation would arise, e.g., when performing a similarity search between a new query and a fixed or slow-changing database (Blalock & Guttag, 2017). When both embeddings must be computed on-the-fly, our method is likely to be slower than DTW and other traditional approaches. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd1954eb73d7cbb7c7df34414e13bc50fe66598833624dcdda9f43e453658ede.jpg",
+        "image_caption": [
+            "Figure 1: Architecture of the proposed model. A single convolutional layer extracts local features from the input, which a strided maxpool layer reduces to a fixed-size vector. A fully connected layer with ReLU activation carries out further, nonlinear dimensionality reduction to yield the embedding. A softmax layer is added at training time. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            97,
+            795,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            378,
+            823,
+            407
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            326,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Before describing our experiments, we first note that, to ensure easy reproduction and extension of our work, all of our code is freely available.1 All of the datasets used are public, and we provide code to clean and operate on them. ",
+        "bbox": [
+            176,
+            464,
+            823,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate Jiffy-produced embeddings through the task of 1-nearest-neighbor classification, which assesses the extent to which time series sharing the same label tend to be nearby in the embedded space. We choose this task because it is the most widely used benchmark for time series distance and similarity measures (Ding et al., 2008; Bagnall et al., 2016). ",
+        "bbox": [
+            174,
+            513,
+            825,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            590,
+            287,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To enable direct comparison to existing methods, we benchmark Jiffy using datasets employed by Mei et al. (2016). These datasets are taken from various domains and exhibit high variability in the numbers of classes, examples, and variables. We briefly describe each dataset below, and summarize statistics about each in Table 1. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0b4f21bcdbc016c41a0e98fd41c53a73d4c9a75e8f80c39af259805647b5587.jpg",
+        "table_caption": [
+            "Table 1: Summary of Multivariate Time Series Datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>#Variables</td><td># Classes</td><td>Length</td><td># Time Series</td></tr><tr><td>Libras</td><td>2</td><td>15</td><td>45</td><td>360</td></tr><tr><td>AUSLAN</td><td>22</td><td>25</td><td>47-95</td><td>675</td></tr><tr><td>CharacterTrajectories</td><td>3</td><td>20</td><td>109-205</td><td>2858</td></tr><tr><td>ArabicDigits</td><td>13</td><td>10</td><td>4-93</td><td>8800</td></tr><tr><td>ECG</td><td>2</td><td>2</td><td>39 - 152</td><td>200</td></tr><tr><td>Wafer</td><td>6</td><td>2</td><td>104 - 198</td><td>1194</td></tr></table>",
+        "bbox": [
+            232,
+            715,
+            761,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• ECG: Electrical recordings of normal and abnormal heartbeats, as measured by two electrodes on the patients’ chests. ",
+        "bbox": [
+            173,
+            832,
+            823,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Wafer: Sensor data collected during the manufacture of semiconductor microelectronics, where the time series are labeled as normal or abnormal. ",
+        "bbox": [
+            178,
+            867,
+            823,
+            896
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• AUSLAN: Hand and finger positions during the performance of various signs in Australian Sign Language, measured via instrumented gloves.   \n• Trajectories: Recordings of pen (x,y) position and force application as different English characters are written with a pen.   \n• Libras: Hand and arm positions during the performance of various signs in Brazilian Sign Language, extracted from videos.   \n• ArabicDigits: Audio signals produced by utterances of Arabic digits, represented by MelFrequency Cepstral Coefficients. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 COMPARISON APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            248,
+            406,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare to recent approaches to time series metric learning, as well as popular means of generalizing DTW to the multivariate case: ",
+        "bbox": [
+            174,
+            275,
+            823,
+            303
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. MDDTW (Mei et al., 2016) - MDDTW compares time series using a combination of DTW and the Mahalanobis distance. It learns the precision matrix for the latter using a triplet loss.   \n2. Siamese RNN (Pei et al., 2016) - The Siamese RNN feeds each time series through a recurrent neural network and uses the hidden unit activations as the embedding. It trains by feeding pairs of time series through two copies of the network and computing errors based on their inner products in the embedded space.   \n3. Siamese CNN The Siamese CNN is similar to the Siamese RNN, but uses convolutional, rather than recurrent, neural networks. This approach has proven successful across several computer vision tasks (Bromley et al., 1994; Taigman et al., 2014).   \n4. DTW-I, DTW-D - As pointed out by Shokoohi-Yekta et al. (2015), there are two straightforward ways to generalize DTW to multivariate time series. The first is to treat the time series as $D$ independent sequences of scalars (DTW-I). In this case, one computes the DTW distance for each sequence separately, then sums the results. The second option is to treat the time series as one sequence of vectors (DTW-D). In this case, one runs DTW a single time, with elementwise distances equal to the squared Euclidean distances between the $D$ -dimensional elements.   \n5. Zero Padding - One means of obtaining a fixed-size vector representation of a multivariate time series is to zero-pad such that all time series are the same length, and then treat the “flattened” representation as a vector.   \n6. Upsampling - Like Zero Padding, but upsamples to the length of the longest time series rather than appending zeros. This approach is known to be effective for univariate time series (Ratanamahatana & Keogh, 2004b). ",
+        "bbox": [
+            166,
+            315,
+            825,
+            607
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.3 ACCURACY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            625,
+            294,
+            638
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 2, we match or exceed the performance of all comparison methods on each of the six datasets. Although it is not possible to claim statistical significance in the absence of more datasets (see Demsar (2006)), the average rank of our method compared to others is higher than its closest competitors at 1.16. The closest second, DTW-I, has an average rank of 3.33 over these six datasets. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Not only does Jiffy attain higher classification accuracies than competing methods, but the method also remains consistent in its performance across datasets. This can most easily be seen through the standard deviation in classification accuracies across datasets for each method. Jiffy’s standard deviation in accuracy (0.026) is approximately a third of DTWI’s (0.071). The closest method in terms of variance is MDDTW with a standard deviation of 0.042 , which exhibits a much lower rank than our method. This consistency suggests that Jiffy generalizes well across domains, and would likely remain effective on other datasets not tested here. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 HYPERPARAMETER EFFECTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            444,
+            880
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A natural question when considering the performance of a neural network is whether, or to what extent, the hyperparameters must be modified to achieve good performance on a new dataset. In this section, we explore the robustness of our approach with respect to the values of the two key parameters: embedding size and pooling percentage. We do this by learning metrics for a variety of parameter values for ten data sets from the UCR Time Series Archive (Chen et al., 2015), and evaluating how classification accuracy varies. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f2dd96747b1353ecd51658ed6b3f8bfc6c24987eb8b7afb6c1171ef25335c3f4.jpg",
+        "table_caption": [
+            "Table 2: 1NN Classification Accuracy. The proposed method equals or exceeds the accuracies of all others on every dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Jiffy</td><td>MDDTW</td><td>DTW-D</td><td>DTW-I</td><td>Siamese CNN</td><td>Siamese RNN</td><td>Zero Pad</td><td>Upsample</td></tr><tr><td>ArabicDigits</td><td>0.974</td><td>0.969</td><td>0.963</td><td>0.974</td><td>0.851</td><td>0.375</td><td>0.967</td><td>0.898</td></tr><tr><td>AUSLAN</td><td>1.000</td><td>0.959</td><td>0.900</td><td>1.000</td><td>1.000</td><td>1.000</td><td>1.000</td><td>1.000</td></tr><tr><td>ECG</td><td>0.925</td><td>0.865</td><td>0.825</td><td>0.810</td><td>0.756</td><td>0.659</td><td>0.820</td><td>0.820</td></tr><tr><td>Libras</td><td>1.000</td><td>0.908</td><td>0.905</td><td>0.979</td><td>0.280</td><td>0.320</td><td>0.534</td><td>0.534</td></tr><tr><td>Trajectories</td><td>0.979</td><td>0.961</td><td>0.956</td><td>0.972</td><td>0.933</td><td>0.816</td><td>0.936</td><td>0.948</td></tr><tr><td>Wafer</td><td>0.992</td><td>0.988</td><td>0.984</td><td>0.861</td><td>0.968</td><td>0.954</td><td>0.945</td><td>0.936</td></tr><tr><td>MeanRank</td><td>1.67</td><td>3.67</td><td>4.67</td><td>3.33</td><td>6.0</td><td>6.5</td><td>4.17</td><td>4.5</td></tr></table>",
+        "bbox": [
+            173,
+            135,
+            844,
+            267
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            287,
+            825,
+            344
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.1 EMBEDDING SIZE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            381,
+            338,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d090f858abf9f17907dd28fc9063688ca2988f9066150a93eb36e024d53a936.jpg",
+        "image_caption": [
+            "Figure 2.left shows that even a few dozen neurons are sufficient to achieve peak accuracy. As a result, an embedding layer of 40 neurons is sufficient and leads to an architecture that is compact enough to run on a personal laptop. ",
+            "Figure 2: Effect of fully connected layer size and degree of max pooling on model accuracy using held-out datasets. Even small fully connected layers and large amounts of max pooling— up to half of the length of the time series in some cases—have little or no effect on accuracy. For ease of visualization, each dataset’s accuracies are scaled such that the largest value is 1.0. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            460,
+            820,
+            718
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 POOLING PERCENTAGE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            821,
+            375,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The typical assumption in machine learning literature is that max pooling windows in convolutional architectures should be small to limit information loss. In contrast, time series algorithms often max pool globally across each example (e.g. (Grabocka et al., 2014)). Contrary to the implicit assumptions of both, we find that the level of pooling that results in the highest classification often falls in the $10 \\%$ range, as shown by Figure 2.right ",
+        "bbox": [
+            174,
+            854,
+            825,
+            925
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present Jiffy, a simple and efficient metric learning approach to measuring multivariate time series similarity. We show that our method learns a metric that leads to consistent and accurate classification across a diverse range of multivariate time series. Jiffy’s resilience to hyperparameter choices and consistent performance across domains provide strong evidence for its utility on a wide range of time series datasets. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Future work includes the extension of this approach to multi-label classification and unsupervised learning. There is also potential to further increase Jiffy’s speed by replacing the fully connected layer with a structured (Bojarski et al., 2016) or binarized (Rastegari et al., 2016) matrix. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            252
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            275,
+            285,
+            289
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lods Arnaud, Simon Malinowski, Romain Tavenard, and Laurent Amsaleg. Learning dtwpreserving shapelets. In Sixteenth International Symposium on Intelligent Data Analysis (IDA 2017). Springer International Publishing, 2017.   \nAnthony Bagnall, Aaron Bostrom, James Large, and Jason Lines. The great time series classification bake off: An experimental evaluation of recently proposed algorithms. extended version. arXiv preprint arXiv:1602.01711, 2016.   \nGustavo EAPA Batista, Xiaoyue Wang, and Eamonn J Keogh. A complexity-invariant distance measure for time series. In Proceedings of the 2011 SIAM International Conference on Data Mining, pp. 699–710. SIAM, 2011.   \nNurjahan Begum, Liudmila Ulanova, Jun Wang, and Eamonn Keogh. Accelerating dynamic time warping clustering with a novel admissible pruning strategy. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 49–58. ACM, 2015.   \nDavis W Blalock and John V Guttag. Extract: Strong examples from weakly-labeled sensor data. In Data Mining (ICDM), 2016 IEEE 16th International Conference on, pp. 799–804. IEEE, 2016.   \nDavis W Blalock and John V Guttag. Bolt: Accelerated data mining with fast vector compression. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 727–735. ACM, 2017.   \nMariusz Bojarski, Anna Choromanska, Krzysztof Choromanski, Francois Fagan, Cedric GouyPailler, Anne Morvan, Nouri Sakr, Tamas Sarlos, and Jamal Atif. Structured adaptive and random spinners for fast machine learning computations. arXiv preprint arXiv:1610.06209, 2016.   \nJane Bromley, Isabelle Guyon, Yann LeCun, Eduard Sackinger, and Roopak Shah. Signature verifi- ¨ cation using a ”siamese” time delay neural network. In Advances in Neural Information Processing Systems, pp. 737–744, 1994.   \nAlessandro Camerra, Themis Palpanas, Jin Shieh, and Eamonn Keogh. isax 2.0: Indexing and mining one billion time series. In Data Mining (ICDM), 2010 IEEE 10th International Conference on, pp. 58–67. IEEE, 2010.   \nZhengping Che, Xinran He, Ke Xu, and Yan Liu. Decade: A deep metric learning model for multivariate time series. 2017.   \nYanping Chen, Eamonn Keogh, Bing Hu, Nurjahan Begum, Anthony Bagnall, Abdullah Mueen, and Gustavo Batista. The ucr time series classification archive, July 2015. www.cs.ucr.edu/ ˜eamonn/time_series_data/.   \nZhicheng Cui, Wenlin Chen, and Yixin Chen. Multi-scale convolutional neural networks for time series classification. arXiv preprint arXiv:1603.06995, 2016.   \nMarco Cuturi. Fast global alignment kernels. In Proceedings of the 28th international conference on machine learning (ICML-11), pp. 929–936, 2011. ",
+        "bbox": [
+            169,
+            285,
+            826,
+            928
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Hoang Anh Dau, Nurjahan Begum, and Eamonn Keogh. Semi-supervision dramatically improves time series clustering under dynamic time warping. In Proceedings of the 25th ACM International on Conference on Information and Knowledge Management, pp. 999–1008. ACM, 2016. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            147
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Janez Demsar. Statistical comparisons of classifiers over multiple data sets. Journal of Machine learning research, 7(Jan):1–30, 2006. ",
+        "bbox": [
+            171,
+            156,
+            823,
+            185
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hui Ding, Goce Trajcevski, Peter Scheuermann, Xiaoyue Wang, and Eamonn Keogh. Querying and mining of time series data: experimental comparison of representations and distance measures. Proceedings of the VLDB Endowment, 1(2):1542–1552, 2008. ",
+        "bbox": [
+            173,
+            195,
+            825,
+            238
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Cao-Tri Do, Ahlame Douzal-Chouakria, Sylvain Marie, Mich ´ ele Rombaut, and Saeed Varasteh.\\` Multi-modal and multi-scale temporal metric learning for a robust time series nearest neighbors classification. Information Sciences, 418:272–285, 2017. ",
+        "bbox": [
+            171,
+            247,
+            826,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ada Wai-Chee Fu, Eamonn Keogh, Leo Yung Lau, Chotirat Ann Ratanamahatana, and Raymond Chi-Wing Wong. Scaling and time warping in time series querying. The VLDB JournalThe International Journal on Very Large Data Bases, 17(4):899–921, 2008. ",
+        "bbox": [
+            174,
+            301,
+            825,
+            344
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gartheeban Ganeshapillai and John V Guttag. Weighted time warping for temporal segmentation of multi-parameter physiological signals. 2011. ",
+        "bbox": [
+            171,
+            353,
+            823,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ary L Goldberger, Luis AN Amaral, Leon Glass, Jeffrey M Hausdorff, Plamen Ch Ivanov, Roger G Mark, Joseph E Mietus, George B Moody, Chung-Kang Peng, and H Eugene Stanley. Physiobank, physiotoolkit, and physionet. Circulation, 101(23):e215–e220, 2000. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            436
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Josif Grabocka, Nicolas Schilling, Martin Wistuba, and Lars Schmidt-Thieme. Learning time-series shapelets. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 392–401. ACM, 2014. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yuan Hao, Yanping Chen, Jesin Zakaria, Bing Hu, Thanawin Rakthanmanon, and Eamonn Keogh. Towards never-ending learning from time series streams. In Proceedings of the 19th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 874–882. ACM, 2013. ",
+        "bbox": [
+            173,
+            498,
+            825,
+            555
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Elad Hoffer and Nir Ailon. Deep metric learning using triplet network. In International Workshop on Similarity-Based Pattern Recognition, pp. 84–92. Springer, 2015. ",
+        "bbox": [
+            171,
+            565,
+            823,
+            595
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bing Hu, Yanping Chen, and Eamonn Keogh. Time series classification under more realistic assumptions. In Proceedings of the 2013 SIAM International Conference on Data Mining, pp. 578–586. SIAM, 2013. ",
+        "bbox": [
+            174,
+            604,
+            823,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eamonn Keogh. Efficiently finding arbitrarily scaled patterns in massive time series databases. In European Conference on Principles of Data Mining and Knowledge Discovery, pp. 253–265. Springer, 2003. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            700
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eamonn Keogh, Kaushik Chakrabarti, Michael Pazzani, and Sharad Mehrotra. Locally adaptive dimensionality reduction for indexing large time series databases. ACM Sigmod Record, 30(2): 151–162, 2001a. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            753
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eamonn Keogh, Kaushik Chakrabarti, Michael Pazzani, and Sharad Mehrotra. Dimensionality reduction for fast similarity search in large time series databases. Knowledge and information Systems, 3(3):263–286, 2001b. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eamonn Keogh, Jessica Lin, and Ada Fu. Hot sax: Efficiently finding the most unusual time series subsequence. In Data mining, fifth IEEE international conference on, pp. 8–pp. Ieee, 2005. ",
+        "bbox": [
+            171,
+            816,
+            823,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Qi Lei, Jinfeng Yi, Roman Vaculin, Lingfei Wu, and Inderjit S Dhillon. Similarity preserving representation learning for time series analysis. arXiv preprint arXiv:1702.03584, 2017. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Daniel Lemire. Streaming maximum-minimum filter using no more than three comparisons per element. arXiv preprint cs/0610046, 2006. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jessica Lin, Eamonn Keogh, Stefano Lonardi, and Bill Chiu. A symbolic representation of time series, with implications for streaming algorithms. In Proceedings of the 8th ACM SIGMOD workshop on Research issues in data mining and knowledge discovery, pp. 2–11. ACM, 2003. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiangyuan Mei, Meizhu Liu, Yuan-Fang Wang, and Huijun Gao. Learning a mahalanobis distancebased dynamic time warping measure for multivariate time series classification. IEEE transactions on Cybernetics, 46(6):1363–1374, 2016. ",
+        "bbox": [
+            173,
+            191,
+            823,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abdullah Mueen, Eamonn Keogh, Qiang Zhu, Sydney Cash, and Brandon Westover. Exact discovery of time series motifs. In Proceedings of the 2009 SIAM International Conference on Data Mining, pp. 473–484. SIAM, 2009. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hyun Oh Song, Yu Xiang, Stefanie Jegelka, and Silvio Savarese. Deep metric learning via lifted structured feature embedding. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4004–4012, 2016. ",
+        "bbox": [
+            171,
+            294,
+            826,
+            337
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wenjie Pei, David MJ Tax, and Laurens van der Maaten. Modeling time series similarity with siamese recurrent networks. arXiv preprint arXiv:1603.04713, 2016. ",
+        "bbox": [
+            171,
+            345,
+            823,
+            375
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thanawin Rakthanmanon, Eamonn J Keogh, Stefano Lonardi, and Scott Evans. Time series epenthesis: Clustering time series streams requires ignoring some data. In Data Mining (ICDM), 2011 IEEE 11th International Conference on, pp. 547–556. IEEE, 2011. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thanawin Rakthanmanon, Bilson Campana, Abdullah Mueen, Gustavo Batista, Brandon Westover, Qiang Zhu, Jesin Zakaria, and Eamonn Keogh. Searching and mining trillions of time series subsequences under dynamic time warping. In Proceedings of the 18th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 262–270. ACM, 2012. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, pp. 525–542. Springer, 2016. ",
+        "bbox": [
+            173,
+            498,
+            823,
+            542
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chotirat Ann Ratanamahatana and Eamonn Keogh. Making time-series classification more accurate using learned constraints. In Proceedings of the 2004 SIAM International Conference on Data Mining, pp. 11–22. SIAM, 2004a. ",
+        "bbox": [
+            174,
+            550,
+            823,
+            593
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chotirat Ann Ratanamahatana and Eamonn Keogh. Everything you know about dynamic time warping is wrong. In Third Workshop on Mining Temporal and Sequential Data, pp. 22–25. Citeseer, 2004b. ",
+        "bbox": [
+            176,
+            601,
+            821,
+            643
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hiroaki Sakoe and Seibi Chiba. Dynamic programming algorithm optimization for spoken word recognition. IEEE transactions on acoustics, speech, and signal processing, 26(1):43–49, 1978. ",
+        "bbox": [
+            169,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Patrick Schafer. Towards time series classification without human preprocessing. In ¨ International Workshop on Machine Learning and Data Mining in Pattern Recognition, pp. 228–242. Springer, 2014. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            733
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Patrick Schafer and Ulf Leser. Fast and accurate time series classification with weasel. ¨ arXiv preprint arXiv:1701.07681, 2017. ",
+        "bbox": [
+            169,
+            741,
+            825,
+            770
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 815–823, 2015. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pavel Senin and Sergey Malinchik. Sax-vsm: Interpretable time series classification using sax and vector space model. In Data Mining (ICDM), 2013 IEEE 13th International Conference on, pp. 1175–1180. IEEE, 2013. ",
+        "bbox": [
+            173,
+            830,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Shokoohi-Yekta, Jun Wang, and Eamonn Keogh. On the non-trivial generalization of dynamic time warping to the multi-dimensional case. In Proceedings of the 2015 SIAM International Conference on Data Mining, pp. 289–297. SIAM, 2015. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yaniv Taigman, Ming Yang, Marc’Aurelio Ranzato, and Lior Wolf. Deepface: Closing the gap to human-level performance in face verification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1701–1708, 2014. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    }
+]