Add files using upload-large-folder tool

parse/train/HJSA_e1AW/HJSA_e1AW.md

@@ -0,0 +1,378 @@
+# NORMALIZED DIRECTION-PRESERVING ADAM
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Optimization algorithms for training deep models not only affects the convergence rate and stability of the training process, but are also highly related to the generalization performance of trained models. While adaptive algorithms, such as Adam and RMSprop, have shown better optimization performance than stochastic gradient descent (SGD) in many scenarios, they often lead to worse generalization performance than SGD, when used for training deep neural networks (DNNs). In this work, we identify two problems regarding the direction and step size for updating the weight vectors of hidden units, which may degrade the generalization performance of Adam. As a solution, we propose the normalized direction-preserving Adam (ND-Adam) algorithm, which controls the update direction and step size more precisely, and thus bridges the generalization gap between Adam and SGD. Following a similar rationale, we further improve the generalization performance in classification tasks by regularizing the softmax logits. By bridging the gap between SGD and Adam, we also shed some light on why certain optimization algorithms generalize better than others.
+
+# 1 INTRODUCTION
+
+In contrast with the growing complexity of neural network architectures (Szegedy et al., 2015; He et al., 2016; Hu et al., 2017), the training methods remain relatively simple. Most practical optimization methods for deep neural networks (DNNs) are based on the stochastic gradient descent (SGD) algorithm. However, the learning rate of SGD, as a hyperparameter, is often difficult to tune, since the magnitudes of different parameters can vary widely, and adjustment is required throughout the training process.
+
+To tackle this problem, several adaptive variants of SGD have been developed, including Adagrad (Duchi et al., 2011), Adadelta (Zeiler, 2012), RMSprop (Tieleman & Hinton, 2012), Adam (Kingma & Ba, 2014), etc. These algorithms aim to adapt the learning rate to different parameters automatically, based on the statistics of gradient. Although they usually simplify learning rate settings, and lead to faster convergence, it is observed that their generalization performance tend to be significantly worse than that of SGD in some scenarios (Wilson et al., 2017). This intriguing phenomenon may explain why SGD (possibly with momentum) is still prevalent in training state-of-the-art deep models, especially feedforward DNNs (Szegedy et al., 2015; He et al., 2016; Hu et al., 2017). Furthermore, recent work has shown that DNNs are capable of fitting noise data (Zhang et al., 2017), suggesting that their generalization capabilities are not the mere result of DNNs themselves, but are entwined with optimization (Arpit et al., 2017).
+
+This work aims to bridge the gap between SGD and Adam in terms of the generalization performance. To this end, we identify two problems that may degrade the generalization performance of Adam, and show how these problems are (partially) avoided by using SGD with L2 weight decay. First, the updates of SGD lie in the span of historical gradients, whereas it is not the case for Adam. This difference has been discussed in rather recent literature (Wilson et al., 2017), where the authors show that adaptive methods can find drastically different but worse solutions than SGD. Second, while the magnitudes of Adam parameter updates are invariant to rescaling of the gradient, the effect of the updates on the same overall network function still varies with the magnitudes of parameters. As a result, the effective learning rates of weight vectors tend to decrease during training, which leads to sharp local minima that do not generalize well (Hochreiter & Schmidhuber, 1997).
+
+To fix the two problems for Adam, we propose the normalized direction-preserving Adam (NDAdam) algorithm, which controls the update direction and step size more precisely. We show that
+
+ND-Adam is able to achieve significantly better generalization performance than vanilla Adam, and matches that of SGD in image classification tasks.
+
+We summarize our contributions as follows:
+
+• We observe that the directions of Adam parameter updates are different from that of SGD, i.e., Adam does not preserve the directions of gradients as SGD does. We fix the problem by adapting the learning rate to each weight vector, instead of each individual weight, such that the direction of the gradient is preserved.   
+For both Adam and SGD without L2 weight decay, we observe that the magnitude of each vector’s direction change depends on its L2-norm. We show that, using SGD with L2 weight decay implicitly normalizes the weight vectors, and thus remove the dependence in an approximate manner. We fix the problem for Adam by explicitly normalizing each weight vector, and by optimizing only its direction, such that the effective learning rate can be precisely controlled.   
+We further show that, without proper regularization, the learning signal backpropagated from the softmax layer may vary with the overall magnitude of the logits in an undesirable way. Based on the observation, we apply batch normalization or L2-regularization to the logits, which further improves the generalization performance in classification tasks.
+
+In essence, our proposed methods, ND-Adam and regularized softmax, improve the generalization performance of Adam by enabling more precise control over the directions of parameter updates, the learning rates, and the learning signals.
+
+# 2 BACKGROUND AND MOTIVATION
+
+# 2.1 ADAPTIVE MOMENT ESTIMATION (ADAM)
+
+Adaptive moment estimation (Adam) (Kingma & Ba, 2014) is a stochastic optimization method that applies individual adaptive learning rates to different parameters, based on the estimates of the first and second moments of the gradients. Specifically, for $n$ trainable parameters, $\boldsymbol \theta \in \mathbb { R } ^ { n }$ , Adam maintains a running average of the first and second moments of the gradient w.r.t. each parameter as
+
+$$
+m _ { t } = \beta _ { 1 } m _ { t - 1 } + \left( 1 - \beta _ { 1 } \right) g _ { t } ,
+$$
+
+$$
+v _ { t } = \beta _ { 2 } v _ { t - 1 } + \left( 1 - \beta _ { 2 } \right) g _ { t } ^ { 2 } .
+$$
+
+Here, $t$ denotes the time step, $m _ { t } \in \mathbb { R } ^ { n }$ and $\boldsymbol { v } _ { t } ~ \in ~ \mathbb { R } ^ { n }$ denote respectively the first and second moments, and $\beta _ { 1 } \in \mathbb { R }$ and $\beta _ { 2 } \in \mathbb { R }$ are the corresponding decay factors. Kingma & Ba (2014) further notice that, since $m _ { 0 }$ and $v _ { 0 }$ are initialized to $0 \mathrm { { s } }$ , they are biased towards zero during the initial time steps, especially when the decay factors are large (i.e., close to 1). Thus, for computing the next update, they need to be corrected as
+
+$$
+\hat { m } _ { t } = \frac { m _ { t } } { 1 - \beta _ { 1 } ^ { t } } , \hat { v } _ { t } = \frac { v _ { t } } { 1 - \beta _ { 2 } ^ { t } } ,
+$$
+
+where $\beta _ { 1 } ^ { t } , \beta _ { 2 } ^ { t }$ are the $t$ -th powers of $\beta _ { 1 } , \beta _ { 2 }$ respectively. Then, we can update each parameter as
+
+$$
+\theta _ { t } = \theta _ { t - 1 } - \frac { \alpha _ { t } } { \sqrt { \hat { v } _ { t } } + \epsilon } \hat { m } _ { t } ,
+$$
+
+where $\alpha _ { t }$ is the global learning rate, and $\epsilon$ is a small constant to avoid division by zero. Note the above computations between vectors are element-wise.
+
+A distinguishing merit of Adam is that the magnitudes of parameter updates are invariant to rescaling of the gradient, as shown by the adaptive learning rate term, $\frac { \alpha _ { t } } { \sqrt { \hat { v } _ { t } } + \epsilon }$ . However, there are two potential problems when applying Adam to DNNs.
+
+First, in some scenarios, DNNs trained with Adam generalize worse than that trained with stochastic gradient descent (SGD) (Wilson et al., 2017). Zhang et al. (2017) demonstrate that overparameterized DNNs are capable of memorizing the entire dataset, no matter if it is natural data or meaningless noise data, and thus suggest much of the generalization power of DNNs comes from the training algorithm, e.g., SGD and its variants. It coincides with another recent work (Wilson et al., 2017), which shows that simple SGD often yields better generalization performance than adaptive gradient methods, such as Adam. As pointed out by the latter, the difference in the generalization performance may result from the different directions of updates. Specifically, for each hidden unit, the SGD update of its input weight vector can only lie in the span of all possible input vectors, which, however, is not the case for Adam due to the individually adapted learning rates. We refer to this problem as the direction missing problem.
+
+Second, while batch normalization (Ioffe & Szegedy, 2015) can significantly accelerate the convergence of DNNs, the input weights and the scaling factor of each hidden unit can be scaled in infinitely many (but consistent) ways, without changing the function implemented by the hidden unit. Thus, for different magnitudes of an input weight vector, the updates given by Adam can have different effects on the overall network function, which is undesirable. Furthermore, even when batch normalization is not used, a network using linear rectifiers (e.g., ReLU, leaky ReLU) as activation functions, is still subject to ill-conditioning of the parameterization (Glorot et al., 2011), and hence the same problem. We refer to this problem as the ill-conditioning problem.
+
+# 2.2 L2 WEIGHT DECAY
+
+L2 weight decay is a regularization technique frequently used with SGD. It often has a significant effect on the generalization performance of DNNs. Despite the simplicity and crucial role of L2 weight decay in the training process, it remains to be explained how it works in DNNs. A common justification for L2 weight decay is that it can be introduced by placing a Gaussian prior upon the weights, when the objective is to find the maximum a posteriori (MAP) weights (Blundell et al., 2015). However, as discussed in Sec. 2.1, the magnitudes of input weight vectors are irrelevant in terms of the overall network function, in some common scenarios, rendering the variance of the Gaussian prior meaningless.
+
+We propose to view L2 weight decay in neural networks as a form of weight normalization, which may better explain its effect on the generalization performance. Consider a neural network trained with the following loss function:
+
+$$
+\widetilde { L } \left( \boldsymbol { \theta } ; \mathcal { D } \right) = L \left( \boldsymbol { \theta } ; \mathcal { D } \right) + \frac { \lambda } { 2 } \sum _ { i \in \mathcal { N } } \left. w _ { i } \right. _ { 2 } ^ { 2 } ,
+$$
+
+where $L \left( \theta ; \mathcal { D } \right)$ is the original loss function specified by the task, $\mathcal { D }$ is a batch of training data, $\mathcal { N }$ is the set of all hidden units, and $w _ { i }$ denotes the input weights of hidden unit $i$ , which is included in the trainable parameters, $\theta$ . For simplicity, we consider SGD updates without momentum. Therefore, the update of $w _ { i }$ at each time step is
+
+$$
+\Delta w _ { i } = - \alpha \frac { \partial \widetilde { L } } { \partial w _ { i } } = - \alpha \left( \frac { \partial L } { \partial w _ { i } } + \lambda w _ { i } \right) ,
+$$
+
+where $\alpha$ is the learning rate. As we can see from Eq. (5), the gradient magnitude of the L2 penalty is proportional to $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ , thus forms a negative feedback loop that stabilizes $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ to an equilibrium value. Empirically, we find that $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ tends to increase or decrease dramatically at the beginning of the training, and then varies mildly within a small range, which indicates $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 } \approx \lVert \boldsymbol { w } _ { i } + \Delta \boldsymbol { w } _ { i } \rVert _ { 2 }$ . In practice, we usually have $\left\| \Delta w _ { i } \right\| _ { 2 } / \left\| w _ { i } \right\| _ { 2 } \ll 1$ , thus $\Delta w _ { i }$ is approximately orthogonal to $w _ { i }$ , i.e. $w _ { i } \cdot \Delta w _ { i } \approx 0$ .
+
+Let $l _ { \parallel w _ { i } }$ and $l \_ w _ { i }$ be the vector projection and rejection of $\frac { \partial L } { \partial w _ { i } }$ on $w _ { i }$ , which are defined as
+
+$$
+l _ { \parallel w _ { i } } = \left( \frac { \partial L } { \partial w _ { i } } \cdot \frac { w _ { i } } { \parallel w _ { i } \parallel _ { 2 } } \right) \frac { w _ { i } } { \parallel w _ { i } \parallel _ { 2 } } , l _ { \perp w _ { i } } = \frac { \partial L } { \partial w _ { i } } - l _ { \parallel w _ { i } } .
+$$
+
+From Eq. (5) and (6), it is easy to show
+
+$$
+\frac { \left. \Delta w _ { i } \right. _ { 2 } } { \left. w _ { i } \right. _ { 2 } } \approx \frac { \left. l _ { \perp w _ { i } } \right. _ { 2 } } { \left. l _ { \parallel w _ { i } } \right. _ { 2 } } \alpha \lambda .
+$$
+
+As discussed in Sec. 2.1, when batch normalization is used, or when linear rectifiers are used as activation functions, the magnitude of $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ is irrelevant. Thus, it is the direction of $w _ { i }$ that actually makes a difference in the overall network function. If L2 weight decay is not applied, the magnitude of $w _ { i }$ ’s direction change will decrease as $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ increases during the training process, which can potentially lead to overfitting (discussed in detail in Sec. 3.2). On the other hand, Eq. (7) shows that L2 weight decay implicitly normalizes the weights, such that the magnitude of $w _ { i }$ ’s direction change does not depend on $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ , and can be tuned by the product of $\alpha$ and $\lambda$ . In the following, we refer to $\| \Delta w _ { i } \| _ { 2 } | \| w _ { i } \| _ { 2 }$ as the effective learning rate of $w _ { i }$ .
+
+While L2 weight decay produces the normalization effect in an implicit and approximate way, we will show that explicitly doing so enables more precise control of the effective learning rate.
+
+# 3 NORMALIZED DIRECTION-PRESERVING ADAM
+
+We first present the normalized direction-preserving Adam (ND-Adam) algorithm, which essentially improves the optimization of the input weights of hidden units, while employing the vanilla Adam algorithm to update other parameters. Specifically, we divide the trainable parameters, $\theta$ , into two sets, $\theta ^ { v }$ and $\theta ^ { s }$ , such that $\mathcal { \tilde { \theta } } ^ { v } = \{ w _ { i } | i \in \bar { \mathcal { N } } \}$ , and $\theta ^ { s } = \{ \theta \setminus \theta ^ { v } \}$ . Then we update $\theta ^ { v }$ and $\theta ^ { s }$ by different rules, as described by Alg. 1. The learning rates for the two sets of parameters are denoted respectively by $\alpha _ { t } ^ { v }$ and $\alpha _ { t } ^ { s }$ .
+
+# Algorithm 1: Normalized direction-preserving Adam
+
+$/ \star$ Initialization \*/   
+$t \gets 0$ ;   
+for $i \in \mathcal N$ do $w _ { i , 0 }  w _ { i , 0 } / \parallel w _ { i , 0 } \parallel _ { 2 } ;$ $m _ { 0 } \left( w _ { i } \right) \gets 0$ ; $v _ { 0 } ( w _ { i } )  0$ ;   
+$/ \star$ Perform $T$ iterations of training \*/   
+while $t < T$ do $t \gets t + 1$ ; $/ \star$ Update $\theta ^ { v }$ \*/ for $i \in \mathcal N$ do $\bar { g } _ { t } ( w _ { i } )  \partial L / \partial w _ { i }$ ; $g _ { t } \left( w _ { i } \right) \gets \bar { g } _ { t } \left( w _ { i } \right) - \left( \bar { g } _ { t } \left( w _ { i } \right) \cdot w _ { i , t - 1 } \right) w _ { i , t - 1 } ;$ $m _ { t } \left( w _ { i } \right) \gets \beta _ { 1 } m _ { t - 1 } \left( w _ { i } \right) + \left( 1 - \beta _ { 1 } \right) g _ { t } \left( w _ { i } \right) ;$ $v _ { t } ( w _ { i } )  \beta _ { 2 } v _ { t - 1 } ( w _ { i } ) + ( 1 - \beta _ { 2 } ) \| g _ { t } ( w _ { i } ) \| _ { 2 } ^ { 2 } ;$ $\hat { m } _ { t } \left( w _ { i } \right) \gets m _ { t } \left( w _ { i } \right) / \left( 1 - \beta _ { 1 } ^ { t } \right)$ ; $\hat { v } _ { t } ( w _ { i } )  v _ { t } ( w _ { i } ) / ( 1 - \beta _ { 2 } ^ { t } )$ ; $\bar { w } _ { i , t }  w _ { i , t - 1 } - \alpha _ { t } ^ { v } \hat { m } _ { t } ( w _ { i } ) / ( \sqrt { \hat { v } _ { t } ( w _ { i } ) } + \epsilon ) ;$ ; $w _ { i , t } \gets \bar { w } _ { i , t } / \left. \bar { w } _ { i , t } \right. _ { 2 }$ ; /\* Update $\theta ^ { s }$ using Adam \*/ $\theta _ { t } ^ { s } \gets$ AdamUpdate $\left( \theta _ { t - 1 } ^ { s } ; \alpha _ { t } ^ { s } , \beta _ { 1 } , \beta _ { 2 } \right)$ ;
+
+return $\theta _ { T }$
+
+In Alg. 1, the iteration over $\mathcal { N }$ can be performed in parallel, and thus introduces no extra computational complexity. Compared to Adam, computing $g _ { t } \left( w _ { i } \right)$ and $w _ { i , t }$ may take slightly more time, which, however, is negligible in practice. On the other hand, to estimate the second order moment of each $w _ { i } \in \mathbb { R } ^ { n }$ , Adam maintains $n$ scalars, whereas ND-Adam requires only one scalar, $v _ { t } \left( w _ { i } \right)$ . Thus, ND-Adam has smaller memory overhead than Adam.
+
+In the following, we address the direction missing problem and the ill-conditioning problem discussed in Sec. 2.1, and explain Alg. 1 in detail. We show how the proposed algorithm jointly solves the two problems, as well as its relation to other normalization schemes.
+
+# 3.1 PRESERVING GRADIENT DIRECTIONS
+
+Assuming the stationarity of a hidden unit’s input distribution, the SGD update (possibly with momentum) of the input weight vector is a linear combination of historical gradients, and thus can only lie in the span of the input vectors. As a result, the input weight vector itself will eventually converge to the same subspace.
+
+On the contrary, the Adam algorithm adapts the global learning rate to each scalar parameter independently, such that the gradient of each parameter is normalized by a running average of its magnitudes, which changes the direction of the gradient. To preserve the direction of the gradient w.r.t. each input weight vector, we generalize the learning rate adaptation scheme from scalars to vectors.
+
+Let $g _ { t } ( w _ { i } ) , m _ { t } ( w _ { i } ) , v _ { t } ( w _ { i } )$ be the counterparts of $g _ { t }$ , $m _ { t }$ , $v _ { t }$ for vector $w _ { i }$ . Since Eq. (1a) is a linear combination of historical gradients, it can be extended to vectors without any change; or equivalently, we can rewrite it for each vector as
+
+$$
+m _ { t } \left( w _ { i } \right) = \beta _ { 1 } m _ { t - 1 } \left( w _ { i } \right) + \left( 1 - \beta _ { 1 } \right) g _ { t } \left( w _ { i } \right) .
+$$
+
+We then extend Eq. (1b) as
+
+$$
+v _ { t } \left( w _ { i } \right) = \beta _ { 2 } v _ { t - 1 } \left( w _ { i } \right) + \left( 1 - \beta _ { 2 } \right) \left. g _ { t } \left( w _ { i } \right) \right. _ { 2 } ^ { 2 } ,
+$$
+
+i.e., instead of estimating the average gradient magnitude for each individual parameter, we estimate the average of $\| g _ { t } \left( w _ { i } \right) \| _ { 2 } ^ { 2 }$ for each vector $w _ { i }$ . In addition, we modify Eq. (2) and (3) accordingly as
+
+$$
+\hat { m } _ { t } \left( w _ { i } \right) = \frac { m _ { t } \left( w _ { i } \right) } { 1 - \beta _ { 1 } ^ { t } } , \hat { v } _ { t } \left( w _ { i } \right) = \frac { v _ { t } \left( w _ { i } \right) } { 1 - \beta _ { 2 } ^ { t } } ,
+$$
+
+and
+
+$$
+w _ { i , t } = w _ { i , t - 1 } - \frac { \alpha _ { t } ^ { v } } { \sqrt { { \hat { v } } _ { t } \left( w _ { i } \right) } + \epsilon } { \hat { m } } _ { t } \left( w _ { i } \right) .
+$$
+
+Here, $\hat { m } _ { t } \left( \boldsymbol { w } _ { i } \right)$ is a vector with the same dimension as $w _ { i }$ , whereas $\hat { v } _ { t } \left( w _ { i } \right)$ is a scalar. Therefore, when applying Eq. (11), the direction of the update is the negative direction of $\hat { m } _ { t } \left( \boldsymbol { w } _ { i } \right)$ , and thus is in the span of the historical gradients of $w _ { i }$ .
+
+It is worth noting that only the input to the first layer (i.e., the training data) is stationary throughout training. Thus, for the weights of an upper layer to converge to the span of its input vectors, it is necessary for the lower layers to converge first. Interestingly, this predicted phenomenon may have been observed in practice (Brock et al., 2017).
+
+Despite the empirical success of SGD, a question remains as to why it is desirable to constrain the input weights in the span of the input vectors. A possible explanation is related to the manifold hypothesis, which suggests that real-world data presented in high dimensional spaces (images, audios, text, etc) concentrates on manifolds of much lower dimensionality (Cayton, 2005; Narayanan & Mitter, 2010). In fact, commonly used activation functions, such as (leaky) ReLU, sigmoid, tanh, can only be activated (not saturating or having small gradients) by a portion of the input vectors, in whose span the input weights lie upon convergence. Assuming the local linearity of the manifolds of data or hidden-layer representations, constraining the input weights in the subspace that contains some of the input vectors, encourages the hidden units to form local coordinate systems on the corresponding manifold, which can lead to good representations (Rifai et al., 2011).
+
+# 3.2 SPHERICAL WEIGHT OPTIMIZATION
+
+The ill-conditioning problem occurs when the magnitude change of an input weight vector can be compensated by other parameters, such as the scaling factor of batch normalization, or the output weight vector, without affecting the overall network function. Consequently, suppose we have two DNNs that parameterize the same function, but with some of the input weight vectors having different magnitudes, applying the same SGD or Adam update rule will, in general, change the network functions in different ways. Thus, the ill-conditioning problem makes the training process inconsistent and difficult to control.
+
+More importantly, when the weights are not properly regularized (e.g., without using L2 weight decay), the magnitude of $w _ { i }$ ’s direction change will decrease as $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ increases during the training process. As a result, the effective learning rate for $w _ { i }$ tends to decrease faster than expected, making the network converge to sharp minima. It is well known that sharp minima generalize worse than flat minima (Hochreiter & Schmidhuber, 1997; Keskar et al., 2017).
+
+As shown in Sec. 2.2, L2 weight decay can alleviate the ill-conditioning problem by implicitly and approximately normalizing the weights. However, we still do not have a precise control over the effective learning rate, since $\| \bar { l _ { \perp w _ { i } } } \| _ { 2 } / | \bar { \| l _ { \parallel w _ { i } } } | | _ { 2 }$ is unknown and not necessarily stable. Moreover, the approximation fails when $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ is far from the equilibrium due to improper initialization, or drastic changes in the magnitudes of the weight vectors. This problem is also addressed by (Neyshabur et al., 2015), by employing a geometry invariant to rescaling of weights. However, their proposed methods do not preserve the direction of gradient.
+
+To address the ill-conditioning problem in a more principled way, we restrict the L2-norm of each $w _ { i }$ to 1, and only optimize its direction. In other words, instead of optimizing $w _ { i }$ in a $n$ -dimensional space, we optimize $w _ { i }$ on a $( n - 1 )$ -dimensional unit sphere. Specifically, we first obtain the raw gradient w.r.t. $w _ { i } , \bar { g } _ { t } \left( w _ { i } \right) = \partial L / \partial w _ { i }$ , and project the gradient onto the unit sphere as
+
+$$
+g _ { t } \left( w _ { i } \right) = \bar { g } _ { t } \left( w _ { i } \right) - \left( \bar { g } _ { t } \left( w _ { i } \right) \cdot w _ { i , t - 1 } \right) w _ { i , t - 1 } .
+$$
+
+Here, $\| w _ { i , t - 1 } \| _ { 2 } = 1$ . Then we follow Eq. (8)-(10), and replace (11) with
+
+and
+
+$$
+\begin{array} { c } { \displaystyle \bar { w } _ { i , t } = w _ { i , t - 1 } - \frac { \alpha _ { t } ^ { v } } { \sqrt { \hat { v } _ { t } \left( w _ { i } \right) } + \epsilon } \hat { m } _ { t } \left( w _ { i } \right) , } \\ { \displaystyle w _ { i , t } = \frac { \bar { w } _ { i , t } } { \| \bar { w } _ { i , t } \| _ { 2 } } . } \end{array}
+$$
+
+In Eq. (12), we keep only the component that is orthogonal to $w _ { i , t - 1 }$ . However, $\hat { m } _ { t } \left( \boldsymbol { w } _ { i } \right)$ is not necessarily orthogonal as well. In addition, even when $\hat { m } _ { t } \left( \boldsymbol { w } _ { i } \right)$ is orthogonal to $w _ { i , t - 1 }$ , Eq. (13a) can still increase $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ , according to the Pythagorean theorem. Therefore, we explicitly normalize $w _ { i , t }$ in Eq. (13b), to ensure $\| w _ { i , t } \| _ { 2 } = 1$ after each update. Also note that, since $w _ { i , t - 1 }$ is a linear combination of its historical gradients, $g _ { t } \left( w _ { i } \right)$ still lies in the span of the historical gradients after the projection in Eq. (12).
+
+Compared to SGD with L2 weight decay, spherical weight optimization explicitly normalizes the weight vectors, such that each update to the weight vectors only changes their directions, and strictly keeps the magnitudes constant. As a result, the effective learning rate of a weight vector is
+
+$$
+\frac { \left. \Delta w _ { i , t } \right. _ { 2 } } { \left. w _ { i , t - 1 } \right. _ { 2 } } \approx \frac { \left. \hat { m } _ { t } \left( w _ { i } \right) \right. _ { 2 } } { \sqrt { \hat { v } _ { t } \left( w _ { i } \right) } } \alpha _ { t } ^ { v } ,
+$$
+
+which enables precise control over the learning rate of $w _ { i }$ through a single hyperparameter, $\alpha _ { t } ^ { v }$ rather than two as required by Eq. (7). Note that it is possible to control the effective learning rate more precisely, by normalizing $\hat { m } _ { t } \left( \boldsymbol { w } _ { i } \right)$ with $\| \hat { m } _ { t } \left( w _ { i } \right) \| _ { 2 }$ , instead of by $\sqrt { \hat { v } _ { t } \left( w _ { i } \right) }$ . However, by doing so, we lose the information provided by $\| \hat { m } _ { t } \left( \boldsymbol { w } _ { i } \right) \| _ { 2 }$ at different time steps. In addition, since $\hat { m } _ { t } \left( \boldsymbol { w } _ { i } \right)$ is less noisy than $g _ { t } \left( w _ { i } \right)$ , $\Vert \hat { m } _ { t } \left( w _ { i } \right) \Vert _ { 2 } / \sqrt { \hat { v } _ { t } \left( w _ { i } \right) }$ becomes small near convergence, which is considered a desirable property of Adam (Kingma $\&$ Ba, 2014). Thus, we keep the gradient normalization scheme intact.
+
+We note the difference between various gradient normalization schemes and the normalization scheme employed by spherical weight optimization. As shown in Eq. 11, ND-Adam generalizes the gradient normalization scheme of Adam, and thus both Adam and ND-Adam normalize the gradient by a running average of its magnitude. This, and other similar schemes (Hazan et al., 2015; Yu et al., 2017) make the optimization less susceptible to vanishing and exploding gradients. On the other hand, the proposed spherical weight optimization serves a different purpose. It normalizes each weight vector and projects the gradient onto a unit sphere, such that the effective learning rate can be controlled more precisely. Moreover, it provides robustness to improper weight initialization, since the magnitude of each weight vector is kept constant.
+
+For nonlinear activation functions, such as sigmoid and tanh, an extra scaling factor is needed for each hidden unit to express functions that require unnormalized weight vectors. For instance, given an input vector $x \in \mathbb { R } ^ { n }$ , and a nonlinearity $\phi \left( \cdot \right)$ , the activation of hidden unit $i$ is then given by
+
+$$
+y _ { i } = \phi \left( \gamma _ { i } w _ { i } \cdot x + b _ { i } \right) ,
+$$
+
+where $\gamma _ { i }$ is the scaling factor, and $b _ { i }$ is the bias.
+
+# 3.3 RELATION TO WEIGHT NORMALIZATION AND BATCH NORMALIZATION
+
+A related normalization and reparameterization scheme, weight normalization (Salimans & Kingma, 2016), has been developed as an alternative to batch normalization, aiming to accelerate the convergence of SGD optimization. We note the difference between spherical weight optimization and weight normalization. First, the weight vector of each hidden unit is not directly normalized in weight normalization, i.e, $\| w _ { i } \| _ { 2 } \neq 1$ in general. At training time, the activation of hidden unit $i$ is
+
+$$
+y _ { i } = \phi \left( \frac { \gamma _ { i } } { \left\| w _ { i } \right\| _ { 2 } } w _ { i } \cdot x + b _ { i } \right) ,
+$$
+
+which is equivalent to Eq. (15) for the forward pass. For the backward pass, the effective learning rate still depends on $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ in weight normalization, hence it does not solve the ill-conditioning problem. At inference time, both of these two schemes can combine $w _ { i }$ and $\gamma _ { i }$ into a single equivalent weight vector, $w _ { i } ^ { \prime } = \gamma _ { i } w _ { i }$ , o r $\begin{array} { r } { w _ { i } ^ { \prime } = \frac { \gamma _ { i } } { \Vert w _ { i } \Vert _ { 2 } } w _ { i } } \end{array}$ .
+
+While spherical weight optimization naturally encompasses weight normalization, it can further benefit from batch normalization. When combined with batch normalization, Eq. (15) evolves into
+
+$$
+y _ { i } = \phi \left( \gamma _ { i } \operatorname { B N } \left( w _ { i } \cdot x \right) + b _ { i } \right) ,
+$$
+
+where $\mathrm { B N } \left( { \cdot } \right)$ represents the transformation done by batch normalization without scaling and shifting. Here, $\gamma _ { i }$ serves as the scaling factor for both the normalized weight vector and batch normalization. At training time, the distribution of the input vector, $x$ , changes over time, slowing down the training of the sub-network composed by the upper layers. Salimans & Kingma (2016) observe that, such problem cannot be eliminated by normalizing the weight vectors alone, but can be substantially mitigated by combining weight normalization and mean-only batch normalization.
+
+Additionally, in linear rectifier networks, the scaling factors, $\gamma _ { i }$ , can be removed (or set to 1), without changing the overall network function. Since $w _ { i } \cdot x$ is standardized by batch normalization, we have
+
+$$
+\mathbb { E } _ { x } \left[ \mathrm { B N } \left( \boldsymbol { w } _ { i } \cdot \boldsymbol { x } \right) ^ { 2 } \right] \approx 1 ,
+$$
+
+and hence
+
+$$
+\operatorname { V a r } _ { \boldsymbol { x } } \left[ \operatorname { B N } \left( \boldsymbol { w } _ { i } \cdot \boldsymbol { x } \right) + b _ { i } \right] \approx 1 .
+$$
+
+Therefore, $y _ { i }$ ’s that belong to the same layer, or different dimensions of $x$ that fed to the upper layer, will also have comparable variances, which potentially makes the weight updates of the upper layer more stable. For these reasons, we combine the use of spherical weight optimization and batch normalization, as shown in Eq. (17).
+
+# 4 REGULARIZED SOFTMAX
+
+For multi-class classification tasks, the softmax function is the de facto activation function for the output layer. Despite its simplicity and intuitive probabilistic interpretation, we observe a related problem to the ill-conditioning problem we have addressed. Similar to how different magnitudes of weight vectors result in different updates to the same network function, the learning signal backpropagated from the softmax layer varies with the overall magnitude of the logits.
+
+Specifically, when using cross entropy as the surrogate loss with one-hot target vectors, the prediction is considered correct as long as arg $\mathrm { m a x } _ { c \in \mathcal { C } } \left( z _ { c } \right)$ is the target class, where $z _ { c }$ is the logit before the softmax activation, corresponding to category $c \in { \mathcal { C } }$ . Thus, the logits can be positively scaled together without changing the predictions, whereas the cross entropy and its derivatives will vary with the scaling factor. Concretely, denoting the scaling factor by $\eta$ , the gradient w.r.t. each logit is
+
+$$
+\frac { \partial L } { \partial z _ { \hat { c } } } = \eta \left[ \frac { \exp \left( \eta z _ { \hat { c } } \right) } { \sum _ { c \in \mathcal { C } } \exp \left( \eta z _ { c } \right) } - 1 \right] ,
+$$
+
+and
+
+$$
+\frac { \partial L } { \partial z _ { \bar { c } } } = \frac { \eta \exp \left( \eta z _ { \bar { c } } \right) } { \sum _ { c \in \mathcal { C } } \exp \left( \eta z _ { c } \right) } .
+$$
+
+where $\hat { c }$ is the target class, and ${ \bar { c } } \in { \mathcal { C } } \backslash \{ { \hat { c } } \}$ .
+
+For Adam and ND-Adam, since the gradient w.r.t. each scalar or vector are normalized, the absolute magnitudes of Eq. (20a) and (20b) are irrelevant. Instead, the relative magnitudes make a difference here. When $\eta$ is small, we have
+
+$$
+\operatorname* { l i m } _ { \eta \to 0 } \left| \frac { \partial L / \partial z _ { \bar { c } } } { \partial L / \partial z _ { \hat { c } } } \right| = \frac { 1 } { | \mathcal { C } | - 1 } ,
+$$
+
+which indicates that, when the magnitude of the logits is small, softmax encourages the logit of the target class to increase, while equally penalizing that of the other classes. On the other end of the spectrum, assuming no two digits are the same, we have
+
+$$
+\operatorname* { l i m } _ { \eta  \infty } | \frac { \partial L / \partial z _ { \bar { c } ^ { \prime } } } { \partial L / \partial z _ { \hat { c } } } | = 1 , \operatorname* { l i m } _ { \eta  \infty } | \frac { \partial L / \partial z _ { \bar { c } ^ { \prime \prime } } } { \partial L / \partial z _ { \hat { c } } } | = 0 ,
+$$
+
+where $\bar { c } ^ { \prime } = \arg \operatorname* { m a x } _ { c \in \mathcal { C } \backslash \{ \hat { c } \} } \left( z _ { c } \right)$ , and $\bar { c } ^ { \prime \prime } \in \mathcal { C } \backslash \{ \hat { c } , \bar { c } ^ { \prime } \}$ . Eq. (22) indicates that, when the magnitude of the logits is large, softmax penalizes only the largest logit of the non-target classes. The latter case is related to the saturation problem of softmax discussed in Oland et al. (2017). However, they focus on the problem of small absolute gradient magnitude, which does not affect Adam and ND-Adam.
+
+It is worth noting that both of these two cases can happen without the scaling factor. For instance, varying the norm of the weights of the softmax layer is equivalent to varying the value of $\eta$ , in terms of the relative magnitude of the gradient. In the case of small $\eta$ , the logits of all non-target classes are penalized equally, regardless of the difference in $\hat { z } - \bar { z }$ for different $\bar { z } \in \mathcal { C } \backslash \{ \hat { z } \}$ . However, it is more reasonable to penalize more the logits that are closer to $\hat { z }$ , which are more likely to cause misclassification. In the case of large $\eta$ , although the logit that is most likely to cause misclassification is strongly penalized, the logits of other non-target classes are ignored. As a result, the logits of the non-target classes tend to be similar at convergence, ignoring the fact that some classes are closer to each other than the others.
+
+We propose two methods to exploit the prior knowledge that the magnitude of the logits should not be too small or too large. First, we can apply batch normalization to the logits. But instead of setting $\gamma _ { c }$ ’s as trainable variables, we consider them as a single hyperparameter, $\gamma _ { \mathcal { C } }$ , such that $\gamma _ { c } = \gamma _ { c } , \forall c \in \mathcal { C }$ . Tuning the value of $\gamma _ { \mathcal { C } }$ can lead to a better trade-off between the two extremes described by Eq. (21) and (22). The optimal value of $\gamma _ { \mathcal { C } }$ tends to remain the same for different optimizers or different network widths, but varies with dataset and network depth. We refer to this method as batch-normalized softmax (BN-Softmax).
+
+Alternatively, since the magnitude of the logits tends to grow larger than expected (in order to minimize the cross entropy), we can apply L2-regularization to the logits by adding the following penalty to the loss function:
+
+$$
+L _ { \mathcal { C } } = \frac { \lambda _ { \mathcal { C } } } { 2 } \sum _ { c \in \mathcal { C } } z _ { c } ^ { 2 } ,
+$$
+
+where $\lambda _ { \mathcal { C } }$ is a hyperparameter to be tuned. Different from BN-Softmax, $\lambda _ { C }$ can be shared by different datasets and networks of different depths.
+
+# 5 EXPERIMENTS
+
+In this section, we provide empirical evidence for the analysis in Sec. 2.2, and evaluate the performance of ND-Adam and regularized softmax on CIFAR-10 and CIFAR-100.
+
+# 5.1 THE EFFECT OF L2 WEIGHT DECAY
+
+To empirically examine the effect of L2 weight decay, we train a wide residual network (WRN) (Zagoruyko & Komodakis, 2016b) of 22 layers, with a width of 7.5 times that of a vanilla ResNet. Using the notation in Zagoruyko & Komodakis (2016b), we refer to this network as WRN-22-7.5. We train the network on the CIFAR-10 dataset (Krizhevsky & Hinton, 2009), with a small modification to the original WRN architecture, and with a different learning rate annealing schedule. Specifically, for simplicity and slightly better performance, we replace the last fully connected layer with a convolutional layer with 10 output feature maps. I.e., we change the layers after the last residual block from BN-ReLU-GlobalAvgPool-FC-Softmax to
+
+BN-ReLU-Conv-GlobalAvgPool-Softmax. In addition, for clearer comparisons, the learning rate is annealed according to a cosine function without restart (Loshchilov & Hutter, 2016; Gastaldi, 2017). We train the model for 80k iterations with a batch size of 128, similar to the settings in Zagoruyko & Komodakis (2016b). The experiments are based on a TensorFlow implementation of WRN (Wu, 2016).
+
+As a common practice, we use SGD with a momentum of 0.9, the analysis for which is similar to that in Sec. 2.2. Due to the linearity of derivatives and momentum, $\Delta w _ { i }$ can be decomposed as $\Delta w _ { i } = \Delta w _ { i } ^ { l } + \Delta w _ { i } ^ { p }$ , where $\Delta w _ { i } ^ { l }$ and $\Delta w _ { i } ^ { p }$ are the components corresponding to the original loss function, $L \left( \cdot \right)$ , and the L2 penalty term (see Eq. (4)), respectively. Fig. 1a shows the ratio between the scalar projection of $\Delta \bar { w } _ { i } ^ { l }$ on $\bar { \Delta } w _ { i } ^ { p }$ and $\left. \Delta w _ { i } ^ { p } \right. _ { 2 }$ , which indicates how the tendency of $\Delta w _ { i } ^ { l }$ to increase $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ is compensated by $\Delta w _ { i } ^ { p }$ . Note that $\Delta w _ { i } ^ { p }$ points to the negative direction of $w _ { i }$ , even when momentum is used, since the direction change of $w _ { i }$ is slow. As shown in Fig. 1a, at the beginning of the training, $\Delta w _ { i } ^ { p }$ dominants and quickly adjusts $\lVert \boldsymbol { w } _ { i } \rVert _ { 2 }$ to its equilibrium value. During the middle stage of the training, the projection of $\Delta w _ { i } ^ { l }$ on $\Delta w _ { i } ^ { p }$ , and $\Delta w _ { i } ^ { p }$ almost cancel each other out. Then, near the end of the training, the gradient of $w _ { i }$ diminishes rapidly to near zero, making $\Delta w _ { i } ^ { p }$ dominant again. Therefore, Eq. (7) holds more accurately during the middle stage of the training.
+
+In Fig. 1b, we show how the effective learning rate varies in different hyperparameter settings. By Eq. (7), $\left\| \Delta w _ { i } \right\| _ { 2 } / \left\| w _ { i } \right\| _ { 2 }$ is expected to remain the same as long as $\alpha \lambda$ stays constant, which is confirmed by the fact that the curve for $\alpha _ { 0 } = 0 . 1 , \lambda = 0 . 0 0 1$ overlaps with that for $\alpha _ { 0 } = 0 . 0 5 , \lambda =$ 0.002. However, comparing the curve for $\alpha _ { 0 } = 0 . 1 , \lambda = 0 . 0 0 1$ , with that for $\alpha _ { 0 } = 0 . 1 , \lambda =$ 0.0005, we can see that the value of $\| \Delta w _ { i } \| _ { 2 } / \| w _ { i } \| _ { 2 }$ does not change proportionally to $\alpha \lambda$ . On the other hand, by using ND-Adam, we can control the value of $\lVert \Delta w _ { i } \rVert _ { 2 } \dot { / } \lVert \dot { w } _ { i } \rVert _ { 2 }$ more precisely by adjusting the learning rate for weight vectors, $\alpha ^ { v }$ . For the same training step, changes in $\alpha ^ { v }$ lead to approximately proportional changes in $\| \Delta w _ { i } \| _ { 2 } / \| w _ { i } \| _ { 2 }$ , as shown by the two curves corresponding to ND-Adam in Fig. 1b.
+
+![](images/dcf5f1c901e84b092b98192aad1de61f46fb687abe7413362a2285ff99d328ee.jpg)  
+(a) The scalar projection of $\Delta w _ { i } ^ { l }$ on $\Delta w _ { i } ^ { p }$ normalized by(b) The relative magnitude of the weight updates, or the $\left. \Delta w _ { i } ^ { p } \right. _ { 2 }$ . effective learning rate.   
+Figure 1: An illustration of how L2 weight decay and ND-Adam control the effective learning rate. The results are obtained from the 5th layer of the network, and other layers show similar results.
+
+# 5.2 PERFORMANCE EVALUATION
+
+To compare the generalization performance of SGD, Adam, and ND-Adam, we train the same WRN22-7.5 network on the CIFAR-10 and CIFAR-100 datasets. For SGD and ND-Adam, we first tune the hyperparameters for SGD $( \alpha _ { 0 } = 0 . 1 , \lambda = 0 . 0 0 1$ , momentum 0.9), then tune the initial learning rate of ND-Adam for weight vectors to match the effective learning rate to that of SGD $\alpha _ { 0 } ^ { v } = 0 . 0 5 )$ , as shown in Fig. 1b. While L2 weight decay can greatly affect the performance of SGD, it does not noticeably benefit Adam in our experiments. For Adam and ND-Adam, $\beta _ { 1 }$ and $\beta _ { 2 }$ are set to the default values of Adam, i.e., $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ . Although the learning rate of Adam is usually set to a constant value, we observe better performance with the cosine learning rate schedule. The initial learning rate of Adam $( \alpha _ { 0 } )$ , and that of ND-Adam for scalar parameters $( \alpha _ { 0 } ^ { s } )$ are both tuned to 0.001. We use the same data augmentation scheme as used in Zagoruyko & Komodakis (2016b), including horizontal flips and random crops, but no dropout is used.
+
+We first experiment with the use of trainable scaling parameters $( \gamma _ { i } )$ of batch normalization. As shown in Fig. 2b, at convergence, the test accuracies of ND-Adam are significantly improved upon that of vanilla Adam, and matches that of SGD. Note that at the early stage of training, the training losses of Adam drop dramatically as shown in Fig. 2a, and the test accuracies also increase more rapidly than that of ND-Adam and SGD. However, the test accuracies remain at a high level afterwards, which indicates that Adam tends to quickly find and get stuck in bad local minima that do not generalize well.
+
+The average results of 3 runs are summarized in the first part of Table 1. Interestingly, compared to SGD, ND-Adam shows slightly better performance on CIFAR-10, but worse performance on CIFAR-100. This inconsistency may be related to the problem of softmax discussed in Sec. 4, that there is a lack of proper control over the magnitude of the logits. But overall, given comparable effective learning rates, ND-Adam and SGD show similar generalization performance. In this sense, the effective learning rate is a more natural learning rate measure than the learning rate hyperparameters.
+
+![](images/2258af99304275cba3dda8e135ac5499ddd95a8b02f54c25a7f467886f8ef9b4.jpg)  
+Figure 2: The training losses and test accuracies of the same network trained with SGD, Adam, and ND-Adam. Batch normalization with scaling factors is used.
+
+Next, we repeat the experiments with the use of BN-Softmax. As discussed in Sec. 3.2, $\gamma _ { i }$ ’s can be removed from a linear rectifier network, without changing the overall network function. Although this property does not strictly hold for residual networks due to the skip connections, we find that simply removing the scaling factors results in slightly improved generalization performance when using ND-Adam. However, the improvement is not consistent as it degrades performance of SGD. Interestingly, when BN-Softmax is further used, we observe consistent improvement over all three algorithms. Thus, we only report results for this setting. The scaling factor of the logits, $\gamma _ { \mathcal { C } }$ , is set to 2.5 for CIFAR-10, and 1 for CIFAR-100. As shown in the second part of Table 1, BN-Softmax significantly improves the performance of Adam and ND-Adam. Moreover, in this setting, we obtain the best generalization performance with ND-Adam, outperforming SGD and Adam on both CIFAR-10 and CIFAR-100.
+
+While the TensorFlow implementation we use already provides an adequate test bed, we notice that it is different from the original implementation of WRN in several aspects. For instance, they use different nonlinearities (leaky ReLU vs. ReLU), and use different skip connections for downsampling (average pooling vs. strided convolution). A seemingly subtle but important difference is that, L2-regularization is applied not only to weight vectors, but also to the scales and biases of batch normalization in the original implementation, which leads to better generalization performance. For further comparison between SGD and ND-Adam, we reimplement ND-Adam and test its performance on a PyTorch version of the original implementation (Zagoruyko & Komodakis, 2016a).
+
+Due to the aforementioned differences, we use a slightly different hyperparameter setting in this experiment. Specifically, for SGD $\lambda$ is set to 5e 4, while for ND-Adam $\lambda$ is set to 5e 6 (L2- regularization for biases), and both $\alpha _ { 0 } ^ { s }$ and $\alpha _ { 0 } ^ { v }$ are set to 0.04. In this case, regularizing softmax does not yield improved performance for SGD, since the L2-regularization applied to $\gamma _ { i }$ ’s and the last layer weights can serve a similar purpose. Thus, we only apply L2-regularized softmax for ND-Adam with $\lambda _ { C } = 0 . 0 0 1$ . The average results of 3 runs are summarized in Table 2. Note that the performance of SGD for WRN-28-10 is slightly better than that reported with the original implementation (i.e., 4.00 and 19.25), due to the modifications described in Sec. 5.1. In this experiment, SGD and ND-Adam show almost identical generalization performance.
+
+![](images/6b18d8319a01a5b33527c5568d4d8a9daa311ed6b273f8af12a0ff24dd7216e8.jpg)  
+Figure 3: The training losses and test accuracies of the same network trained with SGD, Adam, and ND-Adam. Batch normalization without scaling factors, and BN-Softmax are used.   
+Table 2: Test error rates of WRN-22-7.5 and WRN-28-10 networks on CIFAR-10 and CIFAR-100. Based on the original implementation of WRN.
+
+Table 1: Test error rates of WRN-22-7.5 networks on CIFAR-10 and CIFAR-100. Based on a TensorFlow implementation of WRN.   
+
+<table><tr><td>CIFAR-10 Method Error (%)</td><td>CIFAR-100 Error (%)</td></tr><tr><td>BN w/ scaling factors</td></tr><tr><td>SGD 4.61 20.60</td></tr><tr><td>Adam 6.14 25.51</td></tr><tr><td>ND-Adam 4.53 21.45</td></tr><tr><td colspan="2">BN w/o scaling factors,BN-Softmax</td></tr><tr><td>SGD 4.49</td><td>20.18</td></tr><tr><td>Adam 5.43</td><td>22.48</td></tr><tr><td>ND-Adam 4.14</td><td>19.90</td></tr></table>
+
+<table><tr><td>Method</td><td>CIFAR-10 Error (%)</td><td>CIFAR-100 Error (%)</td></tr><tr><td></td><td>WRN-22-7.5</td><td></td></tr><tr><td>SGD</td><td>3.84</td><td>19.24</td></tr><tr><td>ND-Adam</td><td>3.70</td><td>19.30</td></tr><tr><td>WRN-28-10</td><td></td><td></td></tr><tr><td>SGD</td><td>3.80</td><td>18.48</td></tr><tr><td>ND-Adam</td><td>3.70</td><td>18.42</td></tr></table>
+
+# 6 CONCLUSION
+
+In this paper, we have introduced ND-Adam, a tailored version of Adam for training DNNs, to bridge the generalization gap between Adam and SGD. ND-Adam is designed to preserve the direction of gradient for each weight vector, and produce the regularization effect of L2 weight decay in a more precise and principled way. Moreover, we have introduced regularized softmax, which limits the magnitude of softmax logits to provide better learning signals. By combining ND-Adam and regularized softmax, our experiments have shown significantly improved generalization performance, eliminating the gap between Adam and SGD. From a high-level view, our analysis and empirical results suggest the need for more precise control over the training process of DNNs.
+
+# REFERENCES
+
+Devansh Arpit, Stanisław Jastrz˛ebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S Kanwal, Tegan Maharaj, Asja Fischer, Aaron Courville, Yoshua Bengio, et al. A closer look at memorization in deep networks. arXiv preprint arXiv:1706.05394, 2017.
+
+Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. In ICML 2015, 2015.
+
+Andrew Brock, Theodore Lim, JM Ritchie, and Nick Weston. Freezeout: Accelerate training by progressively freezing layers. arXiv preprint arXiv:1706.04983, 2017.
+
+Lawrence Cayton. Algorithms for manifold learning. Univ. of California at San Diego Tech. Rep, pp. 1–17, 2005.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011.
+
+Xavier Gastaldi. Shake-shake regularization of 3-branch residual networks. In ICLR 2017 Workshop, 2017.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, pp. 315–323, 2011.
+
+Elad Hazan, Kfir Levy, and Shai Shalev-Shwartz. Beyond convexity: Stochastic quasi-convex optimization. In Advances in Neural Information Processing Systems, pp. 1594–1602, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. arXiv preprint arXiv:1709.01507, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. ICLR 2017, 2017.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Ilya Loshchilov and Frank Hutter. Sgdr: stochastic gradient descent with restarts. arXiv preprint arXiv:1608.03983, 2016.
+
+Hariharan Narayanan and Sanjoy Mitter. Sample complexity of testing the manifold hypothesis. In Advances in Neural Information Processing Systems, pp. 1786–1794, 2010.
+
+Behnam Neyshabur, Ruslan R Salakhutdinov, and Nati Srebro. Path-sgd: Path-normalized optimization in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2422–2430, 2015.
+
+Anders Oland, Aayush Bansal, Roger B Dannenberg, and Bhiksha Raj. Be careful what you backpropagate: A case for linear output activations & gradient boosting. arXiv preprint arXiv:1707.04199, 2017.
+
+Salah Rifai, Yann N Dauphin, Pascal Vincent, Yoshua Bengio, and Xavier Muller. The manifold tangent classifier. In Advances in Neural Information Processing Systems, pp. 2294–2302, 2011.
+
+Tim Salimans and Diederik P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.
+
+Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. In Advances in Neural Information Processing Systems, 2017.
+
+Neal Wu. A tensorflow implementation of wide residual networks, 2016. URL https:// github.com/tensorflow/models/tree/master/research/resnet.
+
+Adams Wei Yu, Qihang Lin, Ruslan Salakhutdinov, and Jaime Carbonell. Normalized gradient with adaptive stepsize method for deep neural network training. arXiv preprint arXiv:1707.04822, 2017.
+
+Sergey Zagoruyko and Nikos Komodakis. A pytorch implementation of wide residual networks, 2016a. URL https://github.com/szagoruyko/wide-residual-networks.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016b.
+
+Matthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In ICLR 2017, 2017.

parse/train/HJSA_e1AW/HJSA_e1AW_content_list.json

@@ -0,0 +1,1884 @@
+[
+    {
+        "type": "text",
+        "text": "NORMALIZED DIRECTION-PRESERVING ADAM",
+        "text_level": 1,
+        "bbox": [
+            178,
+            99,
+            733,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            400,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Optimization algorithms for training deep models not only affects the convergence rate and stability of the training process, but are also highly related to the generalization performance of trained models. While adaptive algorithms, such as Adam and RMSprop, have shown better optimization performance than stochastic gradient descent (SGD) in many scenarios, they often lead to worse generalization performance than SGD, when used for training deep neural networks (DNNs). In this work, we identify two problems regarding the direction and step size for updating the weight vectors of hidden units, which may degrade the generalization performance of Adam. As a solution, we propose the normalized direction-preserving Adam (ND-Adam) algorithm, which controls the update direction and step size more precisely, and thus bridges the generalization gap between Adam and SGD. Following a similar rationale, we further improve the generalization performance in classification tasks by regularizing the softmax logits. By bridging the gap between SGD and Adam, we also shed some light on why certain optimization algorithms generalize better than others. ",
+        "bbox": [
+            233,
+            238,
+            764,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            468,
+            336,
+            484
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contrast with the growing complexity of neural network architectures (Szegedy et al., 2015; He et al., 2016; Hu et al., 2017), the training methods remain relatively simple. Most practical optimization methods for deep neural networks (DNNs) are based on the stochastic gradient descent (SGD) algorithm. However, the learning rate of SGD, as a hyperparameter, is often difficult to tune, since the magnitudes of different parameters can vary widely, and adjustment is required throughout the training process. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To tackle this problem, several adaptive variants of SGD have been developed, including Adagrad (Duchi et al., 2011), Adadelta (Zeiler, 2012), RMSprop (Tieleman & Hinton, 2012), Adam (Kingma & Ba, 2014), etc. These algorithms aim to adapt the learning rate to different parameters automatically, based on the statistics of gradient. Although they usually simplify learning rate settings, and lead to faster convergence, it is observed that their generalization performance tend to be significantly worse than that of SGD in some scenarios (Wilson et al., 2017). This intriguing phenomenon may explain why SGD (possibly with momentum) is still prevalent in training state-of-the-art deep models, especially feedforward DNNs (Szegedy et al., 2015; He et al., 2016; Hu et al., 2017). Furthermore, recent work has shown that DNNs are capable of fitting noise data (Zhang et al., 2017), suggesting that their generalization capabilities are not the mere result of DNNs themselves, but are entwined with optimization (Arpit et al., 2017). ",
+        "bbox": [
+            174,
+            589,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This work aims to bridge the gap between SGD and Adam in terms of the generalization performance. To this end, we identify two problems that may degrade the generalization performance of Adam, and show how these problems are (partially) avoided by using SGD with L2 weight decay. First, the updates of SGD lie in the span of historical gradients, whereas it is not the case for Adam. This difference has been discussed in rather recent literature (Wilson et al., 2017), where the authors show that adaptive methods can find drastically different but worse solutions than SGD. Second, while the magnitudes of Adam parameter updates are invariant to rescaling of the gradient, the effect of the updates on the same overall network function still varies with the magnitudes of parameters. As a result, the effective learning rates of weight vectors tend to decrease during training, which leads to sharp local minima that do not generalize well (Hochreiter & Schmidhuber, 1997). ",
+        "bbox": [
+            174,
+            750,
+            823,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To fix the two problems for Adam, we propose the normalized direction-preserving Adam (NDAdam) algorithm, which controls the update direction and step size more precisely. We show that ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ND-Adam is able to achieve significantly better generalization performance than vanilla Adam, and matches that of SGD in image classification tasks. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We summarize our contributions as follows: ",
+        "bbox": [
+            174,
+            138,
+            464,
+            154
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We observe that the directions of Adam parameter updates are different from that of SGD, i.e., Adam does not preserve the directions of gradients as SGD does. We fix the problem by adapting the learning rate to each weight vector, instead of each individual weight, such that the direction of the gradient is preserved.   \nFor both Adam and SGD without L2 weight decay, we observe that the magnitude of each vector’s direction change depends on its L2-norm. We show that, using SGD with L2 weight decay implicitly normalizes the weight vectors, and thus remove the dependence in an approximate manner. We fix the problem for Adam by explicitly normalizing each weight vector, and by optimizing only its direction, such that the effective learning rate can be precisely controlled.   \nWe further show that, without proper regularization, the learning signal backpropagated from the softmax layer may vary with the overall magnitude of the logits in an undesirable way. Based on the observation, we apply batch normalization or L2-regularization to the logits, which further improves the generalization performance in classification tasks. ",
+        "bbox": [
+            215,
+            165,
+            825,
+            369
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In essence, our proposed methods, ND-Adam and regularized softmax, improve the generalization performance of Adam by enabling more precise control over the directions of parameter updates, the learning rates, and the learning signals. ",
+        "bbox": [
+            176,
+            382,
+            825,
+            424
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND AND MOTIVATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            444,
+            482,
+            460
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 ADAPTIVE MOMENT ESTIMATION (ADAM) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            476,
+            513,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adaptive moment estimation (Adam) (Kingma & Ba, 2014) is a stochastic optimization method that applies individual adaptive learning rates to different parameters, based on the estimates of the first and second moments of the gradients. Specifically, for $n$ trainable parameters, $\\boldsymbol \\theta \\in \\mathbb { R } ^ { n }$ , Adam maintains a running average of the first and second moments of the gradient w.r.t. each parameter as ",
+        "bbox": [
+            174,
+            501,
+            825,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d066a88fd2391e616d9689ffc9c1a5c86ba8bad600484402c8cb2b76a594531f.jpg",
+        "text": "$$\nm _ { t } = \\beta _ { 1 } m _ { t - 1 } + \\left( 1 - \\beta _ { 1 } \\right) g _ { t } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            569,
+            596,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/839550e0c703e603eb6a7edf962d08f7e02d3b0a06ed0e5e048d8aa201584c1f.jpg",
+        "text": "$$\nv _ { t } = \\beta _ { 2 } v _ { t - 1 } + \\left( 1 - \\beta _ { 2 } \\right) g _ { t } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            601,
+            591,
+            619
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, $t$ denotes the time step, $m _ { t } \\in \\mathbb { R } ^ { n }$ and $\\boldsymbol { v } _ { t } ~ \\in ~ \\mathbb { R } ^ { n }$ denote respectively the first and second moments, and $\\beta _ { 1 } \\in \\mathbb { R }$ and $\\beta _ { 2 } \\in \\mathbb { R }$ are the corresponding decay factors. Kingma & Ba (2014) further notice that, since $m _ { 0 }$ and $v _ { 0 }$ are initialized to $0 \\mathrm { { s } }$ , they are biased towards zero during the initial time steps, especially when the decay factors are large (i.e., close to 1). Thus, for computing the next update, they need to be corrected as ",
+        "bbox": [
+            174,
+            622,
+            825,
+            693
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/74c2e5a56267d5a374a15354c2a8e2202ac47c104b721106a947d5fbe4b834d4.jpg",
+        "text": "$$\n\\hat { m } _ { t } = \\frac { m _ { t } } { 1 - \\beta _ { 1 } ^ { t } } , \\hat { v } _ { t } = \\frac { v _ { t } } { 1 - \\beta _ { 2 } ^ { t } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            699,
+            593,
+            729
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta _ { 1 } ^ { t } , \\beta _ { 2 } ^ { t }$ are the $t$ -th powers of $\\beta _ { 1 } , \\beta _ { 2 }$ respectively. Then, we can update each parameter as ",
+        "bbox": [
+            173,
+            736,
+            797,
+            752
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1366a0f037db401a5cb28dd8678761e3d387befbae8bd331573d5a228b1f359f.jpg",
+        "text": "$$\n\\theta _ { t } = \\theta _ { t - 1 } - \\frac { \\alpha _ { t } } { \\sqrt { \\hat { v } _ { t } } + \\epsilon } \\hat { m } _ { t } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            758,
+            583,
+            789
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha _ { t }$ is the global learning rate, and $\\epsilon$ is a small constant to avoid division by zero. Note the above computations between vectors are element-wise. ",
+        "bbox": [
+            173,
+            794,
+            823,
+            823
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A distinguishing merit of Adam is that the magnitudes of parameter updates are invariant to rescaling of the gradient, as shown by the adaptive learning rate term, $\\frac { \\alpha _ { t } } { \\sqrt { \\hat { v } _ { t } } + \\epsilon }$ . However, there are two potential problems when applying Adam to DNNs. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "First, in some scenarios, DNNs trained with Adam generalize worse than that trained with stochastic gradient descent (SGD) (Wilson et al., 2017). Zhang et al. (2017) demonstrate that overparameterized DNNs are capable of memorizing the entire dataset, no matter if it is natural data or meaningless noise data, and thus suggest much of the generalization power of DNNs comes from the training algorithm, e.g., SGD and its variants. It coincides with another recent work (Wilson et al., 2017), which shows that simple SGD often yields better generalization performance than adaptive gradient methods, such as Adam. As pointed out by the latter, the difference in the generalization performance may result from the different directions of updates. Specifically, for each hidden unit, the SGD update of its input weight vector can only lie in the span of all possible input vectors, which, however, is not the case for Adam due to the individually adapted learning rates. We refer to this problem as the direction missing problem. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Second, while batch normalization (Ioffe & Szegedy, 2015) can significantly accelerate the convergence of DNNs, the input weights and the scaling factor of each hidden unit can be scaled in infinitely many (but consistent) ways, without changing the function implemented by the hidden unit. Thus, for different magnitudes of an input weight vector, the updates given by Adam can have different effects on the overall network function, which is undesirable. Furthermore, even when batch normalization is not used, a network using linear rectifiers (e.g., ReLU, leaky ReLU) as activation functions, is still subject to ill-conditioning of the parameterization (Glorot et al., 2011), and hence the same problem. We refer to this problem as the ill-conditioning problem. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 L2 WEIGHT DECAY",
+        "text_level": 1,
+        "bbox": [
+            176,
+            349,
+            351,
+            364
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "L2 weight decay is a regularization technique frequently used with SGD. It often has a significant effect on the generalization performance of DNNs. Despite the simplicity and crucial role of L2 weight decay in the training process, it remains to be explained how it works in DNNs. A common justification for L2 weight decay is that it can be introduced by placing a Gaussian prior upon the weights, when the objective is to find the maximum a posteriori (MAP) weights (Blundell et al., 2015). However, as discussed in Sec. 2.1, the magnitudes of input weight vectors are irrelevant in terms of the overall network function, in some common scenarios, rendering the variance of the Gaussian prior meaningless. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose to view L2 weight decay in neural networks as a form of weight normalization, which may better explain its effect on the generalization performance. Consider a neural network trained with the following loss function: ",
+        "bbox": [
+            174,
+            493,
+            825,
+            536
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/199cadd218f127868776a23855a6c6dee49ddebf109997468345d5459f58b8c9.jpg",
+        "text": "$$\n\\widetilde { L } \\left( \\boldsymbol { \\theta } ; \\mathcal { D } \\right) = L \\left( \\boldsymbol { \\theta } ; \\mathcal { D } \\right) + \\frac { \\lambda } { 2 } \\sum _ { i \\in \\mathcal { N } } \\left. w _ { i } \\right. _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            539,
+            622,
+            578
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $L \\left( \\theta ; \\mathcal { D } \\right)$ is the original loss function specified by the task, $\\mathcal { D }$ is a batch of training data, $\\mathcal { N }$ is the set of all hidden units, and $w _ { i }$ denotes the input weights of hidden unit $i$ , which is included in the trainable parameters, $\\theta$ . For simplicity, we consider SGD updates without momentum. Therefore, the update of $w _ { i }$ at each time step is ",
+        "bbox": [
+            174,
+            580,
+            825,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0eb9a5e9fdec8f644572172d916aff056fa85fb95bd68b7529632fd3eeda5b3.jpg",
+        "text": "$$\n\\Delta w _ { i } = - \\alpha \\frac { \\partial \\widetilde { L } } { \\partial w _ { i } } = - \\alpha \\left( \\frac { \\partial L } { \\partial w _ { i } } + \\lambda w _ { i } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            641,
+            630,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ is the learning rate. As we can see from Eq. (5), the gradient magnitude of the L2 penalty is proportional to $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ , thus forms a negative feedback loop that stabilizes $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ to an equilibrium value. Empirically, we find that $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ tends to increase or decrease dramatically at the beginning of the training, and then varies mildly within a small range, which indicates $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 } \\approx \\lVert \\boldsymbol { w } _ { i } + \\Delta \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ . In practice, we usually have $\\left\\| \\Delta w _ { i } \\right\\| _ { 2 } / \\left\\| w _ { i } \\right\\| _ { 2 } \\ll 1$ , thus $\\Delta w _ { i }$ is approximately orthogonal to $w _ { i }$ , i.e. $w _ { i } \\cdot \\Delta w _ { i } \\approx 0$ . ",
+        "bbox": [
+            174,
+            680,
+            825,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $l _ { \\parallel w _ { i } }$ and $l \\_ w _ { i }$ be the vector projection and rejection of $\\frac { \\partial L } { \\partial w _ { i } }$ on $w _ { i }$ , which are defined as ",
+        "bbox": [
+            169,
+            770,
+            767,
+            789
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eff39026f922ef46d55a8a8ec5caf84caf35fdfd5a1088fb602313966a2d1446.jpg",
+        "text": "$$\nl _ { \\parallel w _ { i } } = \\left( \\frac { \\partial L } { \\partial w _ { i } } \\cdot \\frac { w _ { i } } { \\parallel w _ { i } \\parallel _ { 2 } } \\right) \\frac { w _ { i } } { \\parallel w _ { i } \\parallel _ { 2 } } , l _ { \\perp w _ { i } } = \\frac { \\partial L } { \\partial w _ { i } } - l _ { \\parallel w _ { i } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            792,
+            674,
+            828
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "From Eq. (5) and (6), it is easy to show ",
+        "bbox": [
+            173,
+            830,
+            431,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f786ae1687da585518710cefeef28f49118d5eb37864ae119a4f390dbfd55037.jpg",
+        "text": "$$\n\\frac { \\left. \\Delta w _ { i } \\right. _ { 2 } } { \\left. w _ { i } \\right. _ { 2 } } \\approx \\frac { \\left. l _ { \\perp w _ { i } } \\right. _ { 2 } } { \\left. l _ { \\parallel w _ { i } } \\right. _ { 2 } } \\alpha \\lambda .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            848,
+            581,
+            885
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Sec. 2.1, when batch normalization is used, or when linear rectifiers are used as activation functions, the magnitude of $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ is irrelevant. Thus, it is the direction of $w _ { i }$ that actually makes a difference in the overall network function. If L2 weight decay is not applied, the magnitude of $w _ { i }$ ’s direction change will decrease as $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ increases during the training process, which can potentially lead to overfitting (discussed in detail in Sec. 3.2). On the other hand, Eq. (7) shows that L2 weight decay implicitly normalizes the weights, such that the magnitude of $w _ { i }$ ’s direction change does not depend on $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ , and can be tuned by the product of $\\alpha$ and $\\lambda$ . In the following, we refer to $\\| \\Delta w _ { i } \\| _ { 2 } | \\| w _ { i } \\| _ { 2 }$ as the effective learning rate of $w _ { i }$ . ",
+        "bbox": [
+            174,
+            895,
+            825,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While L2 weight decay produces the normalization effect in an implicit and approximate way, we will show that explicitly doing so enables more precise control of the effective learning rate. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 NORMALIZED DIRECTION-PRESERVING ADAM",
+        "text_level": 1,
+        "bbox": [
+            174,
+            256,
+            593,
+            272
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first present the normalized direction-preserving Adam (ND-Adam) algorithm, which essentially improves the optimization of the input weights of hidden units, while employing the vanilla Adam algorithm to update other parameters. Specifically, we divide the trainable parameters, $\\theta$ , into two sets, $\\theta ^ { v }$ and $\\theta ^ { s }$ , such that $\\mathcal { \\tilde { \\theta } } ^ { v } = \\{ w _ { i } | i \\in \\bar { \\mathcal { N } } \\}$ , and $\\theta ^ { s } = \\{ \\theta \\setminus \\theta ^ { v } \\}$ . Then we update $\\theta ^ { v }$ and $\\theta ^ { s }$ by different rules, as described by Alg. 1. The learning rates for the two sets of parameters are denoted respectively by $\\alpha _ { t } ^ { v }$ and $\\alpha _ { t } ^ { s }$ . ",
+        "bbox": [
+            173,
+            295,
+            825,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Normalized direction-preserving Adam ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            410,
+            527,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$/ \\star$ Initialization \\*/   \n$t \\gets 0$ ;   \nfor $i \\in \\mathcal N$ do $w _ { i , 0 }  w _ { i , 0 } / \\parallel w _ { i , 0 } \\parallel _ { 2 } ;$ $m _ { 0 } \\left( w _ { i } \\right) \\gets 0$ ; $v _ { 0 } ( w _ { i } )  0$ ;   \n$/ \\star$ Perform $T$ iterations of training \\*/   \nwhile $t < T$ do $t \\gets t + 1$ ; $/ \\star$ Update $\\theta ^ { v }$ \\*/ for $i \\in \\mathcal N$ do $\\bar { g } _ { t } ( w _ { i } )  \\partial L / \\partial w _ { i }$ ; $g _ { t } \\left( w _ { i } \\right) \\gets \\bar { g } _ { t } \\left( w _ { i } \\right) - \\left( \\bar { g } _ { t } \\left( w _ { i } \\right) \\cdot w _ { i , t - 1 } \\right) w _ { i , t - 1 } ;$ $m _ { t } \\left( w _ { i } \\right) \\gets \\beta _ { 1 } m _ { t - 1 } \\left( w _ { i } \\right) + \\left( 1 - \\beta _ { 1 } \\right) g _ { t } \\left( w _ { i } \\right) ;$ $v _ { t } ( w _ { i } )  \\beta _ { 2 } v _ { t - 1 } ( w _ { i } ) + ( 1 - \\beta _ { 2 } ) \\| g _ { t } ( w _ { i } ) \\| _ { 2 } ^ { 2 } ;$ $\\hat { m } _ { t } \\left( w _ { i } \\right) \\gets m _ { t } \\left( w _ { i } \\right) / \\left( 1 - \\beta _ { 1 } ^ { t } \\right)$ ; $\\hat { v } _ { t } ( w _ { i } )  v _ { t } ( w _ { i } ) / ( 1 - \\beta _ { 2 } ^ { t } )$ ; $\\bar { w } _ { i , t }  w _ { i , t - 1 } - \\alpha _ { t } ^ { v } \\hat { m } _ { t } ( w _ { i } ) / ( \\sqrt { \\hat { v } _ { t } ( w _ { i } ) } + \\epsilon ) ;$ ; $w _ { i , t } \\gets \\bar { w } _ { i , t } / \\left. \\bar { w } _ { i , t } \\right. _ { 2 }$ ; /\\* Update $\\theta ^ { s }$ using Adam \\*/ $\\theta _ { t } ^ { s } \\gets$ AdamUpdate $\\left( \\theta _ { t - 1 } ^ { s } ; \\alpha _ { t } ^ { s } , \\beta _ { 1 } , \\beta _ { 2 } \\right)$ ; ",
+        "bbox": [
+            171,
+            428,
+            826,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "return $\\theta _ { T }$ ",
+        "bbox": [
+            173,
+            757,
+            248,
+            770
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Alg. 1, the iteration over $\\mathcal { N }$ can be performed in parallel, and thus introduces no extra computational complexity. Compared to Adam, computing $g _ { t } \\left( w _ { i } \\right)$ and $w _ { i , t }$ may take slightly more time, which, however, is negligible in practice. On the other hand, to estimate the second order moment of each $w _ { i } \\in \\mathbb { R } ^ { n }$ , Adam maintains $n$ scalars, whereas ND-Adam requires only one scalar, $v _ { t } \\left( w _ { i } \\right)$ . Thus, ND-Adam has smaller memory overhead than Adam. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following, we address the direction missing problem and the ill-conditioning problem discussed in Sec. 2.1, and explain Alg. 1 in detail. We show how the proposed algorithm jointly solves the two problems, as well as its relation to other normalization schemes. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 PRESERVING GRADIENT DIRECTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            475,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assuming the stationarity of a hidden unit’s input distribution, the SGD update (possibly with momentum) of the input weight vector is a linear combination of historical gradients, and thus can only lie in the span of the input vectors. As a result, the input weight vector itself will eventually converge to the same subspace. ",
+        "bbox": [
+            174,
+            128,
+            823,
+            185
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "On the contrary, the Adam algorithm adapts the global learning rate to each scalar parameter independently, such that the gradient of each parameter is normalized by a running average of its magnitudes, which changes the direction of the gradient. To preserve the direction of the gradient w.r.t. each input weight vector, we generalize the learning rate adaptation scheme from scalars to vectors. ",
+        "bbox": [
+            174,
+            191,
+            825,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $g _ { t } ( w _ { i } ) , m _ { t } ( w _ { i } ) , v _ { t } ( w _ { i } )$ be the counterparts of $g _ { t }$ , $m _ { t }$ , $v _ { t }$ for vector $w _ { i }$ . Since Eq. (1a) is a linear combination of historical gradients, it can be extended to vectors without any change; or equivalently, we can rewrite it for each vector as ",
+        "bbox": [
+            174,
+            268,
+            825,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/972d98e23fec4951fdd8638a19cb4a46338313d22c5c0a0ef816d5392138c074.jpg",
+        "text": "$$\nm _ { t } \\left( w _ { i } \\right) = \\beta _ { 1 } m _ { t - 1 } \\left( w _ { i } \\right) + \\left( 1 - \\beta _ { 1 } \\right) g _ { t } \\left( w _ { i } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            315,
+            647,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We then extend Eq. (1b) as ",
+        "bbox": [
+            174,
+            337,
+            352,
+            351
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6c80be923cf85056fccd3d973e258df7bddf39ad48c17bc12bca5e71077a1e21.jpg",
+        "text": "$$\nv _ { t } \\left( w _ { i } \\right) = \\beta _ { 2 } v _ { t - 1 } \\left( w _ { i } \\right) + \\left( 1 - \\beta _ { 2 } \\right) \\left. g _ { t } \\left( w _ { i } \\right) \\right. _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            354,
+            651,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "i.e., instead of estimating the average gradient magnitude for each individual parameter, we estimate the average of $\\| g _ { t } \\left( w _ { i } \\right) \\| _ { 2 } ^ { 2 }$ for each vector $w _ { i }$ . In addition, we modify Eq. (2) and (3) accordingly as ",
+        "bbox": [
+            171,
+            378,
+            820,
+            410
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb3b557468764b89874c4cdf6c903279289a1624df832689dcb9fcb27e568601.jpg",
+        "text": "$$\n\\hat { m } _ { t } \\left( w _ { i } \\right) = \\frac { m _ { t } \\left( w _ { i } \\right) } { 1 - \\beta _ { 1 } ^ { t } } , \\hat { v } _ { t } \\left( w _ { i } \\right) = \\frac { v _ { t } \\left( w _ { i } \\right) } { 1 - \\beta _ { 2 } ^ { t } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            414,
+            630,
+            448
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            452,
+            200,
+            464
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ccef22a11094bd082be936af6a911edfaff206aed71f1816ac2c73a30cd1295e.jpg",
+        "text": "$$\nw _ { i , t } = w _ { i , t - 1 } - \\frac { \\alpha _ { t } ^ { v } } { \\sqrt { { \\hat { v } } _ { t } \\left( w _ { i } \\right) } + \\epsilon } { \\hat { m } } _ { t } \\left( w _ { i } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            460,
+            632,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\hat { m } _ { t } \\left( \\boldsymbol { w } _ { i } \\right)$ is a vector with the same dimension as $w _ { i }$ , whereas $\\hat { v } _ { t } \\left( w _ { i } \\right)$ is a scalar. Therefore, when applying Eq. (11), the direction of the update is the negative direction of $\\hat { m } _ { t } \\left( \\boldsymbol { w } _ { i } \\right)$ , and thus is in the span of the historical gradients of $w _ { i }$ . ",
+        "bbox": [
+            174,
+            497,
+            825,
+            540
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that only the input to the first layer (i.e., the training data) is stationary throughout training. Thus, for the weights of an upper layer to converge to the span of its input vectors, it is necessary for the lower layers to converge first. Interestingly, this predicted phenomenon may have been observed in practice (Brock et al., 2017). ",
+        "bbox": [
+            174,
+            546,
+            825,
+            603
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Despite the empirical success of SGD, a question remains as to why it is desirable to constrain the input weights in the span of the input vectors. A possible explanation is related to the manifold hypothesis, which suggests that real-world data presented in high dimensional spaces (images, audios, text, etc) concentrates on manifolds of much lower dimensionality (Cayton, 2005; Narayanan & Mitter, 2010). In fact, commonly used activation functions, such as (leaky) ReLU, sigmoid, tanh, can only be activated (not saturating or having small gradients) by a portion of the input vectors, in whose span the input weights lie upon convergence. Assuming the local linearity of the manifolds of data or hidden-layer representations, constraining the input weights in the subspace that contains some of the input vectors, encourages the hidden units to form local coordinate systems on the corresponding manifold, which can lead to good representations (Rifai et al., 2011). ",
+        "bbox": [
+            173,
+            609,
+            825,
+            748
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 SPHERICAL WEIGHT OPTIMIZATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            465,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The ill-conditioning problem occurs when the magnitude change of an input weight vector can be compensated by other parameters, such as the scaling factor of batch normalization, or the output weight vector, without affecting the overall network function. Consequently, suppose we have two DNNs that parameterize the same function, but with some of the input weight vectors having different magnitudes, applying the same SGD or Adam update rule will, in general, change the network functions in different ways. Thus, the ill-conditioning problem makes the training process inconsistent and difficult to control. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More importantly, when the weights are not properly regularized (e.g., without using L2 weight decay), the magnitude of $w _ { i }$ ’s direction change will decrease as $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ increases during the training process. As a result, the effective learning rate for $w _ { i }$ tends to decrease faster than expected, making the network converge to sharp minima. It is well known that sharp minima generalize worse than flat minima (Hochreiter & Schmidhuber, 1997; Keskar et al., 2017). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As shown in Sec. 2.2, L2 weight decay can alleviate the ill-conditioning problem by implicitly and approximately normalizing the weights. However, we still do not have a precise control over the effective learning rate, since $\\| \\bar { l _ { \\perp w _ { i } } } \\| _ { 2 } / | \\bar { \\| l _ { \\parallel w _ { i } } } | | _ { 2 }$ is unknown and not necessarily stable. Moreover, the approximation fails when $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ is far from the equilibrium due to improper initialization, or drastic changes in the magnitudes of the weight vectors. This problem is also addressed by (Neyshabur et al., 2015), by employing a geometry invariant to rescaling of weights. However, their proposed methods do not preserve the direction of gradient. ",
+        "bbox": [
+            173,
+            151,
+            825,
+            252
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To address the ill-conditioning problem in a more principled way, we restrict the L2-norm of each $w _ { i }$ to 1, and only optimize its direction. In other words, instead of optimizing $w _ { i }$ in a $n$ -dimensional space, we optimize $w _ { i }$ on a $( n - 1 )$ -dimensional unit sphere. Specifically, we first obtain the raw gradient w.r.t. $w _ { i } , \\bar { g } _ { t } \\left( w _ { i } \\right) = \\partial L / \\partial w _ { i }$ , and project the gradient onto the unit sphere as ",
+        "bbox": [
+            174,
+            258,
+            825,
+            315
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38849e355dd943b7878adb32311da37a7373aac601c7d2ee107a629dd3f5b2ed.jpg",
+        "text": "$$\ng _ { t } \\left( w _ { i } \\right) = \\bar { g } _ { t } \\left( w _ { i } \\right) - \\left( \\bar { g } _ { t } \\left( w _ { i } \\right) \\cdot w _ { i , t - 1 } \\right) w _ { i , t - 1 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            316,
+            647,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\| w _ { i , t - 1 } \\| _ { 2 } = 1$ . Then we follow Eq. (8)-(10), and replace (11) with ",
+        "bbox": [
+            173,
+            334,
+            651,
+            349
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            387,
+            200,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/08ed47d73e311f516a568ce9de22e3f3a4fa4d33ad17cd6824482bf404463426.jpg",
+        "text": "$$\n\\begin{array} { c } { \\displaystyle \\bar { w } _ { i , t } = w _ { i , t - 1 } - \\frac { \\alpha _ { t } ^ { v } } { \\sqrt { \\hat { v } _ { t } \\left( w _ { i } \\right) } + \\epsilon } \\hat { m } _ { t } \\left( w _ { i } \\right) , } \\\\ { \\displaystyle w _ { i , t } = \\frac { \\bar { w } _ { i , t } } { \\| \\bar { w } _ { i , t } \\| _ { 2 } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            351,
+            633,
+            430
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Eq. (12), we keep only the component that is orthogonal to $w _ { i , t - 1 }$ . However, $\\hat { m } _ { t } \\left( \\boldsymbol { w } _ { i } \\right)$ is not necessarily orthogonal as well. In addition, even when $\\hat { m } _ { t } \\left( \\boldsymbol { w } _ { i } \\right)$ is orthogonal to $w _ { i , t - 1 }$ , Eq. (13a) can still increase $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ , according to the Pythagorean theorem. Therefore, we explicitly normalize $w _ { i , t }$ in Eq. (13b), to ensure $\\| w _ { i , t } \\| _ { 2 } = 1$ after each update. Also note that, since $w _ { i , t - 1 }$ is a linear combination of its historical gradients, $g _ { t } \\left( w _ { i } \\right)$ still lies in the span of the historical gradients after the projection in Eq. (12). ",
+        "bbox": [
+            173,
+            435,
+            825,
+            520
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Compared to SGD with L2 weight decay, spherical weight optimization explicitly normalizes the weight vectors, such that each update to the weight vectors only changes their directions, and strictly keeps the magnitudes constant. As a result, the effective learning rate of a weight vector is ",
+        "bbox": [
+            174,
+            526,
+            825,
+            569
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2256c2ee16ef8aa463ca069cf8303f2024a1418301825a0377e76502fdeecfcc.jpg",
+        "text": "$$\n\\frac { \\left. \\Delta w _ { i , t } \\right. _ { 2 } } { \\left. w _ { i , t - 1 } \\right. _ { 2 } } \\approx \\frac { \\left. \\hat { m } _ { t } \\left( w _ { i } \\right) \\right. _ { 2 } } { \\sqrt { \\hat { v } _ { t } \\left( w _ { i } \\right) } } \\alpha _ { t } ^ { v } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            569,
+            598,
+            607
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which enables precise control over the learning rate of $w _ { i }$ through a single hyperparameter, $\\alpha _ { t } ^ { v }$ rather than two as required by Eq. (7). Note that it is possible to control the effective learning rate more precisely, by normalizing $\\hat { m } _ { t } \\left( \\boldsymbol { w } _ { i } \\right)$ with $\\| \\hat { m } _ { t } \\left( w _ { i } \\right) \\| _ { 2 }$ , instead of by $\\sqrt { \\hat { v } _ { t } \\left( w _ { i } \\right) }$ . However, by doing so, we lose the information provided by $\\| \\hat { m } _ { t } \\left( \\boldsymbol { w } _ { i } \\right) \\| _ { 2 }$ at different time steps. In addition, since $\\hat { m } _ { t } \\left( \\boldsymbol { w } _ { i } \\right)$ is less noisy than $g _ { t } \\left( w _ { i } \\right)$ , $\\Vert \\hat { m } _ { t } \\left( w _ { i } \\right) \\Vert _ { 2 } / \\sqrt { \\hat { v } _ { t } \\left( w _ { i } \\right) }$ becomes small near convergence, which is considered a desirable property of Adam (Kingma $\\&$ Ba, 2014). Thus, we keep the gradient normalization scheme intact. ",
+        "bbox": [
+            173,
+            607,
+            825,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We note the difference between various gradient normalization schemes and the normalization scheme employed by spherical weight optimization. As shown in Eq. 11, ND-Adam generalizes the gradient normalization scheme of Adam, and thus both Adam and ND-Adam normalize the gradient by a running average of its magnitude. This, and other similar schemes (Hazan et al., 2015; Yu et al., 2017) make the optimization less susceptible to vanishing and exploding gradients. On the other hand, the proposed spherical weight optimization serves a different purpose. It normalizes each weight vector and projects the gradient onto a unit sphere, such that the effective learning rate can be controlled more precisely. Moreover, it provides robustness to improper weight initialization, since the magnitude of each weight vector is kept constant. ",
+        "bbox": [
+            173,
+            715,
+            825,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For nonlinear activation functions, such as sigmoid and tanh, an extra scaling factor is needed for each hidden unit to express functions that require unnormalized weight vectors. For instance, given an input vector $x \\in \\mathbb { R } ^ { n }$ , and a nonlinearity $\\phi \\left( \\cdot \\right)$ , the activation of hidden unit $i$ is then given by ",
+        "bbox": [
+            174,
+            848,
+            825,
+            890
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/838a9898e495283fd18af1de5cf0d118754eb9cc2d17626cce34dd0830bb71da.jpg",
+        "text": "$$\ny _ { i } = \\phi \\left( \\gamma _ { i } w _ { i } \\cdot x + b _ { i } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            892,
+            575,
+            909
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\gamma _ { i }$ is the scaling factor, and $b _ { i }$ is the bias. ",
+        "bbox": [
+            173,
+            910,
+            485,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 RELATION TO WEIGHT NORMALIZATION AND BATCH NORMALIZATION",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            710,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A related normalization and reparameterization scheme, weight normalization (Salimans & Kingma, 2016), has been developed as an alternative to batch normalization, aiming to accelerate the convergence of SGD optimization. We note the difference between spherical weight optimization and weight normalization. First, the weight vector of each hidden unit is not directly normalized in weight normalization, i.e, $\\| w _ { i } \\| _ { 2 } \\neq 1$ in general. At training time, the activation of hidden unit $i$ is ",
+        "bbox": [
+            173,
+            128,
+            825,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/387abd8b42c22cfc8f73bb657f988fa2fd36976a184d2165245c2d9c9cbc9ab3.jpg",
+        "text": "$$\ny _ { i } = \\phi \\left( \\frac { \\gamma _ { i } } { \\left\\| w _ { i } \\right\\| _ { 2 } } w _ { i } \\cdot x + b _ { i } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            207,
+            596,
+            242
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "which is equivalent to Eq. (15) for the forward pass. For the backward pass, the effective learning rate still depends on $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ in weight normalization, hence it does not solve the ill-conditioning problem. At inference time, both of these two schemes can combine $w _ { i }$ and $\\gamma _ { i }$ into a single equivalent weight vector, $w _ { i } ^ { \\prime } = \\gamma _ { i } w _ { i }$ , o r $\\begin{array} { r } { w _ { i } ^ { \\prime } = \\frac { \\gamma _ { i } } { \\Vert w _ { i } \\Vert _ { 2 } } w _ { i } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            246,
+            825,
+            308
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "While spherical weight optimization naturally encompasses weight normalization, it can further benefit from batch normalization. When combined with batch normalization, Eq. (15) evolves into ",
+        "bbox": [
+            173,
+            313,
+            823,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/876e2628a0b4d7cf0c541d0356778044420918d6b4d5e9f002ef8b8f48db501c.jpg",
+        "text": "$$\ny _ { i } = \\phi \\left( \\gamma _ { i } \\operatorname { B N } \\left( w _ { i } \\cdot x \\right) + b _ { i } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            348,
+            596,
+            364
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { B N } \\left( { \\cdot } \\right)$ represents the transformation done by batch normalization without scaling and shifting. Here, $\\gamma _ { i }$ serves as the scaling factor for both the normalized weight vector and batch normalization. At training time, the distribution of the input vector, $x$ , changes over time, slowing down the training of the sub-network composed by the upper layers. Salimans & Kingma (2016) observe that, such problem cannot be eliminated by normalizing the weight vectors alone, but can be substantially mitigated by combining weight normalization and mean-only batch normalization. ",
+        "bbox": [
+            173,
+            371,
+            825,
+            455
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Additionally, in linear rectifier networks, the scaling factors, $\\gamma _ { i }$ , can be removed (or set to 1), without changing the overall network function. Since $w _ { i } \\cdot x$ is standardized by batch normalization, we have ",
+        "bbox": [
+            174,
+            462,
+            823,
+            489
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/333759d1d76fe6f95d2b4f270ecd4a56ce336a767c1862b8777d47d3a2f58d9c.jpg",
+        "text": "$$\n\\mathbb { E } _ { x } \\left[ \\mathrm { B N } \\left( \\boldsymbol { w } _ { i } \\cdot \\boldsymbol { x } \\right) ^ { 2 } \\right] \\approx 1 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            498,
+            578,
+            526
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "and hence ",
+        "bbox": [
+            173,
+            529,
+            241,
+            541
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b6f7e4e9b6d543659accf216ee0f471959944d6de8edc1a049162c191339f7c4.jpg",
+        "text": "$$\n\\operatorname { V a r } _ { \\boldsymbol { x } } \\left[ \\operatorname { B N } \\left( \\boldsymbol { w } _ { i } \\cdot \\boldsymbol { x } \\right) + b _ { i } \\right] \\approx 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            540,
+            596,
+            558
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Therefore, $y _ { i }$ ’s that belong to the same layer, or different dimensions of $x$ that fed to the upper layer, will also have comparable variances, which potentially makes the weight updates of the upper layer more stable. For these reasons, we combine the use of spherical weight optimization and batch normalization, as shown in Eq. (17). ",
+        "bbox": [
+            174,
+            560,
+            825,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 REGULARIZED SOFTMAX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            416,
+            652
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For multi-class classification tasks, the softmax function is the de facto activation function for the output layer. Despite its simplicity and intuitive probabilistic interpretation, we observe a related problem to the ill-conditioning problem we have addressed. Similar to how different magnitudes of weight vectors result in different updates to the same network function, the learning signal backpropagated from the softmax layer varies with the overall magnitude of the logits. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Specifically, when using cross entropy as the surrogate loss with one-hot target vectors, the prediction is considered correct as long as arg $\\mathrm { m a x } _ { c \\in \\mathcal { C } } \\left( z _ { c } \\right)$ is the target class, where $z _ { c }$ is the logit before the softmax activation, corresponding to category $c \\in { \\mathcal { C } }$ . Thus, the logits can be positively scaled together without changing the predictions, whereas the cross entropy and its derivatives will vary with the scaling factor. Concretely, denoting the scaling factor by $\\eta$ , the gradient w.r.t. each logit is ",
+        "bbox": [
+            173,
+            744,
+            825,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0126191743148ed7396068995b526e4199bcb3288face644160cd5fb06f476ae.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial z _ { \\hat { c } } } = \\eta \\left[ \\frac { \\exp \\left( \\eta z _ { \\hat { c } } \\right) } { \\sum _ { c \\in \\mathcal { C } } \\exp \\left( \\eta z _ { c } \\right) } - 1 \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            820,
+            611,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            862,
+            200,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e8bf98516ae3672499c76e3a87fe53c2ed55f67c693fe2cc18dc185c868f8233.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial z _ { \\bar { c } } } = \\frac { \\eta \\exp \\left( \\eta z _ { \\bar { c } } \\right) } { \\sum _ { c \\in \\mathcal { C } } \\exp \\left( \\eta z _ { c } \\right) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            871,
+            583,
+            906
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { c }$ is the target class, and ${ \\bar { c } } \\in { \\mathcal { C } } \\backslash \\{ { \\hat { c } } \\}$ . ",
+        "bbox": [
+            176,
+            909,
+            452,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For Adam and ND-Adam, since the gradient w.r.t. each scalar or vector are normalized, the absolute magnitudes of Eq. (20a) and (20b) are irrelevant. Instead, the relative magnitudes make a difference here. When $\\eta$ is small, we have ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91a3d10efa55517d5444044095814cc90799e6868097bf18aaa44a9b33d71ec8.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { \\eta \\to 0 } \\left| \\frac { \\partial L / \\partial z _ { \\bar { c } } } { \\partial L / \\partial z _ { \\hat { c } } } \\right| = \\frac { 1 } { | \\mathcal { C } | - 1 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            151,
+            586,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "which indicates that, when the magnitude of the logits is small, softmax encourages the logit of the target class to increase, while equally penalizing that of the other classes. On the other end of the spectrum, assuming no two digits are the same, we have ",
+        "bbox": [
+            174,
+            193,
+            825,
+            234
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7227d3afd07a17d83bb88e900197a8d0a50caeafa46e7b66011c53905750e8e0.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { \\eta  \\infty } | \\frac { \\partial L / \\partial z _ { \\bar { c } ^ { \\prime } } } { \\partial L / \\partial z _ { \\hat { c } } } | = 1 , \\operatorname* { l i m } _ { \\eta  \\infty } | \\frac { \\partial L / \\partial z _ { \\bar { c } ^ { \\prime \\prime } } } { \\partial L / \\partial z _ { \\hat { c } } } | = 0 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            241,
+            645,
+            276
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\bar { c } ^ { \\prime } = \\arg \\operatorname* { m a x } _ { c \\in \\mathcal { C } \\backslash \\{ \\hat { c } \\} } \\left( z _ { c } \\right)$ , and $\\bar { c } ^ { \\prime \\prime } \\in \\mathcal { C } \\backslash \\{ \\hat { c } , \\bar { c } ^ { \\prime } \\}$ . Eq. (22) indicates that, when the magnitude of the logits is large, softmax penalizes only the largest logit of the non-target classes. The latter case is related to the saturation problem of softmax discussed in Oland et al. (2017). However, they focus on the problem of small absolute gradient magnitude, which does not affect Adam and ND-Adam. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            339
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that both of these two cases can happen without the scaling factor. For instance, varying the norm of the weights of the softmax layer is equivalent to varying the value of $\\eta$ , in terms of the relative magnitude of the gradient. In the case of small $\\eta$ , the logits of all non-target classes are penalized equally, regardless of the difference in $\\hat { z } - \\bar { z }$ for different $\\bar { z } \\in \\mathcal { C } \\backslash \\{ \\hat { z } \\}$ . However, it is more reasonable to penalize more the logits that are closer to $\\hat { z }$ , which are more likely to cause misclassification. In the case of large $\\eta$ , although the logit that is most likely to cause misclassification is strongly penalized, the logits of other non-target classes are ignored. As a result, the logits of the non-target classes tend to be similar at convergence, ignoring the fact that some classes are closer to each other than the others. ",
+        "bbox": [
+            173,
+            344,
+            825,
+            470
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We propose two methods to exploit the prior knowledge that the magnitude of the logits should not be too small or too large. First, we can apply batch normalization to the logits. But instead of setting $\\gamma _ { c }$ ’s as trainable variables, we consider them as a single hyperparameter, $\\gamma _ { \\mathcal { C } }$ , such that $\\gamma _ { c } = \\gamma _ { c } , \\forall c \\in \\mathcal { C }$ . Tuning the value of $\\gamma _ { \\mathcal { C } }$ can lead to a better trade-off between the two extremes described by Eq. (21) and (22). The optimal value of $\\gamma _ { \\mathcal { C } }$ tends to remain the same for different optimizers or different network widths, but varies with dataset and network depth. We refer to this method as batch-normalized softmax (BN-Softmax). ",
+        "bbox": [
+            173,
+            477,
+            825,
+            575
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Alternatively, since the magnitude of the logits tends to grow larger than expected (in order to minimize the cross entropy), we can apply L2-regularization to the logits by adding the following penalty to the loss function: ",
+        "bbox": [
+            176,
+            582,
+            821,
+            623
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21930570e6ad5d25f580ad3cae5530791f026b7f99e3c12cf55cb99901245ace.jpg",
+        "text": "$$\nL _ { \\mathcal { C } } = \\frac { \\lambda _ { \\mathcal { C } } } { 2 } \\sum _ { c \\in \\mathcal { C } } z _ { c } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            618,
+            555,
+            657
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { \\mathcal { C } }$ is a hyperparameter to be tuned. Different from BN-Softmax, $\\lambda _ { C }$ can be shared by different datasets and networks of different depths. ",
+        "bbox": [
+            173,
+            660,
+            825,
+            689
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            709,
+            326,
+            726
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide empirical evidence for the analysis in Sec. 2.2, and evaluate the performance of ND-Adam and regularized softmax on CIFAR-10 and CIFAR-100. ",
+        "bbox": [
+            173,
+            741,
+            821,
+            770
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 THE EFFECT OF L2 WEIGHT DECAY",
+        "text_level": 1,
+        "bbox": [
+            176,
+            785,
+            465,
+            800
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To empirically examine the effect of L2 weight decay, we train a wide residual network (WRN) (Zagoruyko & Komodakis, 2016b) of 22 layers, with a width of 7.5 times that of a vanilla ResNet. Using the notation in Zagoruyko & Komodakis (2016b), we refer to this network as WRN-22-7.5. We train the network on the CIFAR-10 dataset (Krizhevsky & Hinton, 2009), with a small modification to the original WRN architecture, and with a different learning rate annealing schedule. Specifically, for simplicity and slightly better performance, we replace the last fully connected layer with a convolutional layer with 10 output feature maps. I.e., we change the layers after the last residual block from BN-ReLU-GlobalAvgPool-FC-Softmax to ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "BN-ReLU-Conv-GlobalAvgPool-Softmax. In addition, for clearer comparisons, the learning rate is annealed according to a cosine function without restart (Loshchilov & Hutter, 2016; Gastaldi, 2017). We train the model for 80k iterations with a batch size of 128, similar to the settings in Zagoruyko & Komodakis (2016b). The experiments are based on a TensorFlow implementation of WRN (Wu, 2016). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As a common practice, we use SGD with a momentum of 0.9, the analysis for which is similar to that in Sec. 2.2. Due to the linearity of derivatives and momentum, $\\Delta w _ { i }$ can be decomposed as $\\Delta w _ { i } = \\Delta w _ { i } ^ { l } + \\Delta w _ { i } ^ { p }$ , where $\\Delta w _ { i } ^ { l }$ and $\\Delta w _ { i } ^ { p }$ are the components corresponding to the original loss function, $L \\left( \\cdot \\right)$ , and the L2 penalty term (see Eq. (4)), respectively. Fig. 1a shows the ratio between the scalar projection of $\\Delta \\bar { w } _ { i } ^ { l }$ on $\\bar { \\Delta } w _ { i } ^ { p }$ and $\\left. \\Delta w _ { i } ^ { p } \\right. _ { 2 }$ , which indicates how the tendency of $\\Delta w _ { i } ^ { l }$ to increase $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ is compensated by $\\Delta w _ { i } ^ { p }$ . Note that $\\Delta w _ { i } ^ { p }$ points to the negative direction of $w _ { i }$ , even when momentum is used, since the direction change of $w _ { i }$ is slow. As shown in Fig. 1a, at the beginning of the training, $\\Delta w _ { i } ^ { p }$ dominants and quickly adjusts $\\lVert \\boldsymbol { w } _ { i } \\rVert _ { 2 }$ to its equilibrium value. During the middle stage of the training, the projection of $\\Delta w _ { i } ^ { l }$ on $\\Delta w _ { i } ^ { p }$ , and $\\Delta w _ { i } ^ { p }$ almost cancel each other out. Then, near the end of the training, the gradient of $w _ { i }$ diminishes rapidly to near zero, making $\\Delta w _ { i } ^ { p }$ dominant again. Therefore, Eq. (7) holds more accurately during the middle stage of the training. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            349
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 1b, we show how the effective learning rate varies in different hyperparameter settings. By Eq. (7), $\\left\\| \\Delta w _ { i } \\right\\| _ { 2 } / \\left\\| w _ { i } \\right\\| _ { 2 }$ is expected to remain the same as long as $\\alpha \\lambda$ stays constant, which is confirmed by the fact that the curve for $\\alpha _ { 0 } = 0 . 1 , \\lambda = 0 . 0 0 1$ overlaps with that for $\\alpha _ { 0 } = 0 . 0 5 , \\lambda =$ 0.002. However, comparing the curve for $\\alpha _ { 0 } = 0 . 1 , \\lambda = 0 . 0 0 1$ , with that for $\\alpha _ { 0 } = 0 . 1 , \\lambda =$ 0.0005, we can see that the value of $\\| \\Delta w _ { i } \\| _ { 2 } / \\| w _ { i } \\| _ { 2 }$ does not change proportionally to $\\alpha \\lambda$ . On the other hand, by using ND-Adam, we can control the value of $\\lVert \\Delta w _ { i } \\rVert _ { 2 } \\dot { / } \\lVert \\dot { w } _ { i } \\rVert _ { 2 }$ more precisely by adjusting the learning rate for weight vectors, $\\alpha ^ { v }$ . For the same training step, changes in $\\alpha ^ { v }$ lead to approximately proportional changes in $\\| \\Delta w _ { i } \\| _ { 2 } / \\| w _ { i } \\| _ { 2 }$ , as shown by the two curves corresponding to ND-Adam in Fig. 1b. ",
+        "bbox": [
+            173,
+            357,
+            825,
+            483
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/dcf5f1c901e84b092b98192aad1de61f46fb687abe7413362a2285ff99d328ee.jpg",
+        "image_caption": [
+            "(a) The scalar projection of $\\Delta w _ { i } ^ { l }$ on $\\Delta w _ { i } ^ { p }$ normalized by(b) The relative magnitude of the weight updates, or the $\\left. \\Delta w _ { i } ^ { p } \\right. _ { 2 }$ . effective learning rate. ",
+            "Figure 1: An illustration of how L2 weight decay and ND-Adam control the effective learning rate. The results are obtained from the 5th layer of the network, and other layers show similar results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            525,
+            812,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 PERFORMANCE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            416,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To compare the generalization performance of SGD, Adam, and ND-Adam, we train the same WRN22-7.5 network on the CIFAR-10 and CIFAR-100 datasets. For SGD and ND-Adam, we first tune the hyperparameters for SGD $( \\alpha _ { 0 } = 0 . 1 , \\lambda = 0 . 0 0 1$ , momentum 0.9), then tune the initial learning rate of ND-Adam for weight vectors to match the effective learning rate to that of SGD $\\alpha _ { 0 } ^ { v } = 0 . 0 5 )$ , as shown in Fig. 1b. While L2 weight decay can greatly affect the performance of SGD, it does not noticeably benefit Adam in our experiments. For Adam and ND-Adam, $\\beta _ { 1 }$ and $\\beta _ { 2 }$ are set to the default values of Adam, i.e., $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 9 9$ . Although the learning rate of Adam is usually set to a constant value, we observe better performance with the cosine learning rate schedule. The initial learning rate of Adam $( \\alpha _ { 0 } )$ , and that of ND-Adam for scalar parameters $( \\alpha _ { 0 } ^ { s } )$ are both tuned to 0.001. We use the same data augmentation scheme as used in Zagoruyko & Komodakis (2016b), including horizontal flips and random crops, but no dropout is used. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We first experiment with the use of trainable scaling parameters $( \\gamma _ { i } )$ of batch normalization. As shown in Fig. 2b, at convergence, the test accuracies of ND-Adam are significantly improved upon that of vanilla Adam, and matches that of SGD. Note that at the early stage of training, the training losses of Adam drop dramatically as shown in Fig. 2a, and the test accuracies also increase more rapidly than that of ND-Adam and SGD. However, the test accuracies remain at a high level afterwards, which indicates that Adam tends to quickly find and get stuck in bad local minima that do not generalize well. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The average results of 3 runs are summarized in the first part of Table 1. Interestingly, compared to SGD, ND-Adam shows slightly better performance on CIFAR-10, but worse performance on CIFAR-100. This inconsistency may be related to the problem of softmax discussed in Sec. 4, that there is a lack of proper control over the magnitude of the logits. But overall, given comparable effective learning rates, ND-Adam and SGD show similar generalization performance. In this sense, the effective learning rate is a more natural learning rate measure than the learning rate hyperparameters. ",
+        "bbox": [
+            173,
+            243,
+            825,
+            340
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/2258af99304275cba3dda8e135ac5499ddd95a8b02f54c25a7f467886f8ef9b4.jpg",
+        "image_caption": [
+            "Figure 2: The training losses and test accuracies of the same network trained with SGD, Adam, and ND-Adam. Batch normalization with scaling factors is used. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            378,
+            810,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Next, we repeat the experiments with the use of BN-Softmax. As discussed in Sec. 3.2, $\\gamma _ { i }$ ’s can be removed from a linear rectifier network, without changing the overall network function. Although this property does not strictly hold for residual networks due to the skip connections, we find that simply removing the scaling factors results in slightly improved generalization performance when using ND-Adam. However, the improvement is not consistent as it degrades performance of SGD. Interestingly, when BN-Softmax is further used, we observe consistent improvement over all three algorithms. Thus, we only report results for this setting. The scaling factor of the logits, $\\gamma _ { \\mathcal { C } }$ , is set to 2.5 for CIFAR-10, and 1 for CIFAR-100. As shown in the second part of Table 1, BN-Softmax significantly improves the performance of Adam and ND-Adam. Moreover, in this setting, we obtain the best generalization performance with ND-Adam, outperforming SGD and Adam on both CIFAR-10 and CIFAR-100. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While the TensorFlow implementation we use already provides an adequate test bed, we notice that it is different from the original implementation of WRN in several aspects. For instance, they use different nonlinearities (leaky ReLU vs. ReLU), and use different skip connections for downsampling (average pooling vs. strided convolution). A seemingly subtle but important difference is that, L2-regularization is applied not only to weight vectors, but also to the scales and biases of batch normalization in the original implementation, which leads to better generalization performance. For further comparison between SGD and ND-Adam, we reimplement ND-Adam and test its performance on a PyTorch version of the original implementation (Zagoruyko & Komodakis, 2016a). ",
+        "bbox": [
+            173,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Due to the aforementioned differences, we use a slightly different hyperparameter setting in this experiment. Specifically, for SGD $\\lambda$ is set to 5e 4, while for ND-Adam $\\lambda$ is set to 5e 6 (L2- regularization for biases), and both $\\alpha _ { 0 } ^ { s }$ and $\\alpha _ { 0 } ^ { v }$ are set to 0.04. In this case, regularizing softmax does not yield improved performance for SGD, since the L2-regularization applied to $\\gamma _ { i }$ ’s and the last layer weights can serve a similar purpose. Thus, we only apply L2-regularized softmax for ND-Adam with $\\lambda _ { C } = 0 . 0 0 1$ . The average results of 3 runs are summarized in Table 2. Note that the performance of SGD for WRN-28-10 is slightly better than that reported with the original implementation (i.e., 4.00 and 19.25), due to the modifications described in Sec. 5.1. In this experiment, SGD and ND-Adam show almost identical generalization performance. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b18d8319a01a5b33527c5568d4d8a9daa311ed6b273f8af12a0ff24dd7216e8.jpg",
+        "image_caption": [
+            "Figure 3: The training losses and test accuracies of the same network trained with SGD, Adam, and ND-Adam. Batch normalization without scaling factors, and BN-Softmax are used. ",
+            "Table 2: Test error rates of WRN-22-7.5 and WRN-28-10 networks on CIFAR-10 and CIFAR-100. Based on the original implementation of WRN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            128,
+            812,
+            287
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/ba0ff15ffa568869d208909ab34172633c428cbdada2f7bac7c01cd95fc9da28.jpg",
+        "table_caption": [
+            "Table 1: Test error rates of WRN-22-7.5 networks on CIFAR-10 and CIFAR-100. Based on a TensorFlow implementation of WRN. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>CIFAR-10 Method Error (%)</td><td>CIFAR-100 Error (%)</td></tr><tr><td>BN w/ scaling factors</td></tr><tr><td>SGD 4.61 20.60</td></tr><tr><td>Adam 6.14 25.51</td></tr><tr><td>ND-Adam 4.53 21.45</td></tr><tr><td colspan=\"2\">BN w/o scaling factors,BN-Softmax</td></tr><tr><td>SGD 4.49</td><td>20.18</td></tr><tr><td>Adam 5.43</td><td>22.48</td></tr><tr><td>ND-Adam 4.14</td><td>19.90</td></tr></table>",
+        "bbox": [
+            302,
+            351,
+            696,
+            527
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            602,
+            825,
+            688
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/5c5dc574638d1e9f111ffeede72952d7d27d8eb25a6a282d6a2a16879ed9dcb1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>CIFAR-10 Error (%)</td><td>CIFAR-100 Error (%)</td></tr><tr><td></td><td>WRN-22-7.5</td><td></td></tr><tr><td>SGD</td><td>3.84</td><td>19.24</td></tr><tr><td>ND-Adam</td><td>3.70</td><td>19.30</td></tr><tr><td>WRN-28-10</td><td></td><td></td></tr><tr><td>SGD</td><td>3.80</td><td>18.48</td></tr><tr><td>ND-Adam</td><td>3.70</td><td>18.42</td></tr></table>",
+        "bbox": [
+            302,
+            708,
+            696,
+            857
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have introduced ND-Adam, a tailored version of Adam for training DNNs, to bridge the generalization gap between Adam and SGD. ND-Adam is designed to preserve the direction of gradient for each weight vector, and produce the regularization effect of L2 weight decay in a more precise and principled way. Moreover, we have introduced regularized softmax, which limits the magnitude of softmax logits to provide better learning signals. By combining ND-Adam and regularized softmax, our experiments have shown significantly improved generalization performance, eliminating the gap between Adam and SGD. From a high-level view, our analysis and empirical results suggest the need for more precise control over the training process of DNNs. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            266,
+            285,
+            281
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Devansh Arpit, Stanisław Jastrz˛ebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S Kanwal, Tegan Maharaj, Asja Fischer, Aaron Courville, Yoshua Bengio, et al. A closer look at memorization in deep networks. arXiv preprint arXiv:1706.05394, 2017. ",
+        "bbox": [
+            176,
+            289,
+            821,
+            332
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. In ICML 2015, 2015. ",
+        "bbox": [
+            173,
+            339,
+            823,
+            369
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Theodore Lim, JM Ritchie, and Nick Weston. Freezeout: Accelerate training by progressively freezing layers. arXiv preprint arXiv:1706.04983, 2017. ",
+        "bbox": [
+            171,
+            377,
+            823,
+            407
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lawrence Cayton. Algorithms for manifold learning. Univ. of California at San Diego Tech. Rep, pp. 1–17, 2005. ",
+        "bbox": [
+            173,
+            415,
+            823,
+            445
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011. ",
+        "bbox": [
+            173,
+            453,
+            823,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xavier Gastaldi. Shake-shake regularization of 3-branch residual networks. In ICLR 2017 Workshop, 2017. ",
+        "bbox": [
+            171,
+            491,
+            823,
+            520
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, pp. 315–323, 2011. ",
+        "bbox": [
+            176,
+            527,
+            823,
+            570
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Elad Hazan, Kfir Levy, and Shai Shalev-Shwartz. Beyond convexity: Stochastic quasi-convex optimization. In Advances in Neural Information Processing Systems, pp. 1594–1602, 2015. ",
+        "bbox": [
+            174,
+            579,
+            821,
+            609
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            176,
+            617,
+            821,
+            660
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997. ",
+        "bbox": [
+            174,
+            669,
+            797,
+            684
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. arXiv preprint arXiv:1709.01507, 2017. ",
+        "bbox": [
+            173,
+            693,
+            823,
+            722
+        ],
+        "page_idx": 11
+    },
+    {
+        "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, pp. 448–456, 2015. ",
+        "bbox": [
+            174,
+            731,
+            823,
+            773
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. ICLR 2017, 2017. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            825
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            833,
+            821,
+            862
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            871,
+            821,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Sgdr: stochastic gradient descent with restarts. arXiv preprint arXiv:1608.03983, 2016. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hariharan Narayanan and Sanjoy Mitter. Sample complexity of testing the manifold hypothesis. In Advances in Neural Information Processing Systems, pp. 1786–1794, 2010. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Behnam Neyshabur, Ruslan R Salakhutdinov, and Nati Srebro. Path-sgd: Path-normalized optimization in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2422–2430, 2015. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Anders Oland, Aayush Bansal, Roger B Dannenberg, and Bhiksha Raj. Be careful what you backpropagate: A case for linear output activations & gradient boosting. arXiv preprint arXiv:1707.04199, 2017. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Salah Rifai, Yann N Dauphin, Pascal Vincent, Yoshua Bengio, and Xavier Muller. The manifold tangent classifier. In Advances in Neural Information Processing Systems, pp. 2294–2302, 2011. ",
+        "bbox": [
+            173,
+            243,
+            821,
+            273
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans and Diederik P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016. ",
+        "bbox": [
+            176,
+            281,
+            823,
+            324
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. In Advances in Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            173,
+            422,
+            826,
+            465
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Neal Wu. A tensorflow implementation of wide residual networks, 2016. URL https:// github.com/tensorflow/models/tree/master/research/resnet. ",
+        "bbox": [
+            173,
+            474,
+            823,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Adams Wei Yu, Qihang Lin, Ruslan Salakhutdinov, and Jaime Carbonell. Normalized gradient with adaptive stepsize method for deep neural network training. arXiv preprint arXiv:1707.04822, 2017. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. A pytorch implementation of wide residual networks, 2016a. URL https://github.com/szagoruyko/wide-residual-networks. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            593
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016b. ",
+        "bbox": [
+            173,
+            601,
+            825,
+            630
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012. ",
+        "bbox": [
+            173,
+            638,
+            823,
+            669
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In ICLR 2017, 2017. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            707
+        ],
+        "page_idx": 12
+    }
+]

parse/train/Tsp2PL7-GQ/Tsp2PL7-GQ.md

@@ -0,0 +1,231 @@
+# Can You Learn an Algorithm? Generalizing from Easy to Hard Problems with Recurrent Networks
+
+# Avi Schwarzschild
+
+Department of Mathematics University of Maryland College Park, MD, USA avi1@umd.edu
+
+Eitan Borgnia Department of Computer Science University of Maryland College Park, MD, USA
+
+Arjun Gupta Department of Robotics University of Maryland College Park, MD, USA
+
+Furong Huang Department of Computer Science University of Maryland College Park, MD, USA
+
+Uzi Vishkin Department of Electrical and Computer Engineering University of Maryland College Park, MD, USA
+
+Micah Goldblum Department of Computer Science University of Maryland College Park, MD, USA
+
+Tom Goldstein Department of Computer Science University of Maryland College Park, MD, USA
+
+# Abstract
+
+Deep neural networks are powerful machines for visual pattern recognition, but reasoning tasks that are easy for humans may still be difficult for neural models. Humans possess the ability to extrapolate reasoning strategies learned on simple problems to solve harder examples, often by thinking for longer. For example, a person who has learned to solve small mazes can easily extend the very same search techniques to solve much larger mazes by spending more time. In computers, this behavior is often achieved through the use of algorithms, which scale to arbitrarily hard problem instances at the cost of more computation. In contrast, the sequential computing budget of feed-forward neural networks is limited by their depth, and networks trained on simple problems have no way of extending their reasoning to accommodate harder problems. In this work, we show that recurrent networks trained to solve simple problems with few recurrent steps can indeed solve much more complex problems simply by performing additional recurrences during inference. We demonstrate this algorithmic behavior of recurrent networks on prefix sum computation, mazes, and chess. In all three domains, networks trained on simple problem instances are able to extend their reasoning abilities at test time simply by “thinking for longer.”
+
+# 1 Introduction
+
+In computational theories of mind, an analytical problem is tackled by embedding it in “working memory” and then iteratively applying transformations to the representation until the problem is solved [Baddeley, 2012, Baddeley and Hitch, 1974]. Iterative processes underlie the human ability to solve sequential reasoning problems, such as complex question answering, proof writing, and even object classification $\lVert \underline { { \tilde { \mathrm { L i a o ~ a n d ~ P o g g i o } } } } \rVert \underline { { 2 0 1 6 } } \rVert \underline { { \tilde { \mathrm { K a r ~ e t ~ a l l } } } } \rVert \underline { { 2 0 1 9 } } \rVert$ . They also enable humans to extrapolate their knowledge to solve problems of potentially unbounded complexity, including harder problems than they have seen before, by thinking for longer.
+
+This work examines whether recurrent neural networks trained on easy problems can extrapolate their knowledge to solve hard problems. We find that recurrent networks can indeed generalize to harder problems simply by increasing their test time iteration budget (i.e., thinking for longer than they did at train time). Moreover, we find that the performance of recurrent models improves as they recur for more iterations, even without adding parameters or re-training in the new, more challenging problem domain. This ability is specific to recurrent networks, as standard feed-forward networks rely on layer-specific behaviors that cannot be repeated to extend their reasoning power.
+
+The behavior we observe in recurrent networks falls outside the classical notions of generalization in which models are trained and tested on the same distribution. Because we train and test on problems of different sizes/difficulties, our training and test distributions are disjoint, and systems must extrapolate to solve problems from the test distribution. Outside the field of machine learning, computers achieve a functionally similar extrapolation ability through the use of algorithms, which encode the process required to solve a class of problems, and can therefore scale to problems of arbitrary size, albeit with longer runtime.
+
+By training networks to solve problems iteratively, we hope to find models that encode a scalable method for solving problems rather than memorizing a mapping between input features and outputs. In short, the goal is to create recurrent architectures that are capable of learning an algorithm.
+
+Our focus is on three reasoning problems that are classically solved using hand-crafted algorithms: computing prefix sums, solving mazes, and playing chess. Sequential reasoning tasks like these are ideal for our study because one can directly quantify the difficulty of a problem instance. In the case of mazes, for example, we can easily swap to a more challenging domain by increasing the size of the search space.
+
+For each class of problems, recurrent networks are trained on a set of “easy” problems using a fixed number of iterations of the recurrent module on the forward pass. After training is complete, we assess whether our models exhibit logical extrapolation behaviors by testing them on “hard” problems, with varying numbers of additional iterations. Remarkably, models trained on easy examples exhibit little extrapolative behavior until their iteration budget is increased — generalizing to harder problems requires thinking deeper. Moreover, we find recurrent models tested with a sufficient number of extra iterations outperform the inflexible feed-forward models of comparable depth, often by a wide margin. Finally, we visualize the iterative behavior of the recurrent module to gain insights into the problem solving process they discover.
+
+# 1.1 Related works
+
+Our investigation into generalizing from easy to hard examples builds on several bodies of work. Logical extrapolation encompasses a special kind of distributional shift. A number of existing works on domain generalization instead explore shifts, such as re-stylization and image corruptions, which do not represent an increase in scale or computational complexity [Arjovsky et al., 2019, Shu et al., $\boxed { 2 0 2 0 }$ . Also, the basic neural architectures we use are not new and build upon prior studies of weight sharing and recurrence [Pinheiro and Collobert, 2014, Liang and Hu, 2015, Alom et al., 2018, Bai et al., 2018, 2019, Lan et al., 2020, Jaegle et al., 2021]. Networks with variable numbers of test time iterations/layers have also been studied, including variable depth networks [Graves, 2016, Huang et al., 2016, Kaya et al., 2019, Eyzaguirre and Soto, 2020].
+
+Existing work on algorithm learning involves recurrent neural network (RNN) based approaches. For example, neural turing machines and neural GPUs can learn simple algorithms for tasks such as binary addition and multiplication [Graves et al., 2014, Kaiser and Sutskever, 2015]. Like most RNNs, the compute budget for these methods is inextricably tied to input length. Motivated by the fact that input sequence length is not necessarily correlated with the computational burden required to solve a problem, $\boxed { \mathrm { G r a v e s } } \boxed { \sqrt { 2 0 1 6 } }$ develops a method for RNNs to adaptively select a compute time limit. This work considers only sequence inputs and shows the benefits of decoupling compute budget from input length. A differentiable extension of the technique can also be applied to visual question answering [Eyzaguirre and Soto, 2020]
+
+The above works leverage neural networks with adaptive computation budgets to speed up and strengthen inference when learning on stationary distributions. In contrast, our work studies the logical extrapolation behaviors that recurrent networks possess when both computation budgets and problem difficulties are extended beyond the train-time regime. In the domain of constraint satisfiability problems (CSPs), Selsam et al. [2018] show message passing neural networks trained on small CSPs can generalize to larger problems if more messages are passed at test-time – a similar type of extrapolation to our methods, but for a very specific problem formulation.
+
+The particular problems we use to study this type of extrapolation include prefix sum computation and maze solving, two problems analyzed in the classical algorithms literature. For example, there are many ways to solve mazes, both classical (e.g. breadth first search) and learned (e.g. value iteration networks), but our goal is not to develop the best solver, rather to use mazes as a test bed for logical extrapolation $\overline { { \| \mathrm { T a m a r ~ e t ~ a l . } \| 2 0 1 6 } } $ . Our third case study is the game of chess, which has also been the focus of much artificial intelligence work [Romstad et al., Biswas and Regan, 2015, Silver et al., 2017, McIlroy-Young et al., 2020]. However, those efforts to play chess rely heavily on hand-crafted search algorithms, often paired with neural networks or opening books, and aim to play games from start to finish, both methods and goals that diverge from ours. As opposed to hard-coded algorithms, which scale by design, we are interested in studying whether learned processes can generalize from the data on which they are trained to even harder problems.
+
+# 2 Dataset descriptions
+
+We conduct experiments in three problem domains that are classically solved using hand-crafted algorithms. For each, we define datasets that have quantifiable notions of difficulty. This makes it possible to train models on easy/small examples and test them on harder/larger ones. We consider the task of computing prefix sums modulo two of binary bit strings, solving two-dimensional mazes, and finding the best move in chess puzzles.
+
+Prefix sums This problem is inspired by a similar dataset used by $\widetilde { | \mathrm { G r a v e s } | } \widetilde { | 2 0 1 6 | }$ . Each training sample is a binary string. The goal is to output a binary string of equal length, where each bit represents the cumulative sum of input bits modulo two. Our models accept input strings of any size, and we consider longer strings to be more difficult to process than shorter ones. Each dataset contains 10,000 uniform random binary strings without duplicates. We use datasets with input lengths of 32, 44, and 48 bits. See Figure 1 for an example input and the corresponding target output.
+
+![](images/6ba61e4f9b86e5d33e531134408964e5005e6400214a8bab8fd281a08da84600.jpg)  
+Figure 1: Prefix sum input and target example.
+
+Mazes We consider mazes generated using a depth-first search algorithm $\underline { { \ [ \mathrm { H i l l } ] [ 2 0 1 7 ] } }$ We train on 50,000 small $( 9 \times 9 )$ mazes, and we test on 10,000 larger $( 1 3 \times 1 3 )$ mazes. Our models are convolutional, and receive a maze as a $N \times N$ three-channel image, where the maze walls are black, and the start and goal locations are red and green, respectively. The label for each maze is a binary two-dimensional mask containing the locations of positions along the shortest path solution. Our models output a two logits per pixel which are then thresholded to a binary mask of the whole input, and we consider a candidate solution correct only if it exactly predicts the labeled path. See Figure 10 for an example. More examples are available in Appendix A.1.2.
+
+![](images/e5ba65125ced5cf1141b5ee0c6da55ddc261fc1b2ba859072452d3c52ff88eaf.jpg)  
+Figure 2: An example maze input and target. The target is a binary classification label for each pixel indicating on/off the optimal path.
+
+![](images/56a9178f21277f4cadccd2e520a77dcb1ec66c0fc4777b76af98727662a224af.jpg)  
+Figure 3: An example of a chess puzzle input (left) and target (right). In the target, white represents one and black is zero.
+
+Chess puzzles The third dataset we use is a corpus of chess puzzles. The data is furnished by Lichess, an online open-source chess server [Lichess, 2021]. From billions of games, Lichess compiles “puzzles” – mid-game boards for which a sequence of unique best moves is determinable (e.g. sequences of moves leading to a forced checkmate). From this database, we compiled labeled data where the inputs are $8 \times 8 \times 1 2$ arrays indicating the position of each piece on the board (one channel per piece type and color) and the outputs are $8 \times 8$ binary masks showing the origin and destination positions for the optimal move. See the example in Figure 3, where it is white to move and the solution to the puzzle is to move the queen from F3 to F7.
+
+The puzzles each have a difficulty rating determined by an Elo-like system (a standard system for rating players using tournament play) $\boxed { \boxed { \mathrm { E l o } } \boxed { 1 9 7 8 } }$ . When Lichess users, each with an Elo rating, attempt to solve the puzzle, the rating of the player and puzzle is updated as if they “played” against each other. After enough players encounter the puzzle, the rating of the puzzle reaches an equilibrium which gets recorded in the database. We use these ratings to distinguish between easy and hard; 600,000 puzzles of difficulty rating less than 1,385 are used for training, and testing is performed on 100,000 examples with ratings greater than 1,385.
+
+Our models output a confidence score between zero and one for each square on the board. We take the two highest scores and compare their locations to the target to measure correctness – only exact matches are considered correct.
+
+# 3 Model architectures & training
+
+In all of the experiments in this work, we employ network architectures based on ResNets [He et al., $\bigstar$ . Our feed-forward networks are slight deviations from the most commonly used ResNets, in that the width does not change except at the first layer and after the last residual block, and we do not use batch normalization. This is done so that the recurrent models, whose internal recurrent module has the same input and output dimensions, can be as similar as possible to the feed-forward ResNets. In fact, the only difference during training between a feed-forward and recurrent model of the same effective depth is that the weights are shared between the residual blocks in the recurrent models. We refer to the recurrent portion of the network as the recurrent module. Also, our models are fully convolutional with no fully connected heads. For solving prefix sums, which involves onedimensional strings, we further deviate from classical ResNets by using one-dimensional convolutions. For complete architectural details, see Appendix A.2.
+
+We measure recurrent models in terms of iterations and effective depth. An iteration is a repetition of the recurrent residual block, which contains four layers in all of our models. Therefore, the effective depth is equal to four times the number of iterations, plus non-recurrent encoder and head layers that sandwich the recurrent module. For example, the models used for computing prefix sums have one convolutional encoder layer, followed by the recurrent block and then by a three layer convolutional head. In this case, a 10-iteration model has effective depth $1 + 1 0 \times 4 + 3 = 4 4$ layers.
+
+For each training sample we consider, the label is an array of binary classification variables, one per input pixel. The training loss is simply the mean cross-entropy loss across output values. In general, hyperparameters were determined with the goal of finding convergent models. The specific batch sizes, learning rate and decay schedules, and other hyperparameter values are all available in Appendix A.3. 1
+
+# 4 Recurrent networks can generalize from easy to hard problems
+
+We explore the ability of recurrent neural networks to generalize to more difficult problems simply by thinking deeper. To this end, we train models of varying effective depth on easy training examples and test them on harder problems. We find that recurrent models are even better at generalizing from easy to hard than their feed-forward counterparts. While there is only one way to test the feed-forward models, we take a closer look at what happens when the recurrent models are allowed to think deeper about the harder problems. Formally, we use more iterations of the recurrent module within the recurrent models when performing inference on test data. Across all three problem types, we find that the confidence of the model is a good surrogate for correctness. Therefore, when evaluating recurrent models, we use the output from the iteration to which the network assigns the highest confidence.
+
+# 4.1 Prefix sums
+
+The first task on which we demonstrate the ability of recurrent neural networks to learn an algorithm is one from the classical algorithms literature, namely computing prefix sums. Specifically, we study the problem of computing the prefix sums modulo two of binary input strings.
+
+When computing prefix sums, we employ models with effective depths from 40 to 68 layers. We train models on easy data consisting of 32-bit input strings and test on harder 40-bit and 44-bit strings. In Table 1, it is clear that even when holding the depth constant at test time, recurrent models generalize from easy to hard better than feed-forward networks.
+
+Table 1: Extrapolating to longer input strings. Shown here are the average accuracies of models trained on 32-bit inputs and tested on 40-bit inputs. The effective depths listed below correspond to 9, 10, and 11 iterations in recurrent models. We report average accuracy $\pm$ one standard error.   
+
+<table><tr><td></td><td colspan="3">Effective Depth (Layers)</td></tr><tr><td></td><td>40</td><td>44</td><td>48</td></tr><tr><td>Recurrent</td><td>24.96± 2.96</td><td>31.02 ± 2.56</td><td>35.22 ± 3.34</td></tr><tr><td>Feed-forward</td><td>22.17 ± 0.85</td><td>24.78 ± 1.65</td><td>22.79 ± 1.32</td></tr></table>
+
+![](images/75d8a02adf1abd4ebc2e7a971fff383ea86cc068b4c7fe5762cfe8e2d8696123.jpg)  
+Figure 4: Generalizing from easy to hard prefix sums. The ability of networks to compute prefix sums on two test sets with longer input strings than were used for training (accuracy on 40-bit inputs in purple and on 44-bit inputs in red). We compare recurrent models to the best feed-forward models of comparable effective depth. The markers are at average values from several trials and the shaded regions indicate $\pm$ one standard error.
+
+When the thought budget, or number of iterations, is increased, we see that recurrent models can get upwards of $90 \%$ of the harder testing examples correct. In Figure 4, we observe this large boost in the recurrent models’ performance and a vast difference in the accuracy of recurrent models (with added iterations at test time) and feed-forward networks. Note that the dotted lines represent the average accuracy of the deepest feed-forward networks considered. That depth is 68 layers, or the effective depth of recurrent models with 16 iterations, and we use this baseline in the plot specifically because in the range of depths corresponding to the numbers of iterations shown, these feed-forward models achieve the highest accuracy. In other words, recurrent models trained with relatively few iterations generalize well to harder data while similar and even much larger feed-forward networks fail to generalize in the same scenario.
+
+The generalization we see in Figure 4 indicates that these recurrent models learn processes that can be extended to harder problems by running for more iterations. In particular, the recurrence is both the machinery that allows for varying the depth at test time, as well as a force at training to push the model to find parameters that make progress toward a solution with each reuse.
+
+When these results are viewed through the lens of algorithm design, one might wonder how the receptive field, or the number of entries in the input that determine a single entry in the output, affects these models. The feed-forward models, whose accuracies are shown in Figure 4, have the same receptive field as the recurrent models when tested with 16 iterations. This makes it clear that the increase in accuracy of recurrent models does not simply occur because the receptive field grows with added iterations, rather it occurs because they have learned a process that can extrapolate beyond the training distribution. Further discussion on receptive field is presented in Appendix B.
+
+# 4.1.1 Iterative outputs
+
+One way to dissect the learned process and compare it to known algorithms is to plot the confidence of the model at each iteration. In Figure $\boxed { 5 }$ we show a representative example of a network’s confidence that each bit in the output is a one. Two striking observations can be made from this figure. The first is that the model is progressing to the solution with each iteration. The second observation is that it is resolving the prefix sum in the earlier bits first and moving down the string, settling on the final bits only in the last iteration. This is remarkably similar to a naive algorithm one might implement for this task that marches from the first index until the end of the string computing prefix sums in order.
+
+![](images/cc860366995e3816ca17493ef6b4efdd036066e61f58f70f16f7e4200cdcc8b7.jpg)  
+Figure 5: A recurrent model’s output from each of 11 iterations on a 40-bit input string. Shown here is the confidence that there is a 1 at each index of the output. The first index is at the top for all vectors, the input is in the left-most column and the target is in the right-most column. The model used to produce this plot was trained with fewer iterations (10) on shorter input strings (32-bit).
+
+# 4.2 Mazes
+
+For maze solving, we train models on a training set composed of the easier small mazes, and we investigate the ability of networks to make the leap to larger, or harder, mazes at test time. In line with the findings above, we show two important behaviors. First, the recurrent models make the leap from small to large mazes better than feed-forward models. Second, when allowed to think deeper, the recurrent models exhibit even higher performance.
+
+The networks employed here are fully convolutional and have 512 channels in the internal layers. In assessing the confidence of a given output, we average each pixel’s classification confidence.
+
+Table 2 shows that for a fixed effective depth, recurrent models always generalize to the hard mazes better than their feed-forward counterparts. Inspired by the upward trend in Table 2, we shift focus to deeper models. In Figure $_ { . . } ^ { 6 , }$ we show that recurrent models can extrapolate to harder problems better than feed forward models. When trained on small mazes with 20 iterations (effective depth of 84 layers), these networks can solve about half of large mazes. However, when allowed to think for longer, the recurrent models can correctly solve an even higher proportion of large mazes. In fact, models trained with 20 iterations can achieve upward of $70 \%$ accuracy on large mazes using 5 additional iterations at test time.
+
+Table 2: The average accuracy $( \% )$ of models trained on small mazes and tested on large ones. Over a range of effective depths, we see that recurrent models generalize to the harder mazes better than their feed-forward counterparts. Figures reflect averages over several trials $\pm$ one standard error.   
+
+<table><tr><td></td><td colspan="5">Effective Depth</td></tr><tr><td></td><td>20</td><td>24</td><td>28</td><td>36</td><td>44</td></tr><tr><td>Recurrent</td><td>12.66 ± 0.44</td><td>14.02 ± 0.39</td><td>19.95 ± 0.31</td><td>22.96 ± 1.03</td><td>29.72 ± 1.22</td></tr><tr><td>Feed-forward</td><td>7.94 ± 0.36</td><td>12.43 ± 0.50</td><td>14.67 ± 0.54</td><td>17.71 ± 0.36</td><td>22.53 ± 1.14</td></tr></table>
+
+![](images/e38418ead266361297b87df3bbe4d5a138e8de0facc71a6608896165cdd862cd.jpg)  
+Figure 6: Generalizing from easy to hard mazes. We compare recurrent models to the best feedforward models. The markers are at average values from several trials and the shaded regions indicate $\pm$ one standard error.
+
+Maze solving is another task for which global information is needed. We investigate how dilated filters affect model performance. Dilation is a way of changing the receptive field without adding new parameters or more depth. Table $\textcircled { 3 }$ shows that dilations lead to slight improvements, however, the benefits of recurrence are still abundantly clear. Indeed, the difference in performance is even larger.
+
+Table 3: The average accuracy $( \% )$ of models with dilated filters trained on small mazes and tested on large ones. Figures reflect averages over several trials $\pm$ one standard deviation.   
+
+<table><tr><td></td><td colspan="5">Effective Depth</td></tr><tr><td></td><td>20</td><td>24</td><td>28</td><td>32</td><td>36</td></tr><tr><td>Recurrent</td><td>33.60±1.06</td><td>40.49 ± 1.63</td><td>33.91 ± 1.99</td><td>40.56± 4.34</td><td>50.50± 7.97</td></tr><tr><td>Feed-forward</td><td>19.73 ± 0.72</td><td>21.59 ± 0.22</td><td>24.18 ± 1.33</td><td>25.82 ± 0.10</td><td>26.54 ± 2.13</td></tr></table>
+
+# 4.2.1 Iterative outputs
+
+The recurrent maze solving networks also produce output at every iteration. Examining this output again leads to a remarkable conclusion: these recurrent models are narrowing in on the answer with each successive iteration. In Figure $\bigstar$ it is clear from the output on iteration four that the network has found two routes emanating from the red square. Moving through the iterations, the model refines the output, increasing the confidence for pixels on the path and decreasing the others until finally at Iteration $\# 7$ , the output matches the target. It is also interesting to observe here that the output is consistently correct for two iterations, after which a few pixels flip (Iteration #9).
+
+![](images/c45db6e9d1e5bb3e1aa89809a44a26336f5a0254f1d218ee8c475568d7efeae9.jpg)  
+Figure 7: Input, target, and outputs from different iterations are shown to highlight the model’s ability to think sequentially about mazes. We plot the model’s confidence that each pixel belongs to the optimal path. This is a representative example from a model trained to solve small mazes in six iterations.
+
+# 4.3 Chess puzzles
+
+The third dataset comprises chess puzzles, or mid-game chess boards for which we seek the best next move. Unlike the other two datasets, the state of the art for chess playing algorithms is complex and has components that use algorithms like Monte Carlo tree search as well as neural network based elements for evaluating positions $\mathbf { \underline { { \{ R o m s t a d e t ~ a l . \} } } \mathbf { \underline { { \{ S i l v e r ~ e t ~ a l . \} } } } \mathbf { \underline { { \{ 2 0 1 7 \} } } } }$ . The complicated nature of these systems provides some context for how difficult these puzzles are. What makes these puzzles particularly useful for us is that there is a predetermined best next move. A move is defined as an origin square, or the current location of the piece to be moved, and a destination square $\bigstar \bigstar \mathrm { I n }$ order to generate target outputs for our models, we define a move as an $8 \times 8$ array with zeros everywhere except at the entries corresponding to the origin and destination squares which are ones.
+
+We compare recurrent and feed-forward networks of effective depths from 84 layers to 100 layers that take $8 \times 8 \times 1 2$ arrays as input. These fully convolutional networks have 512 channels in the internal layers, and the output is $8 \times 8 \times 2$ , corresponding to binary classification at each input pixel. During training, we use an average of cross-entropy losses at every pixel. When evaluating these models, however, we define the predicted move by the locations of the two highest confidence scores.
+
+![](images/6f9d9a1acf162443b4d148f5bae2d9a42780222acadcdfd89f24871d2bf11b31.jpg)  
+Figure 8: Generalizing from easy to hard chess puzzles. The ability of networks to solve harder puzzles than were used for training. We compare recurrent models to the best feed-forward models of comparable effective depth. The markers are at average values from several trials and the shaded region indicate $\pm$ one standard error.
+
+Once again, we see that recurrent models can solve more chess puzzles than their feed forward counterparts. Furthermore, by thinking deeper at test time, recurrent models can perform even better. While the gains shown in Figure 8 are modest in comparison to the other two problem settings, the trend is clear – recurrent models can solve more puzzles with more iterations.
+
+# 4.3.1 Iterative outputs
+
+![](images/017703ea05676fb6338275cc07cc4ce4a8e731b4907e2dc7c7820afd6e096b4a.jpg)  
+Figure 9: Input, target, and outputs form different iterations are shown to highlight the model’s ability to think about the next move. We plot the model’s confidence that each pixel is one of the two that define a move. In this example, black is to move next. For space consideration, iterations 2-14, which look like the first iteration, are left out of this plot. More examples are available in Appendix C.
+
+While the outputs from the other two datasets show the similarity between the learned iterative process and known sum and search algorithms, extracting that insight on chess puzzles is much more difficult. Partly, this is because exploiting known search algorithms on such a large search space is hard to visualize. Nonetheless, the network’s output, shown in Figure 9, tells a fascinating story. First, the Iteration #1 plot shows that after one iteration, we observe equal confidence at every location on the board. In the next frame, Iteration $\# 1 5$ , it is clear that the model is considering moving the D8 rook to multiple squares, and it also considers the intuitive idea of using the E5 queen to place the white king in check on H2. With each successive iteration, the network becomes more confident – first that the rook is the correct piece to move, and then where to move it to.
+
+# 5 Discussion
+
+More than an answer, the results and conclusions in this paper are posing a question: Can learned models behave like classical algorithms in the way they generalize to harder or larger problems?
+
+Our discussion of this question and our observations begins with delineating the limitations of our work. The first major limitation is that we do not propose a definitive answer. Rather, using representative cases, we demonstrate that recurrence can help neural models make the leap from easy training data to hard testing examples. A more subtle limitation of our work lies in how we split the data by difficulty. For prefix sum computation and for mazes, the classical algorithms approach to measuring problem complexity is tied to problem size, so in those settings we make intuitive easy/hard splits. With chess however, the issue is much more complex. Should puzzles with higher ratings require more memory or more computation? We carry out our work assuming the answer is yes, but we remain open minded to the possibility that the ratings assigned by Lichess may be weak surrogates for algorithmic complexity of each puzzle. In short, chess is an extremely difficult domain to analyze.
+
+The observations above indicate that iterative models can learn processes that generalize beyond the training distribution with more iterations. One exciting use case is when the testing distribution is inaccessible, a setting where training on the harder distribution itself would be impossible. Many real life scenarios demand exactly this type of problem solving, from robots deployed in the real world after training in simulation to humans who spend a lot of time practicing on easy math problems only to spend years on difficult unsolved questions.
+
+On a conceptual level, the recurrent model behavior we show is analogous to the human behavior of manipulating representations in working memory; in this analogy, the recurrent block performs the transformations and the activations it generates are the memory. It is not the goal of the experiments here to suggest that iterative models use mechanisms similar to those in a human brain. Nonetheless, it is exciting to see, even in a proof of concept setting, neural models that appear to deliberate on a problem until it is solved and can extend their abilities by thinking for longer.
+
+This raises a questions that motivates future work. Can we build neural networks that can think for even longer? Is it feasible to have models whose performance only increases with added compute time? Humans who are given more than enough time to solve a maze, will not suddenly get it wrong after arriving at the right answer, perhaps this awareness of when to stop thinking can be built into networks like the ones we study here.
+
+# 6 Conclusion
+
+In this work, we demonstrate that neural networks are capable of solving sequential reasoning tasks and then extrapolating this knowledge to solve problems of greater complexity than they were trained on. These recurrent models are largely inspired by the classical theory of mind, in which the brain iteratively applies primitive strategies to solve complex problems over time [Baddeley, 2012] Our models are recurrent versions of popular architectures and we acknowledge that variations to the model may be helpful. Thus, we leave an in depth investigation into other neural network designs for future work.
+
+Interestingly, the resulting models excel at solving problems that are classically solved by handcrafted algorithms; prefix sums are computed using reduction trees, mazes are classically solved by depth/breadth first search, and chess is solved by Monte-Carlo tree search. Even with the advances in machine learning that we have today, hand-crafted algorithms still play a role in state-of-the-art reasoning systems. A prominent example is AlphaZero, which plays board games using Monte-Carlo tree search algorithms assisted by a learned pruning function [Silver et al., 2017]. While moving away from this paradigm that includes hand-crafted elements is highly ambitious, this work suggests that it may be possible to train gameplay systems without building them on top of a hand-crafted tree search engine. In other words, it may be possible to machine-learn these algorithmic behaviors end-to-end.
+
+# Acknowledgements
+
+This project was supported by the ONR MURI program, AFOSR MURI program, the DARPA Young Faculty Award, and the National Science Foundation Division of Mathematical Sciences. Additional support was provided by Capital One Bank and JP Morgan Chase. Additionally, we thank Avrim Blum for thought-provoking and insightful conversations.
+
+# References
+
+Md Zahangir Alom, Mahmudul Hasan, Chris Yakopcic, Tarek M Taha, and Vijayan K Asari. Recurrent residual convolutional neural network based on u-net (r2u-net) for medical image segmentation. arXiv preprint arXiv:1802.06955, 2018.   
+Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019.   
+Alan Baddeley. Working memory: theories, models, and controversies. Annual review of psychology, 63:1–29, 2012.   
+Alan D Baddeley and Graham Hitch. Working memory. In Psychology of learning and motivation, volume 8, pages 47–89. Elsevier, 1974.   
+Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Trellis networks for sequence modeling. In International Conference on Learning Representations, 2018.   
+Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Deep equilibrium models. Advances in Neural Information Processing Systems, 32:690–701, 2019.
+
+Tamal Biswas and Kenneth Regan. Measuring level-k reasoning, satisficing, and human error in gameplay data. In 2015 IEEE 14th International Conference on Machine Learning and Applications (ICMLA), pages 941–947. IEEE, 2015.
+
+Arpad E Elo. The rating of chessplayers, past and present. Arco Pub., 1978.
+
+Cristobal Eyzaguirre and Alvaro Soto. Differentiable adaptive computation time for visual reasoning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 12817–12825, 2020.
+
+Alex Graves. Adaptive computation time for recurrent neural networks. arXiv preprint arXiv:1603.08983, 2016.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016.
+
+Christian Hill. Making a maze, Apr 2017. URL https://scipython.com/blog/ making-a-maze/.
+
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In European conference on computer vision, pages 646–661. Springer, 2016.
+
+Andrew Jaegle, Felix Gimeno, Andrew Brock, Andrew Zisserman, Oriol Vinyals, and Joao Carreira. Perceiver: General perception with iterative attention. arXiv preprint arXiv:2103.03206, 2021.
+
+Łukasz Kaiser and Ilya Sutskever. Neural gpus learn algorithms. arXiv preprint arXiv:1511.08228, 2015.
+
+Kohitij Kar, Jonas Kubilius, Kailyn Schmidt, Elias B Issa, and James J DiCarlo. Evidence that recurrent circuits are critical to the ventral stream’s execution of core object recognition behavior. Nature neuroscience, 22(6):974–983, 2019.
+
+Yigitcan Kaya, Sanghyun Hong, and Tudor Dumitras. Shallow-deep networks: Understanding and mitigating network overthinking. In International Conference on Machine Learning, pages 3301–3310. PMLR, 2019.
+
+Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. Albert: A lite bert for self-supervised learning of language representations. In International Conference on Learning Representations, 2020.
+
+Ming Liang and Xiaolin Hu. Recurrent convolutional neural network for object recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 3367–3375, 2015.
+
+Qianli Liao and Tomaso Poggio. Bridging the gaps between residual learning, recurrent neural networks and visual cortex. arXiv preprint arXiv:1604.03640, 2016.
+
+Lichess. Lichess open puzzles database. https://database.lichess.org/#puzzles, 2021. Accessed: 2021-04-01.
+
+Reid McIlroy-Young, Siddhartha Sen, Jon Kleinberg, and Ashton Anderson. Aligning superhuman ai with human behavior: Chess as a model system. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1677–1687, 2020.
+
+Pedro Pinheiro and Ronan Collobert. Recurrent convolutional neural networks for scene labeling. In International conference on machine learning, pages 82–90. PMLR, 2014.
+
+Tord Romstad, Marco Costalba, and et al. Kiiski, Joona. Stockfish: A strong open source chess engine. URL https://stockfishchess.org/.
+
+Avi Schwarzschild, Eitan Borgnia, Arjun Gupta, Arpit Bansal, Zeyad Emam, Furong Huang, Micah Goldblum, and Tom Goldstein. Datasets for studying generalization from easy to hard examples. arXiv preprint arXiv:2108.06011, 2021.
+
+Daniel Selsam, Matthew Lamm, Benedikt Bünz, Percy Liang, Leonardo de Moura, and David L Dill. Learning a sat solver from single-bit supervision. arXiv preprint arXiv:1802.03685, 2018.
+
+Manli Shu, Zuxuan Wu, Micah Goldblum, and Tom Goldstein. Preparing for the worst: Making networks less brittle with adversarial batch normalization. arXiv preprint arXiv:2009.08965, 2020.
+
+David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. Mastering chess and shogi by self-play with a general reinforcement learning algorithm. arXiv preprint arXiv:1712.01815, 2017.
+
+Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. arXiv preprint arXiv:1602.02867, 2016.

parse/train/Tsp2PL7-GQ/Tsp2PL7-GQ_content_list.json

@@ -0,0 +1,1281 @@
+[
+    {
+        "type": "text",
+        "text": "Can You Learn an Algorithm? Generalizing from Easy to Hard Problems with Recurrent Networks ",
+        "text_level": 1,
+        "bbox": [
+            199,
+            122,
+            799,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Avi Schwarzschild ",
+        "text_level": 1,
+        "bbox": [
+            222,
+            227,
+            349,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Mathematics University of Maryland College Park, MD, USA avi1@umd.edu ",
+        "bbox": [
+            191,
+            241,
+            375,
+            295
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Eitan Borgnia Department of Computer Science University of Maryland College Park, MD, USA ",
+        "bbox": [
+            400,
+            226,
+            620,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Arjun Gupta Department of Robotics University of Maryland College Park, MD, USA ",
+        "bbox": [
+            645,
+            227,
+            807,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Furong Huang Department of Computer Science University of Maryland College Park, MD, USA ",
+        "bbox": [
+            199,
+            318,
+            421,
+            373
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Uzi Vishkin Department of Electrical and Computer Engineering University of Maryland College Park, MD, USA ",
+        "bbox": [
+            452,
+            316,
+            797,
+            373
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Micah Goldblum Department of Computer Science University of Maryland College Park, MD, USA ",
+        "bbox": [
+            240,
+            393,
+            462,
+            450
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tom Goldstein Department of Computer Science University of Maryland College Park, MD, USA ",
+        "bbox": [
+            534,
+            393,
+            758,
+            450
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            484,
+            535,
+            501
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks are powerful machines for visual pattern recognition, but reasoning tasks that are easy for humans may still be difficult for neural models. Humans possess the ability to extrapolate reasoning strategies learned on simple problems to solve harder examples, often by thinking for longer. For example, a person who has learned to solve small mazes can easily extend the very same search techniques to solve much larger mazes by spending more time. In computers, this behavior is often achieved through the use of algorithms, which scale to arbitrarily hard problem instances at the cost of more computation. In contrast, the sequential computing budget of feed-forward neural networks is limited by their depth, and networks trained on simple problems have no way of extending their reasoning to accommodate harder problems. In this work, we show that recurrent networks trained to solve simple problems with few recurrent steps can indeed solve much more complex problems simply by performing additional recurrences during inference. We demonstrate this algorithmic behavior of recurrent networks on prefix sum computation, mazes, and chess. In all three domains, networks trained on simple problem instances are able to extend their reasoning abilities at test time simply by “thinking for longer.” ",
+        "bbox": [
+            232,
+            515,
+            766,
+            751
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            775,
+            312,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In computational theories of mind, an analytical problem is tackled by embedding it in “working memory” and then iteratively applying transformations to the representation until the problem is solved [Baddeley, 2012, Baddeley and Hitch, 1974]. Iterative processes underlie the human ability to solve sequential reasoning problems, such as complex question answering, proof writing, and even object classification $\\lVert \\underline { { \\tilde { \\mathrm { L i a o ~ a n d ~ P o g g i o } } } } \\rVert \\underline { { 2 0 1 6 } } \\rVert \\underline { { \\tilde { \\mathrm { K a r ~ e t ~ a l l } } } } \\rVert \\underline { { 2 0 1 9 } } \\rVert$ . They also enable humans to extrapolate their knowledge to solve problems of potentially unbounded complexity, including harder problems than they have seen before, by thinking for longer. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This work examines whether recurrent neural networks trained on easy problems can extrapolate their knowledge to solve hard problems. We find that recurrent networks can indeed generalize to harder problems simply by increasing their test time iteration budget (i.e., thinking for longer than they did at train time). Moreover, we find that the performance of recurrent models improves as they recur for more iterations, even without adding parameters or re-training in the new, more challenging problem domain. This ability is specific to recurrent networks, as standard feed-forward networks rely on layer-specific behaviors that cannot be repeated to extend their reasoning power. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The behavior we observe in recurrent networks falls outside the classical notions of generalization in which models are trained and tested on the same distribution. Because we train and test on problems of different sizes/difficulties, our training and test distributions are disjoint, and systems must extrapolate to solve problems from the test distribution. Outside the field of machine learning, computers achieve a functionally similar extrapolation ability through the use of algorithms, which encode the process required to solve a class of problems, and can therefore scale to problems of arbitrary size, albeit with longer runtime. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "By training networks to solve problems iteratively, we hope to find models that encode a scalable method for solving problems rather than memorizing a mapping between input features and outputs. In short, the goal is to create recurrent architectures that are capable of learning an algorithm. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our focus is on three reasoning problems that are classically solved using hand-crafted algorithms: computing prefix sums, solving mazes, and playing chess. Sequential reasoning tasks like these are ideal for our study because one can directly quantify the difficulty of a problem instance. In the case of mazes, for example, we can easily swap to a more challenging domain by increasing the size of the search space. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For each class of problems, recurrent networks are trained on a set of “easy” problems using a fixed number of iterations of the recurrent module on the forward pass. After training is complete, we assess whether our models exhibit logical extrapolation behaviors by testing them on “hard” problems, with varying numbers of additional iterations. Remarkably, models trained on easy examples exhibit little extrapolative behavior until their iteration budget is increased — generalizing to harder problems requires thinking deeper. Moreover, we find recurrent models tested with a sufficient number of extra iterations outperform the inflexible feed-forward models of comparable depth, often by a wide margin. Finally, we visualize the iterative behavior of the recurrent module to gain insights into the problem solving process they discover. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            546
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 Related works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            566,
+            312,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our investigation into generalizing from easy to hard examples builds on several bodies of work. Logical extrapolation encompasses a special kind of distributional shift. A number of existing works on domain generalization instead explore shifts, such as re-stylization and image corruptions, which do not represent an increase in scale or computational complexity [Arjovsky et al., 2019, Shu et al., $\\boxed { 2 0 2 0 }$ . Also, the basic neural architectures we use are not new and build upon prior studies of weight sharing and recurrence [Pinheiro and Collobert, 2014, Liang and Hu, 2015, Alom et al., 2018, Bai et al., 2018, 2019, Lan et al., 2020, Jaegle et al., 2021]. Networks with variable numbers of test time iterations/layers have also been studied, including variable depth networks [Graves, 2016, Huang et al., 2016, Kaya et al., 2019, Eyzaguirre and Soto, 2020]. ",
+        "bbox": [
+            173,
+            593,
+            825,
+            720
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Existing work on algorithm learning involves recurrent neural network (RNN) based approaches. For example, neural turing machines and neural GPUs can learn simple algorithms for tasks such as binary addition and multiplication [Graves et al., 2014, Kaiser and Sutskever, 2015]. Like most RNNs, the compute budget for these methods is inextricably tied to input length. Motivated by the fact that input sequence length is not necessarily correlated with the computational burden required to solve a problem, $\\boxed { \\mathrm { G r a v e s } } \\boxed { \\sqrt { 2 0 1 6 } }$ develops a method for RNNs to adaptively select a compute time limit. This work considers only sequence inputs and shows the benefits of decoupling compute budget from input length. A differentiable extension of the technique can also be applied to visual question answering [Eyzaguirre and Soto, 2020] ",
+        "bbox": [
+            173,
+            724,
+            825,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The above works leverage neural networks with adaptive computation budgets to speed up and strengthen inference when learning on stationary distributions. In contrast, our work studies the logical extrapolation behaviors that recurrent networks possess when both computation budgets and problem difficulties are extended beyond the train-time regime. In the domain of constraint satisfiability problems (CSPs), Selsam et al. [2018] show message passing neural networks trained on small CSPs can generalize to larger problems if more messages are passed at test-time – a similar type of extrapolation to our methods, but for a very specific problem formulation. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The particular problems we use to study this type of extrapolation include prefix sum computation and maze solving, two problems analyzed in the classical algorithms literature. For example, there are many ways to solve mazes, both classical (e.g. breadth first search) and learned (e.g. value iteration networks), but our goal is not to develop the best solver, rather to use mazes as a test bed for logical extrapolation $\\overline { { \\| \\mathrm { T a m a r ~ e t ~ a l . } \\| 2 0 1 6 } } $ . Our third case study is the game of chess, which has also been the focus of much artificial intelligence work [Romstad et al., Biswas and Regan, 2015, Silver et al., 2017, McIlroy-Young et al., 2020]. However, those efforts to play chess rely heavily on hand-crafted search algorithms, often paired with neural networks or opening books, and aim to play games from start to finish, both methods and goals that diverge from ours. As opposed to hard-coded algorithms, which scale by design, we are interested in studying whether learned processes can generalize from the data on which they are trained to even harder problems. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Dataset descriptions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            315,
+            374,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments in three problem domains that are classically solved using hand-crafted algorithms. For each, we define datasets that have quantifiable notions of difficulty. This makes it possible to train models on easy/small examples and test them on harder/larger ones. We consider the task of computing prefix sums modulo two of binary bit strings, solving two-dimensional mazes, and finding the best move in chess puzzles. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Prefix sums This problem is inspired by a similar dataset used by $\\widetilde { | \\mathrm { G r a v e s } | } \\widetilde { | 2 0 1 6 | }$ . Each training sample is a binary string. The goal is to output a binary string of equal length, where each bit represents the cumulative sum of input bits modulo two. Our models accept input strings of any size, and we consider longer strings to be more difficult to process than shorter ones. Each dataset contains 10,000 uniform random binary strings without duplicates. We use datasets with input lengths of 32, 44, and 48 bits. See Figure 1 for an example input and the corresponding target output. ",
+        "bbox": [
+            173,
+            438,
+            826,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ba61e4f9b86e5d33e531134408964e5005e6400214a8bab8fd281a08da84600.jpg",
+        "image_caption": [
+            "Figure 1: Prefix sum input and target example. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            326,
+            539,
+            674,
+            570
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Mazes We consider mazes generated using a depth-first search algorithm $\\underline { { \\ [ \\mathrm { H i l l } ] [ 2 0 1 7 ] } }$ We train on 50,000 small $( 9 \\times 9 )$ mazes, and we test on 10,000 larger $( 1 3 \\times 1 3 )$ mazes. Our models are convolutional, and receive a maze as a $N \\times N$ three-channel image, where the maze walls are black, and the start and goal locations are red and green, respectively. The label for each maze is a binary two-dimensional mask containing the locations of positions along the shortest path solution. Our models output a two logits per pixel which are then thresholded to a binary mask of the whole input, and we consider a candidate solution correct only if it exactly predicts the labeled path. See Figure 10 for an example. More examples are available in Appendix A.1.2. ",
+        "bbox": [
+            173,
+            622,
+            826,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e5ba65125ced5cf1141b5ee0c6da55ddc261fc1b2ba859072452d3c52ff88eaf.jpg",
+        "image_caption": [
+            "Figure 2: An example maze input and target. The target is a binary classification label for each pixel indicating on/off the optimal path. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            752,
+            475,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/56a9178f21277f4cadccd2e520a77dcb1ec66c0fc4777b76af98727662a224af.jpg",
+        "image_caption": [
+            "Figure 3: An example of a chess puzzle input (left) and target (right). In the target, white represents one and black is zero. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            519,
+            751,
+            795,
+            856
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Chess puzzles The third dataset we use is a corpus of chess puzzles. The data is furnished by Lichess, an online open-source chess server [Lichess, 2021]. From billions of games, Lichess compiles “puzzles” – mid-game boards for which a sequence of unique best moves is determinable (e.g. sequences of moves leading to a forced checkmate). From this database, we compiled labeled data where the inputs are $8 \\times 8 \\times 1 2$ arrays indicating the position of each piece on the board (one channel per piece type and color) and the outputs are $8 \\times 8$ binary masks showing the origin and destination positions for the optimal move. See the example in Figure 3, where it is white to move and the solution to the puzzle is to move the queen from F3 to F7. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The puzzles each have a difficulty rating determined by an Elo-like system (a standard system for rating players using tournament play) $\\boxed { \\boxed { \\mathrm { E l o } } \\boxed { 1 9 7 8 } }$ . When Lichess users, each with an Elo rating, attempt to solve the puzzle, the rating of the player and puzzle is updated as if they “played” against each other. After enough players encounter the puzzle, the rating of the puzzle reaches an equilibrium which gets recorded in the database. We use these ratings to distinguish between easy and hard; 600,000 puzzles of difficulty rating less than 1,385 are used for training, and testing is performed on 100,000 examples with ratings greater than 1,385. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our models output a confidence score between zero and one for each square on the board. We take the two highest scores and compare their locations to the target to measure correctness – only exact matches are considered correct. ",
+        "bbox": [
+            176,
+            311,
+            825,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Model architectures & training ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            373,
+            465,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In all of the experiments in this work, we employ network architectures based on ResNets [He et al., $\\bigstar$ . Our feed-forward networks are slight deviations from the most commonly used ResNets, in that the width does not change except at the first layer and after the last residual block, and we do not use batch normalization. This is done so that the recurrent models, whose internal recurrent module has the same input and output dimensions, can be as similar as possible to the feed-forward ResNets. In fact, the only difference during training between a feed-forward and recurrent model of the same effective depth is that the weights are shared between the residual blocks in the recurrent models. We refer to the recurrent portion of the network as the recurrent module. Also, our models are fully convolutional with no fully connected heads. For solving prefix sums, which involves onedimensional strings, we further deviate from classical ResNets by using one-dimensional convolutions. For complete architectural details, see Appendix A.2. ",
+        "bbox": [
+            173,
+            405,
+            826,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We measure recurrent models in terms of iterations and effective depth. An iteration is a repetition of the recurrent residual block, which contains four layers in all of our models. Therefore, the effective depth is equal to four times the number of iterations, plus non-recurrent encoder and head layers that sandwich the recurrent module. For example, the models used for computing prefix sums have one convolutional encoder layer, followed by the recurrent block and then by a three layer convolutional head. In this case, a 10-iteration model has effective depth $1 + 1 0 \\times 4 + 3 = 4 4$ layers. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            647
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For each training sample we consider, the label is an array of binary classification variables, one per input pixel. The training loss is simply the mean cross-entropy loss across output values. In general, hyperparameters were determined with the goal of finding convergent models. The specific batch sizes, learning rate and decay schedules, and other hyperparameter values are all available in Appendix A.3. 1 ",
+        "bbox": [
+            174,
+            654,
+            825,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Recurrent networks can generalize from easy to hard problems ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            743,
+            732,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We explore the ability of recurrent neural networks to generalize to more difficult problems simply by thinking deeper. To this end, we train models of varying effective depth on easy training examples and test them on harder problems. We find that recurrent models are even better at generalizing from easy to hard than their feed-forward counterparts. While there is only one way to test the feed-forward models, we take a closer look at what happens when the recurrent models are allowed to think deeper about the harder problems. Formally, we use more iterations of the recurrent module within the recurrent models when performing inference on test data. Across all three problem types, we find that the confidence of the model is a good surrogate for correctness. Therefore, when evaluating recurrent models, we use the output from the iteration to which the network assigns the highest confidence. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            872
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Prefix sums ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            137,
+            294,
+            151
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The first task on which we demonstrate the ability of recurrent neural networks to learn an algorithm is one from the classical algorithms literature, namely computing prefix sums. Specifically, we study the problem of computing the prefix sums modulo two of binary input strings. ",
+        "bbox": [
+            174,
+            162,
+            825,
+            205
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "When computing prefix sums, we employ models with effective depths from 40 to 68 layers. We train models on easy data consisting of 32-bit input strings and test on harder 40-bit and 44-bit strings. In Table 1, it is clear that even when holding the depth constant at test time, recurrent models generalize from easy to hard better than feed-forward networks. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            267
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/dd397a515513652d3248480fee02d23e512d7a8b6b9d822538b58f48e2f52657.jpg",
+        "table_caption": [
+            "Table 1: Extrapolating to longer input strings. Shown here are the average accuracies of models trained on 32-bit inputs and tested on 40-bit inputs. The effective depths listed below correspond to 9, 10, and 11 iterations in recurrent models. We report average accuracy $\\pm$ one standard error. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Effective Depth (Layers)</td></tr><tr><td></td><td>40</td><td>44</td><td>48</td></tr><tr><td>Recurrent</td><td>24.96± 2.96</td><td>31.02 ± 2.56</td><td>35.22 ± 3.34</td></tr><tr><td>Feed-forward</td><td>22.17 ± 0.85</td><td>24.78 ± 1.65</td><td>22.79 ± 1.32</td></tr></table>",
+        "bbox": [
+            299,
+            330,
+            699,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/75d8a02adf1abd4ebc2e7a971fff383ea86cc068b4c7fe5762cfe8e2d8696123.jpg",
+        "image_caption": [
+            "Figure 4: Generalizing from easy to hard prefix sums. The ability of networks to compute prefix sums on two test sets with longer input strings than were used for training (accuracy on 40-bit inputs in purple and on 44-bit inputs in red). We compare recurrent models to the best feed-forward models of comparable effective depth. The markers are at average values from several trials and the shaded regions indicate $\\pm$ one standard error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            417,
+            736,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "When the thought budget, or number of iterations, is increased, we see that recurrent models can get upwards of $90 \\%$ of the harder testing examples correct. In Figure 4, we observe this large boost in the recurrent models’ performance and a vast difference in the accuracy of recurrent models (with added iterations at test time) and feed-forward networks. Note that the dotted lines represent the average accuracy of the deepest feed-forward networks considered. That depth is 68 layers, or the effective depth of recurrent models with 16 iterations, and we use this baseline in the plot specifically because in the range of depths corresponding to the numbers of iterations shown, these feed-forward models achieve the highest accuracy. In other words, recurrent models trained with relatively few iterations generalize well to harder data while similar and even much larger feed-forward networks fail to generalize in the same scenario. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The generalization we see in Figure 4 indicates that these recurrent models learn processes that can be extended to harder problems by running for more iterations. In particular, the recurrence is both the machinery that allows for varying the depth at test time, as well as a force at training to push the model to find parameters that make progress toward a solution with each reuse. ",
+        "bbox": [
+            173,
+            882,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When these results are viewed through the lens of algorithm design, one might wonder how the receptive field, or the number of entries in the input that determine a single entry in the output, affects these models. The feed-forward models, whose accuracies are shown in Figure 4, have the same receptive field as the recurrent models when tested with 16 iterations. This makes it clear that the increase in accuracy of recurrent models does not simply occur because the receptive field grows with added iterations, rather it occurs because they have learned a process that can extrapolate beyond the training distribution. Further discussion on receptive field is presented in Appendix B. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            223
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 Iterative outputs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            237,
+            341,
+            252
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "One way to dissect the learned process and compare it to known algorithms is to plot the confidence of the model at each iteration. In Figure $\\boxed { 5 }$ we show a representative example of a network’s confidence that each bit in the output is a one. Two striking observations can be made from this figure. The first is that the model is progressing to the solution with each iteration. The second observation is that it is resolving the prefix sum in the earlier bits first and moving down the string, settling on the final bits only in the last iteration. This is remarkably similar to a naive algorithm one might implement for this task that marches from the first index until the end of the string computing prefix sums in order. ",
+        "bbox": [
+            173,
+            261,
+            826,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cc860366995e3816ca17493ef6b4efdd036066e61f58f70f16f7e4200cdcc8b7.jpg",
+        "image_caption": [
+            "Figure 5: A recurrent model’s output from each of 11 iterations on a 40-bit input string. Shown here is the confidence that there is a 1 at each index of the output. The first index is at the top for all vectors, the input is in the left-most column and the target is in the right-most column. The model used to produce this plot was trained with fewer iterations (10) on shorter input strings (32-bit). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            274,
+            375,
+            723,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Mazes ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            719,
+            258,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For maze solving, we train models on a training set composed of the easier small mazes, and we investigate the ability of networks to make the leap to larger, or harder, mazes at test time. In line with the findings above, we show two important behaviors. First, the recurrent models make the leap from small to large mazes better than feed-forward models. Second, when allowed to think deeper, the recurrent models exhibit even higher performance. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            815
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The networks employed here are fully convolutional and have 512 channels in the internal layers. In assessing the confidence of a given output, we average each pixel’s classification confidence. ",
+        "bbox": [
+            176,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows that for a fixed effective depth, recurrent models always generalize to the hard mazes better than their feed-forward counterparts. Inspired by the upward trend in Table 2, we shift focus to deeper models. In Figure $_ { . . } ^ { 6 , }$ we show that recurrent models can extrapolate to harder problems better than feed forward models. When trained on small mazes with 20 iterations (effective depth of 84 layers), these networks can solve about half of large mazes. However, when allowed to think for longer, the recurrent models can correctly solve an even higher proportion of large mazes. In fact, models trained with 20 iterations can achieve upward of $70 \\%$ accuracy on large mazes using 5 additional iterations at test time. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/77f4cf2c0f52617ab733304fab73549686aeef6a0db83fbd7875cc95d9a5ce9f.jpg",
+        "table_caption": [
+            "Table 2: The average accuracy $( \\% )$ of models trained on small mazes and tested on large ones. Over a range of effective depths, we see that recurrent models generalize to the harder mazes better than their feed-forward counterparts. Figures reflect averages over several trials $\\pm$ one standard error. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"5\">Effective Depth</td></tr><tr><td></td><td>20</td><td>24</td><td>28</td><td>36</td><td>44</td></tr><tr><td>Recurrent</td><td>12.66 ± 0.44</td><td>14.02 ± 0.39</td><td>19.95 ± 0.31</td><td>22.96 ± 1.03</td><td>29.72 ± 1.22</td></tr><tr><td>Feed-forward</td><td>7.94 ± 0.36</td><td>12.43 ± 0.50</td><td>14.67 ± 0.54</td><td>17.71 ± 0.36</td><td>22.53 ± 1.14</td></tr></table>",
+        "bbox": [
+            199,
+            137,
+            797,
+            199
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            227,
+            826,
+            282
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e38418ead266361297b87df3bbe4d5a138e8de0facc71a6608896165cdd862cd.jpg",
+        "image_caption": [
+            "Figure 6: Generalizing from easy to hard mazes. We compare recurrent models to the best feedforward models. The markers are at average values from several trials and the shaded regions indicate $\\pm$ one standard error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            297,
+            754,
+            518
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Maze solving is another task for which global information is needed. We investigate how dilated filters affect model performance. Dilation is a way of changing the receptive field without adding new parameters or more depth. Table $\\textcircled { 3 }$ shows that dilations lead to slight improvements, however, the benefits of recurrence are still abundantly clear. Indeed, the difference in performance is even larger. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            650
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/704a3e27cbae86d83e07c02e127a071127557ee587d0e88ce24967d00c1a63d3.jpg",
+        "table_caption": [
+            "Table 3: The average accuracy $( \\% )$ of models with dilated filters trained on small mazes and tested on large ones. Figures reflect averages over several trials $\\pm$ one standard deviation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"5\">Effective Depth</td></tr><tr><td></td><td>20</td><td>24</td><td>28</td><td>32</td><td>36</td></tr><tr><td>Recurrent</td><td>33.60±1.06</td><td>40.49 ± 1.63</td><td>33.91 ± 1.99</td><td>40.56± 4.34</td><td>50.50± 7.97</td></tr><tr><td>Feed-forward</td><td>19.73 ± 0.72</td><td>21.59 ± 0.22</td><td>24.18 ± 1.33</td><td>25.82 ± 0.10</td><td>26.54 ± 2.13</td></tr></table>",
+        "bbox": [
+            199,
+            700,
+            797,
+            761
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 Iterative outputs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            341,
+            804
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The recurrent maze solving networks also produce output at every iteration. Examining this output again leads to a remarkable conclusion: these recurrent models are narrowing in on the answer with each successive iteration. In Figure $\\bigstar$ it is clear from the output on iteration four that the network has found two routes emanating from the red square. Moving through the iterations, the model refines the output, increasing the confidence for pixels on the path and decreasing the others until finally at Iteration $\\# 7$ , the output matches the target. It is also interesting to observe here that the output is consistently correct for two iterations, after which a few pixels flip (Iteration #9). ",
+        "bbox": [
+            173,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c45db6e9d1e5bb3e1aa89809a44a26336f5a0254f1d218ee8c475568d7efeae9.jpg",
+        "image_caption": [
+            "Figure 7: Input, target, and outputs from different iterations are shown to highlight the model’s ability to think sequentially about mazes. We plot the model’s confidence that each pixel belongs to the optimal path. This is a representative example from a model trained to solve small mazes in six iterations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            90,
+            794,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Chess puzzles ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            324,
+            308,
+            339
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The third dataset comprises chess puzzles, or mid-game chess boards for which we seek the best next move. Unlike the other two datasets, the state of the art for chess playing algorithms is complex and has components that use algorithms like Monte Carlo tree search as well as neural network based elements for evaluating positions $\\mathbf { \\underline { { \\{ R o m s t a d e t ~ a l . \\} } } \\mathbf { \\underline { { \\{ S i l v e r ~ e t ~ a l . \\} } } } \\mathbf { \\underline { { \\{ 2 0 1 7 \\} } } } }$ . The complicated nature of these systems provides some context for how difficult these puzzles are. What makes these puzzles particularly useful for us is that there is a predetermined best next move. A move is defined as an origin square, or the current location of the piece to be moved, and a destination square $\\bigstar \\bigstar \\mathrm { I n }$ order to generate target outputs for our models, we define a move as an $8 \\times 8$ array with zeros everywhere except at the entries corresponding to the origin and destination squares which are ones. ",
+        "bbox": [
+            173,
+            352,
+            825,
+            477
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare recurrent and feed-forward networks of effective depths from 84 layers to 100 layers that take $8 \\times 8 \\times 1 2$ arrays as input. These fully convolutional networks have 512 channels in the internal layers, and the output is $8 \\times 8 \\times 2$ , corresponding to binary classification at each input pixel. During training, we use an average of cross-entropy losses at every pixel. When evaluating these models, however, we define the predicted move by the locations of the two highest confidence scores. ",
+        "bbox": [
+            174,
+            483,
+            826,
+            553
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6f9d9a1acf162443b4d148f5bae2d9a42780222acadcdfd89f24871d2bf11b31.jpg",
+        "image_caption": [
+            "Figure 8: Generalizing from easy to hard chess puzzles. The ability of networks to solve harder puzzles than were used for training. We compare recurrent models to the best feed-forward models of comparable effective depth. The markers are at average values from several trials and the shaded region indicate $\\pm$ one standard error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            248,
+            585,
+            753,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Once again, we see that recurrent models can solve more chess puzzles than their feed forward counterparts. Furthermore, by thinking deeper at test time, recurrent models can perform even better. While the gains shown in Figure 8 are modest in comparison to the other two problem settings, the trend is clear – recurrent models can solve more puzzles with more iterations. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3.1 Iterative outputs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            165,
+            341,
+            180
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/017703ea05676fb6338275cc07cc4ce4a8e731b4907e2dc7c7820afd6e096b4a.jpg",
+        "image_caption": [
+            "Figure 9: Input, target, and outputs form different iterations are shown to highlight the model’s ability to think about the next move. We plot the model’s confidence that each pixel is one of the two that define a move. In this example, black is to move next. For space consideration, iterations 2-14, which look like the first iteration, are left out of this plot. More examples are available in Appendix C. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            207,
+            790,
+            369
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While the outputs from the other two datasets show the similarity between the learned iterative process and known sum and search algorithms, extracting that insight on chess puzzles is much more difficult. Partly, this is because exploiting known search algorithms on such a large search space is hard to visualize. Nonetheless, the network’s output, shown in Figure 9, tells a fascinating story. First, the Iteration #1 plot shows that after one iteration, we observe equal confidence at every location on the board. In the next frame, Iteration $\\# 1 5$ , it is clear that the model is considering moving the D8 rook to multiple squares, and it also considers the intuitive idea of using the E5 queen to place the white king in check on H2. With each successive iteration, the network becomes more confident – first that the rook is the correct piece to move, and then where to move it to. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            601,
+            292,
+            618
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "More than an answer, the results and conclusions in this paper are posing a question: Can learned models behave like classical algorithms in the way they generalize to harder or larger problems? ",
+        "bbox": [
+            176,
+            635,
+            825,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our discussion of this question and our observations begins with delineating the limitations of our work. The first major limitation is that we do not propose a definitive answer. Rather, using representative cases, we demonstrate that recurrence can help neural models make the leap from easy training data to hard testing examples. A more subtle limitation of our work lies in how we split the data by difficulty. For prefix sum computation and for mazes, the classical algorithms approach to measuring problem complexity is tied to problem size, so in those settings we make intuitive easy/hard splits. With chess however, the issue is much more complex. Should puzzles with higher ratings require more memory or more computation? We carry out our work assuming the answer is yes, but we remain open minded to the possibility that the ratings assigned by Lichess may be weak surrogates for algorithmic complexity of each puzzle. In short, chess is an extremely difficult domain to analyze. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The observations above indicate that iterative models can learn processes that generalize beyond the training distribution with more iterations. One exciting use case is when the testing distribution is inaccessible, a setting where training on the harder distribution itself would be impossible. Many real life scenarios demand exactly this type of problem solving, from robots deployed in the real world after training in simulation to humans who spend a lot of time practicing on easy math problems only to spend years on difficult unsolved questions. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On a conceptual level, the recurrent model behavior we show is analogous to the human behavior of manipulating representations in working memory; in this analogy, the recurrent block performs the transformations and the activations it generates are the memory. It is not the goal of the experiments here to suggest that iterative models use mechanisms similar to those in a human brain. Nonetheless, it is exciting to see, even in a proof of concept setting, neural models that appear to deliberate on a problem until it is solved and can extend their abilities by thinking for longer. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This raises a questions that motivates future work. Can we build neural networks that can think for even longer? Is it feasible to have models whose performance only increases with added compute time? Humans who are given more than enough time to solve a maze, will not suddenly get it wrong after arriving at the right answer, perhaps this awareness of when to stop thinking can be built into networks like the ones we study here. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            268,
+            299,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we demonstrate that neural networks are capable of solving sequential reasoning tasks and then extrapolating this knowledge to solve problems of greater complexity than they were trained on. These recurrent models are largely inspired by the classical theory of mind, in which the brain iteratively applies primitive strategies to solve complex problems over time [Baddeley, 2012] Our models are recurrent versions of popular architectures and we acknowledge that variations to the model may be helpful. Thus, we leave an in depth investigation into other neural network designs for future work. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            396
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, the resulting models excel at solving problems that are classically solved by handcrafted algorithms; prefix sums are computed using reduction trees, mazes are classically solved by depth/breadth first search, and chess is solved by Monte-Carlo tree search. Even with the advances in machine learning that we have today, hand-crafted algorithms still play a role in state-of-the-art reasoning systems. A prominent example is AlphaZero, which plays board games using Monte-Carlo tree search algorithms assisted by a learned pruning function [Silver et al., 2017]. While moving away from this paradigm that includes hand-crafted elements is highly ambitious, this work suggests that it may be possible to train gameplay systems without building them on top of a hand-crafted tree search engine. In other words, it may be possible to machine-learn these algorithmic behaviors end-to-end. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            560,
+            338,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This project was supported by the ONR MURI program, AFOSR MURI program, the DARPA Young Faculty Award, and the National Science Foundation Division of Mathematical Sciences. Additional support was provided by Capital One Bank and JP Morgan Chase. Additionally, we thank Avrim Blum for thought-provoking and insightful conversations. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            646
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            266,
+            681
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Md Zahangir Alom, Mahmudul Hasan, Chris Yakopcic, Tarek M Taha, and Vijayan K Asari. Recurrent residual convolutional neural network based on u-net (r2u-net) for medical image segmentation. arXiv preprint arXiv:1802.06955, 2018.   \nMartin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019.   \nAlan Baddeley. Working memory: theories, models, and controversies. Annual review of psychology, 63:1–29, 2012.   \nAlan D Baddeley and Graham Hitch. Working memory. In Psychology of learning and motivation, volume 8, pages 47–89. Elsevier, 1974.   \nShaojie Bai, J Zico Kolter, and Vladlen Koltun. Trellis networks for sequence modeling. In International Conference on Learning Representations, 2018.   \nShaojie Bai, J Zico Kolter, and Vladlen Koltun. Deep equilibrium models. Advances in Neural Information Processing Systems, 32:690–701, 2019. ",
+        "bbox": [
+            171,
+            689,
+            828,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tamal Biswas and Kenneth Regan. Measuring level-k reasoning, satisficing, and human error in gameplay data. In 2015 IEEE 14th International Conference on Machine Learning and Applications (ICMLA), pages 941–947. IEEE, 2015. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arpad E Elo. The rating of chessplayers, past and present. Arco Pub., 1978. ",
+        "bbox": [
+            173,
+            143,
+            676,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cristobal Eyzaguirre and Alvaro Soto. Differentiable adaptive computation time for visual reasoning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 12817–12825, 2020. ",
+        "bbox": [
+            173,
+            169,
+            825,
+            213
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Adaptive computation time for recurrent neural networks. arXiv preprint arXiv:1603.08983, 2016. ",
+        "bbox": [
+            171,
+            223,
+            825,
+            252
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014. ",
+        "bbox": [
+            173,
+            262,
+            825,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Hill. Making a maze, Apr 2017. URL https://scipython.com/blog/ making-a-maze/. ",
+        "bbox": [
+            174,
+            339,
+            823,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In European conference on computer vision, pages 646–661. Springer, 2016. ",
+        "bbox": [
+            174,
+            380,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Jaegle, Felix Gimeno, Andrew Brock, Andrew Zisserman, Oriol Vinyals, and Joao Carreira. Perceiver: General perception with iterative attention. arXiv preprint arXiv:2103.03206, 2021. ",
+        "bbox": [
+            174,
+            419,
+            823,
+            449
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Łukasz Kaiser and Ilya Sutskever. Neural gpus learn algorithms. arXiv preprint arXiv:1511.08228, 2015. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kohitij Kar, Jonas Kubilius, Kailyn Schmidt, Elias B Issa, and James J DiCarlo. Evidence that recurrent circuits are critical to the ventral stream’s execution of core object recognition behavior. Nature neuroscience, 22(6):974–983, 2019. ",
+        "bbox": [
+            173,
+            497,
+            828,
+            541
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yigitcan Kaya, Sanghyun Hong, and Tudor Dumitras. Shallow-deep networks: Understanding and mitigating network overthinking. In International Conference on Machine Learning, pages 3301–3310. PMLR, 2019. ",
+        "bbox": [
+            176,
+            551,
+            823,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. Albert: A lite bert for self-supervised learning of language representations. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            178,
+            604,
+            825,
+            648
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ming Liang and Xiaolin Hu. Recurrent convolutional neural network for object recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 3367–3375, 2015. ",
+        "bbox": [
+            173,
+            657,
+            826,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qianli Liao and Tomaso Poggio. Bridging the gaps between residual learning, recurrent neural networks and visual cortex. arXiv preprint arXiv:1604.03640, 2016. ",
+        "bbox": [
+            173,
+            712,
+            821,
+            741
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lichess. Lichess open puzzles database. https://database.lichess.org/#puzzles, 2021. Accessed: 2021-04-01. ",
+        "bbox": [
+            173,
+            750,
+            821,
+            780
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Reid McIlroy-Young, Siddhartha Sen, Jon Kleinberg, and Ashton Anderson. Aligning superhuman ai with human behavior: Chess as a model system. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1677–1687, 2020. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            834
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pedro Pinheiro and Ronan Collobert. Recurrent convolutional neural networks for scene labeling. In International conference on machine learning, pages 82–90. PMLR, 2014. ",
+        "bbox": [
+            169,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tord Romstad, Marco Costalba, and et al. Kiiski, Joona. Stockfish: A strong open source chess engine. URL https://stockfishchess.org/. ",
+        "bbox": [
+            171,
+            882,
+            825,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Avi Schwarzschild, Eitan Borgnia, Arjun Gupta, Arpit Bansal, Zeyad Emam, Furong Huang, Micah Goldblum, and Tom Goldstein. Datasets for studying generalization from easy to hard examples. arXiv preprint arXiv:2108.06011, 2021. ",
+        "bbox": [
+            176,
+            90,
+            826,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Selsam, Matthew Lamm, Benedikt Bünz, Percy Liang, Leonardo de Moura, and David L Dill. Learning a sat solver from single-bit supervision. arXiv preprint arXiv:1802.03685, 2018. ",
+        "bbox": [
+            171,
+            142,
+            825,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Manli Shu, Zuxuan Wu, Micah Goldblum, and Tom Goldstein. Preparing for the worst: Making networks less brittle with adversarial batch normalization. arXiv preprint arXiv:2009.08965, 2020. ",
+        "bbox": [
+            171,
+            179,
+            825,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. Mastering chess and shogi by self-play with a general reinforcement learning algorithm. arXiv preprint arXiv:1712.01815, 2017. ",
+        "bbox": [
+            174,
+            217,
+            826,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. arXiv preprint arXiv:1602.02867, 2016. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            311
+        ],
+        "page_idx": 11
+    }
+]

parse/train/gjBz22V93a/gjBz22V93a.md

@@ -0,0 +1,288 @@
+# Fast Multi-Resolution Transformer Fine-tuning for Extreme Multi-label Text Classification
+
+Jiong Zhang   
+Amazon   
+jiongz@amazon.com
+
+Wei-cheng Chang Amazon chanweic@amazon.com
+
+Hsiang-fu Yu   
+Amazon   
+rofu.yu@gmail.com
+
+Inderjit S. Dhillon UT Austin & Amazon inderjit@cs.utexas.edu
+
+# Abstract
+
+Extreme multi-label text classification (XMC) seeks to find relevant labels from an extreme large label collection for a given text input. Many real-world applications can be formulated as XMC problems, such as recommendation systems, document tagging and semantic search. Recently, transformer based XMC methods, such as XTransformer and LightXML, have shown significant improvement over other XMC methods. Despite leveraging pre-trained transformer models for text representation, the fine-tuning procedure of transformer models on large label space still has lengthy computational time even with powerful GPUs. In this paper, we propose a novel recursive approach, XR-Transformer to accelerate the procedure through recursively fine-tuning transformer models on a series of multi-resolution objectives related to the original XMC objective function. Empirical results show that XRTransformer takes significantly less training time compared to other transformerbased XMC models while yielding better state-of-the-art results. In particular, on the public Amazon-3M dataset with 3 million labels, XR-Transformer is not only 20x faster than X-Transformer but also improves the Precision $@ 1$ from $5 1 \%$ to $5 4 \%$ . Our code is publicly available at https://github.com/amzn/pecos.
+
+# 1 Introduction
+
+Many real-world applications such as open-domain question answering [1, 2], e-commerce dynamic search advertising [3, 4], and semantic matching [5], can be formulated as an extreme multi-label text classification (XMC) problem: given a text input, predict relevant labels from an enormous label collection of size $L$ . In these applications, $L$ ranges from tens of thousands to millions, which makes it very challenging to design XMC models that are both accurate and efficient to train. Recent works such as Parabel [3], Bonsai [6], XR-Linear [7] and AttentionXML [8], exploit the correlations among the labels to generate label partitions or hierarchical label trees (HLTs) which can be used to shortlist candidate labels to be considered during training and inference. While these methods are scalable in terms of the size of the label collection, most of them rely only on statistical representations (such as bag-of-words) or pooling from pre-generated token embeddings (such as word2vec) to vectorize text inputs.
+
+In light of the recent success of deep pretrained transformers models such as BERT [9], XLNet [10] and RoBerta [11] in various NLP applications, X-Transformer [12] and LightXML [13] propose to fine-tune pre-trained transformer models on XMC tasks to obtain new state-of-the-art results over the aforementioned approaches. Although transformers are able to better capture semantic meaning of textual inputs than statistical representations, text truncation is often needed in practice to reduce GPU memory footprint and maintain model efficiency. For example, X-Transformer truncates input texts to contain the first 128 tokens before feeding it into transformer models. Efficiency of transformer fine-tuning poses another challenge for XMC applications. Directly fine-tuning transformer models on the original XMC task with a very large label collection is infeasible as both the training time and the memory consumption are linear in $L$ . In order to alleviate this, both $\mathbf { X }$ -Transformer and LightXML adopt a similar approach to group $L$ labels into $K$ clusters of roughly equal size denoted by $B$ and fine-tune transformers on the task to identify relevant label clusters (instead of labels themselves). If $B \approx { \sqrt { L } }$ and $K \approx { \sqrt { L } }$ , then both the training time and the memory requirement of the fine-tuning can be reduced to $O ( \sqrt { L } )$ from $O ( L )$ . However, as pointed out in [8], the model performance would deteriorate due to the information loss from label aggregation. Thus, both XTransformer and LightXML still choose a small constant $B$ $( \leq 1 0 0 )$ as the size of the label clusters. As a result, transformers are still fine-tuned on a task with around $L / 1 0 0$ clusters, which leads to a much longer training time compared with non-transformer based models. For example, it takes X-Transformer 23 and 25 days respectively to train on Amazon-3M and Wiki- $5 0 0 \mathsf { K }$ even with 8 Nvidia V100 GPUs.
+
+To address these issues, we propose XR-Transformer, an XMC architecture that leverages pre-trained transformer models and has much smaller training cost compared to other transformer-based XMC methods. Motivated by the multi-resolution learning in image generation [14–16] and curriculum learning [17], we formulate the XMC problem as a series of sub-problems with multi-resolution label signals and recursively fine-tune the pre-trained transformer on the coarse-to-fine objectives. In this paper, our contributions are as follows:
+
+• We propose XR-Transformer, a transformer based framework for extreme multi-label text classification where the pre-trained transformer is recursively fine-tuned on a series of easyto-hard training objectives defined by a hierarchical label tree. This allows the transformers to be quickly fine-tuned for a XMC problem with a very large number label collection progressively. To get better text representation and mitigate the information loss in text truncation for transformers, we take into account statistical text features in addition to the transformer text embeddings in our model. Also, a cost sensitive learning scheme by label aggregation is proposed to introduce richer information on the coarsified labels.   
+We conduct experiments on 6 public XMC benchmarking datasets and our model takes significantly lower training time compared to other transformer-based XMC models to yield better state-of-the-art results. For example, we improve the state-of-the-art Prec $@ 1$ result on Amazon-3M established by X-Transformer from $5 1 . 2 0 \%$ to $5 4 . 0 4 \%$ while reducing the required training time from 23 days to 29 hours using the same hardware.
+
+# 2 Related Works
+
+Sparse Linear Models with Partitioning Techniques. Conventional XMC methods consider fixed input representations such as sparse TF-IDF features and study different partitioning techniques or surrogate loss functions on the large output spaces to reduce complexity. For example, sparse linear one-versus-all (OVA) methods such as DiSMEC [18], PPD-Sparse [19, 20], ProXML [21] explore parallelism to solve OVA losses and reduce the model size by weight truncations.
+
+The inference time complexity of OVA models is linear in the output space, which can be greatly improved by partitioning methods or approximate nearest neighbor (ANN) indexing on the label spaces. Initial works on tree-based methods [22, 23] reduce the OVA problem to one-versus-some (OVS) with logarithmic depth trees. Down that path, recent works on sparse linear models including Parabel [3], eXtremeText [24], Bonsai [6], XReg [25], NAPKINXC [26, 27] and XR-Linear [7] partition labels with $B$ -array hierarchical label trees (HLT), leading to inference time complexity that is logarithmic in the output space. On the other hand, low-dimensional embedding-based models often leverage ANN methods to speed up the inference procedure. For example, AnnexML [28] and SLICE [29] consider graph-based methods such as HNSW [30] while GLaS [31] considers product quantization variants such as ScaNN [32].
+
+Shallow Embedding-based Methods. Neural-based XMC models employ various network architectures to learn semantic embeddings of the input text. XML-CNN [33] applies one-dimensional CNN on the input sequence and use the BCE loss without sampling, which is not scalable to XMC problems. AttentionXML [8] employs BiLSTMs and label-aware attention as scoring functions. For better scalability to large output spaces, only a small number of positive and hard negative labels are used in model GPU training. Shallow embedding-based methods [34–38] use word embedding lookup followed by shallow MLP layers to obtain input embeddings. For instance, MACH [34] learns MLP layers on several smaller XMC sub-problems induced by hashing tricks on the large label space. Similarly, DeepXML [35] and its variant (i.e., DECAF [36], GalaXC [37], ECLARE [38]) pre-train MLP encoders on XMC sub-problems induced by label clusters. They freeze the pre-trained word embedding and learn another MLP layer followed by a linear ranker with sampled hard negative labels from HNSW [30]. Importantly, shallow embedding-based methods only show competitive performance on short-text XMC problems where the number of input tokens is small [34, 35].
+
+Deep Transformer Models. Recently, pre-trained Transformer models [9–11] have been applied to XMC problems with promising results [12, 13, 39]. X-Transformer [12] considers a two-stage approach where the first stage transformer-based encoders are learned on XMC sub-problems induced by balanced label clusters, and the second stage sparse TF-IDF is combined with the learned neural embeddings as the input to linear OVA models. APLC-XLNet [39] fine-tunes XLNet encoder on adaptive imbalanced label clusters based on label frequency similar to Adaptive Softmax [40]. LightXML [13] fine-tunes Transformer encoders with the OVA loss function end-to-end via dynamic negative sampling from the matching network trained on label cluster signals. Nonetheless, Transformer-based XMC models have larger model size and require longer training time, which hinders its practical usage on different downstream XMC problems.
+
+# 3 Background Material
+
+We assume we are given a training set $\{ \mathbf { x } _ { i } , \mathbf { y } _ { i } \} _ { i = 1 } ^ { N }$ where $\mathbf { x } _ { i } \in \mathcal { D }$ is the ith input document and $\mathbf { y } _ { i } \in \{ 0 , 1 \} ^ { L }$ is the one hot label vector with $y _ { i , \ell } = 1$ indicating that label $\ell$ is relevant to instance $i$ The goal of eXtreme Multi-label Text Classification (XMC) is to learn a function $f : \mathcal { D } \times \left[ L \right] \mapsto \mathbb { R }$ , such that $f ( \mathbf { x } , \boldsymbol { \ell } )$ denotes the relevance between the input $\mathbf { x }$ and the label $\ell$ . In practice, labels with the largest $k$ values are retrieved as the predicted relevant labels for a given input $\mathbf { x }$ . The most straightforward model is one-versus-all (OVA) model:
+
+$$
+f ( \mathbf { x } , \boldsymbol { \ell } ) = \mathbf { w } _ { \boldsymbol { \ell } } ^ { \top } \boldsymbol { \Phi } ( \mathbf { x } ) ; \boldsymbol { \ell } \in [ L ] ,
+$$
+
+where $\mathbf { W } = [ \mathbf { w } _ { 1 } , \hdots , \mathbf { w } _ { L } ] \in \mathbb { R } ^ { d \times L }$ are the weight vectors and $\Phi : \mathcal { D } \mapsto \mathbb { R } ^ { d }$ is the text vectorizer that maps $\mathbf { x }$ to $d$ -dimensional feature vector. $\Phi ( \cdot )$ could be a deterministic text vectorizer, such as the bag-of-words (BOW) model or Term Frequency-Inverse Document Frequency (TFIDF) model, or a vectorizer with learnable parameters. With the recent development in deep learning, using pre-trained transformer as the text vectorizer has shown promising results in many XMC applications [12, 13, 39]. When $L$ is large, however, training and inference of OVA model without sampling would be prohibitive due to the $O ( L )$ time complexity.
+
+To handle the extremely large output space, recent approaches partition the label space to shortlist the labels considered during training and inference. In particular, [7, 12, 13, 34, 35, 39] follow a three stage framework: partitioning, shortlisting, and ranking. First, label features are constructed to group labels into $K$ clusters $\mathbf { C } \in \overline { { \{ 0 , 1 \} } } ^ { L \times K }$ where $C _ { \ell , k } = 1$ denotes that label $\ell$ is included in the $k$ -th cluster. Then a shortlisting model is learned to match input $\mathbf { x }$ to relevant clusters in an OVA setting:
+
+$$
+g ( \mathbf { x } , k ) = \hat { \mathbf { w } } _ { k } ^ { \top } \Phi _ { g } ( \mathbf { x } ) ; k \in [ K ] .
+$$
+
+Finally, a classification model with output size $L$ is trained on the shortlisted labels:
+
+$$
+f ( \mathbf { x } , \boldsymbol { \ell } ) = \mathbf { w } _ { \boldsymbol { \ell } } ^ { \top } \boldsymbol { \Phi } ( \mathbf { x } ) ; \boldsymbol { \ell } \in S _ { g } ( \mathbf { x } ) ,
+$$
+
+where $S _ { g } ( \mathbf { x } ) \subset [ L ]$ is the label set shortlisted by $g ( \mathbf { x } , \cdot )$ . In the extreme case where only one label cluster is determined to be relevant to a input $\mathbf { x }$ , the training and inference cost on √ √ $\mathbf { x }$ would be $\begin{array} { r } { O ( K + \frac { L } { K } ) } \end{array}$ , which in the best case scenario is $O ( \sqrt { L } )$ when $\bar { K } = \sqrt { L }$ .
+
+For transformer based methods, the dominant time is the evaluation of $\Phi ( \mathbf { x } )$ . But $K$ being too big or too small could still be problematic. Empirical results show that the model performance deteriorates when clusters are too big [8]. This is because that the signals coming from $B$ labels within the same cluster will be aggregated and not distinguishable, where $B$ is the cluster size. Therefore, $B$ cannot be too big to ensure a reasonable label resolution for fine-tuning. Also, as pointed out in [12], fine-tuning transformer models on large output spaces can be prohibitive. As a result, the label clusters need to be constructed in a way to balance the model performance and fine-tuning efficiency. In practice, both the transformer-based XMC models, such as X-Transformer and LightXML, adopt a small fixed constant as the cluster size $B$ $3 ( \leq 1 0 0 )$ , which means that training the shortlisting model $g ( \mathbf { x } , k )$ is still very time consuming as the number of clusters $K \approx L / B$ .
+
+![](images/46f66c6210a2f96597b951ec90d598f4c129d57734107b7a3ab7444b5fdc94a5.jpg)  
+Figure 1: Illustration of fine-tuning on XMC tasks of different label resolutions. For an XMC task with a low label resolution, fine-tuning can be fast but model performance might deteriorate due to large deviation from the original XMC task. In practice, X-Transformer and LightXML adopt a XMC task with a relatively higher label resolution to ensure reasonable model performance at the cost of longer training time. The proposed XR-Transformer leverages multi-resolution learning and model bootstrapping that achieves both fast fine-tuning and good model performance.
+
+# 4 Proposed Method: XR-Transformer
+
+As noted above, the shortlisting problem (2) is itself an XMC problem with slightly smaller output size $\frac { L } { B }$ where $B$ is the cluster size. In XR-Transformer, we apply the same three stage framework recursively on the shortlisting problem until a reasonably small output size is reached $\frac { L } { B _ { - } ^ { D } }$ We can therefore follow the curriculum learning scheme and fine-tune the pre-trained transformers progressively on the sub-XMC problems with increasing output space $\Big \{ \frac { \dot { \bf \Phi } _ { L } } { B ^ { D } } , \frac { L } { B ^ { D - 1 } } , \ldots \Big \}$ . At each fine-tuning task, the candidate label set is shortlisted by the final model at the previous task. The recursive shortlisting ensures that for any input, the number of candidate labels to include in training and inference is $O ( B )$ and therefore the total number of considered labels is $O ( B \log _ { B } ( L ) )$ . Also, we leverage the multi-step fine-tuning and use the embedding generated at the previous task to bootstrap the non pre-trained part for the current task. We now describe the model design in detail.
+
+Hierarchical Label Tree (HLT). Recursively generating label clusters $D$ times is equivalent to building a HLT [41] of depth $D$ . We first construct label features $\mathbf { Z } \in \mathbb { R } ^ { L \times \hat { d } }$ . This could be done by applying text vectorizers on label text or from Positive Instance Feature Aggregation (PIFA):
+
+$$
+\mathbf { Z } _ { \ell } = { \frac { \mathbf { v } _ { \ell } } { \| \mathbf { v } _ { \ell } \| } } ; { \mathrm { w h e r e ~ } } \mathbf { v } _ { \ell } = \sum _ { i : y _ { i , \ell } = 1 } \Phi ( \mathbf { x } _ { i } ) , \forall \ell \in [ L ] ,
+$$
+
+where $\Phi : \mathcal { D } \mapsto \mathbb { R } ^ { d }$ it the text vectorizer. Then we follow similar procedures as [8] and [13] and use balanced $\mathbf { k }$ -means ( $k = B ,$ ) to recursively partition label sets and generate the HLT in a top-down fashion. The HLT is represented with a series of indexing matrices $\{ \mathbf { C } ^ { ( t ) } \} _ { t = 1 } ^ { D }$ )}Dt=1, such that $\mathbf { C } ^ { ( t ) } \in \{ 0 , 1 \} ^ { K _ { t } \times K _ { t - 1 } }$ where $K _ { 0 } = 1$ and $K _ { D } = L$ . Equivalently, once $\mathbf { C } ^ { ( D ) }$ is constructed, the HLT can be built from bottom up through joining $B$ adjacent clusters together.
+
+Multi-resolution Output Space. Multi-resolution learning has been explored in different contexts such as computer vision [14, 42]. For instance, using an output scheme with coarse-to-fine resolutions results in better image quality for generative adversarial networks [15, 16]. As an another example in meta learning, [43] learns multiclass models via auxiliary meta classes by collapsing existing classes. Nevertheless, multi-resolution learning has not been well-explored in the XMC literature. In XR-Transformer, we leverage the label hierarchy defined by the HLT and train the transformer model on multi-resolution objectives.
+
+The XMC task can be viewed as generating an 1-D image $\mathbf { y } \in \{ 0 , 1 \} ^ { L }$ with binary values based on input text x. Just like a coarsified image could be obtained by a max or mean pooling of nearby pixels, the coarse label vector can be obtained by max-pooling of labels which are nearby in the label feature space. Once the HLT is constructed using label features, the true labels at layer $\mathbf { \bar { Y } } ^ { ( t ) } \in \{ 0 , 1 \} ^ { N \times K _ { t } }$ can be determined by the true labels of the child clusters at $t + 1$ through a max-pooling like operation:
+
+$$
+\mathbf { Y } ^ { ( t ) } = \mathrm { b i n a r i z e } ( \mathbf { Y } ^ { ( t + 1 ) } \mathbf { C } ^ { ( t + 1 ) } ) ,
+$$
+
+and Y (D)i,\` $Y _ { i , \ell } ^ { ( D ) } = y _ { i , \ell }$ is the original label matrix. This forms a series of learning signals with coarse-to-fine resolution and can be used to generate learning tasks with easy-to-hard objectives.
+
+Direct use of the binarized $\mathbf { Y } ^ { ( t ) } \in \{ 0 , 1 \} ^ { N \times K _ { t } }$ in Eq (5) results in information loss when merging several positive labels into one cluster. Ideally, a cluster containing several positive children is more relevant than a cluster with only one positive child. To add this lower level information to higher level learning objectives, we introduce the relevance matrix ${ \bf R } ^ { ( t ) } \in \mathbb { R } _ { \pm } ^ { N \times K _ { t } }$ for layer $t$ of the XMC sub-problem where $R _ { i , \ell }$ defines the non-negative important weight for ith instance to \`th cluster. Different from cost-sensitive learning [44] for MLC (CSMLC) setting [45–47] where there is only one cost matrix explicitly derived by evaluation metrics such as F1 score, in XR-Transformer, we consider the usage of cost-sensitive learning where the relevance matrices are recursively induced by the HLT structure. Specifically, given an HLT, we recursively construct relevance matrices for $t = 1 , \ldots , D$ :
+
+$$
+\mathbf { R } ^ { ( t ) } = \mathbf { R } ^ { ( t + 1 ) } \mathbf { C } ^ { ( t + 1 ) } ,
+$$
+
+and $\mathbf { R } ^ { ( D ) } = \mathbf { Y } ^ { ( D ) }$ . Motivated by [48], we adopts the row-wise $\ell _ { 1 }$ normalized relevance matrix:
+
+$$
+\begin{array} { r } { \hat { R } _ { i , j } ^ { ( t ) } = \left\{ \begin{array} { l l } { \frac { R _ { i , j } ^ { ( t ) } } { \| \mathbf { R } _ { i } ^ { ( t ) } \| _ { 1 } } } & { \mathrm { ~ i f ~ } Y _ { i , j } ^ { ( t ) } = 1 , } \\ { \alpha } & { \mathrm { o t h e r w i s e } , } \end{array} \right. } \end{array}
+$$
+
+where $\alpha$ is the hyper parameter to balance positive and negative weights.
+
+Label Shortlisting. During training, XR-Transformer only focuses on discriminating the labels or clusters that have high chance of being positive. A necessary condition for a label at layer $t$ to be positive is that its parent label at level $t - 1$ is positive. Therefore, an intuitive approach would be to only train on the output space shortlisted by positive clusters of the parent layer. However, in practice we found this approach sometimes leads to sub-optimal result during inference with beam search. As an effort to balance explore and exploit, we further include the top- $k$ relevant clusters determined by the model learned on the parent layer to mimic the beam search during inference. Thus at layer $t$ , the labels considered during training are shortlisted by the parent layer $t - 1$ :
+
+$$
+\begin{array} { r } { \begin{array} { r l } & { \mathbf { P } ^ { ( t - 1 ) } = \mathrm { T o p } ( \mathbf { W } ^ { ( t - 1 ) \top } \Phi ( \mathbf { X } , \Theta ^ { ( t - 1 ) } ) , k ) , } \\ & { \mathbf { M } ^ { ( t ) } = \mathrm { b i n a r i z e } ( \mathbf { P } ^ { ( t - 1 ) } \mathbf { C } ^ { ( t ) \top } ) + \mathrm { b i n a r i z e } ( \mathbf { Y } ^ { ( t - 1 ) } \mathbf { C } ^ { ( t ) \top } ) , } \end{array} } \end{array}
+$$
+
+where the $\mathrm { T o p } ( \cdot , k )$ operator zeros out elements in a matrix except the top- $k$ largest values in each row. For each instance $\mathbf { x } _ { i }$ , only non-zero indices of $\mathbf { M } _ { i }$ will be included into the training objective. We can therefore define a series of learning objectives for level $t \in \{ 1 , 2 , \dots , D \}$ as:
+
+$$
+\operatorname* { m i n } _ { \mathbf { W } ^ { ( t ) } , \Theta } \sum _ { i = 1 } ^ { N } \sum _ { \ell : \mathbf { M } _ { i , \ell } ^ { ( t ) } \neq 0 } \hat { R } _ { i , \ell } ^ { ( t ) } \mathcal { L } ( Y _ { i , \ell } ^ { ( t ) } , \mathbf { W } _ { \ell } ^ { ( t ) \top } \Phi ( \mathbf { x } _ { i } , \Theta ) ) + \lambda \| \mathbf { W } ^ { ( t ) } \| ^ { 2 } ,
+$$
+
+where $\mathcal { L }$ is a point-wise loss such as hinge loss, squared hinge loss or BCE loss, $\mathbf { W } ^ { ( t ) }$ , $\Theta$ are the model weights to be learned.
+
+Text Representation. Most previous works on XMC construct text feature representation in one of two ways: statistical feature representations and semantic feature representations. Although the latter, in particular transformer models, have shown promising results on various NLP benchmarks, the self-attention mechanism makes transformers unscalable w.r.t. sequence length. To ensure efficiency, input texts are usually truncated [12, 13] which result in loss of information. On the other hand, the statistical features, such as TFIDF, are fast to construct with the whole input taken into consideration. In XR-Transformer, we use a combination of these two feature representations and each component is a complement of lost information for the other one:
+
+$$
+\Phi _ { c a t } ( \mathbf { x } , \Theta ) : = \Big [ \frac { \Phi _ { t f i d f } ( \mathbf { x } ) } { \lVert \Phi _ { t f i d f } ( \mathbf { x } ) \rVert } , \frac { \Phi _ { d n n } ( \mathbf { x } , \Theta ) } { \lVert \Phi _ { d n n } ( \mathbf { x } , \Theta ) \rVert } \Big ] ,
+$$
+
+$$
+\perp \theta ^ { * }  \theta
+$$
+
+$$
+\begin{array} { r l } & { \quad \lfloor \mathbf { \delta v } ^ { \star } \gets \boldsymbol { \sigma } } \\ & { \mathbf { W } ^ { * } \gets \operatorname * { a r g m i n } _ { \mathbf { W } } \sum _ { i = 1 } ^ { N } \sum _ { \ell = 1 } ^ { m } \hat { R } _ { i , \ell } ^ { ( t ) } \mathcal { L } ( Y _ { i , \ell } , \mathbf { W } _ { \ell } ^ { \top } \Phi _ { c a t } ( \mathbf { x } _ { i } , \boldsymbol { \Theta } ) ) + \lambda \| \mathbf { W } \| ^ { 2 } } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \quad \bigcup \mathbf { \phi } \in \mathbf { \phi }  \theta } \\ & { \mathbf { W } ^ { * }  \operatorname { a r g m i n } _ { \mathbf { W } } \sum _ { i = 1 } ^ { N } \sum _ { \ell : \mathbf { M } _ { i , \ell } \neq 0 } \hat { R } _ { i , \ell } ^ { ( t ) } \mathcal { L } ( Y _ { i , \ell } , \mathbf { W } _ { \ell } ^ { \top } \Phi _ { c a t } ( \mathbf { x } _ { i } , \theta ^ { * } ) ) + \lambda \Vert \mathbf { W } \Vert ^ { 2 } } \end{array}
+$$
+
+# Algorithm 2: XR-Transformer training
+
+Input :X, $\mathbf { Y }$ , pre-trained transformer $\Phi _ { d n n } ( \cdot , \pmb { \theta } _ { 0 } )$   
+$\hat { \mathbf { Z } } _ { \ell } = \mathbf { v } _ { \ell } / \| \mathbf { v } _ { \ell } \|$ ; where $\begin{array} { r } { \mathbf { v } _ { \ell } = \sum _ { i : y _ { i , \ell } = 1 } \Phi _ { t f i d f } ( \mathbf { x } _ { i } ) , \forall \ell \in [ L ] } \end{array}$   
+$\{ \hat { \mathbf { C } } ^ { ( t ) } \} _ { t = 1 } ^ { \hat { D } }  \mathbf { k }$ -means-clustering $( \hat { \mathbf { Z } } )$   
+Generate label hierarchy {Yˆ (t)}Dˆt= using 5   
+${ \pmb \theta } ^ { * } = { \pmb \theta } _ { 0 }$ , ${ \bf P } = N o n e$   
+for $t$ in $1 , 2 , 3 , \cdots , \hat { D } $ do $\hat { \mathbf { W } } , \pmb { \theta } ^ { * } \gets$ Iterative_Learn(X, Yˆ (t), Cˆ (t), θ∗, P) $\mathbf { P } \gets \mathrm { T o p } ( \hat { \mathbf { W } } ^ { \top } \Phi _ { c a t } ( \mathbf { X } , \pmb { \theta } ^ { * } ) , k )$   
+$\mathbf { Z } _ { \ell } = \mathbf { v } _ { \ell } / \| \mathbf { v } _ { \ell } \|$ ; where $\begin{array} { r } { \mathbf { v } _ { \ell } = \sum _ { i : y _ { i , \ell } = 1 } \Phi _ { c a t } ( \mathbf { x } _ { i } ) , \forall \ell \in [ L ] } \end{array}$   
+$\{ \mathbf { C } ^ { ( t ) } \} _ { t = 1 } ^ { D }  \mathbf { k }$ -means-clustering $( \mathbf { Z } )$   
+Generate label hierarchy $\{ \mathbf { Y } ^ { ( t ) } \} _ { t = 1 } ^ { \hat { D } }$ using 5   
+Fix $\pmb { \theta } ^ { * }$ , ${ \bf P } = N o n e$   
+for $t$ in $1 , 2 , 3 , \cdots , D$ do   
+R $\begin{array} { r l } & { \mathbf { W } ^ { ( t ) } , \ldots  \mathrm { I t e r a t i v e \_ L e a r n } ( \mathbf { X } , \mathbf { Y } ^ { ( t ) } , \mathbf { C } ^ { ( t ) } , \pmb { \theta } ^ { * } , \mathbf { P } ) } \\ & { \mathbf { P }  \mathrm { T o p } ( \mathbf { W } ^ { ( t ) \top } \Phi _ { c a t } ( \mathbf { X } , \pmb { \theta } ^ { * } ) , k ) } \\ & { \mathbf { e t u r n } : \Phi _ { c a t } ( \cdot , \pmb { \theta } ^ { * } ) , \{ \mathbf { C } ^ { ( t ) } \} _ { t = 1 } ^ { D } , \{ \mathbf { W } ^ { ( t ) } \} _ { t = 1 } ^ { D } } \end{array}$
+
+where $\Phi _ { d n n } ( \cdot , \Theta )$ is the transformer parametrized by $\Theta$ . Once the text representation is constructed, predictions can be made by simply applying a linear projection on top of the text representation through (1).
+
+Training with bootstrapping. The training of XR-Transformer consists of three steps. At first, a preliminary HLT is constructed using raw statistical features. Then a pre-trained transformer model is fine-tuned recursively from low resolution output to high resolution. At each layer $t$ , fine-tuning objective (9) is optimized with initialization $\Theta = \pmb \theta ^ { ( t - 1 ) * }$ the best transformer weights of layer $t - 1$ ${ \pmb \theta } ^ { ( 0 ) * }$ denotes the pre-trained transformer weights.
+
+Unlike the transformer warmed-up with pre-trained weights, the projection weights $\mathbf { W } ^ { ( t ) }$ is trained from scratch without good initialization. At the beginning of fine-tuning, gradient flow through these cold-start (usually randomly initialized) weights will usually worsen the pre-trained components.
+
+We leverage the recursive learning structure to tackle this issue by model bootstrapping. Concretely, $\mathbf { W } ^ { ( t ) }$ is initialized as:
+
+$$
+\mathbf { W } _ { i n i t } ^ { ( t ) } : = \underset { \mathbf { W } ^ { ( t ) } } { \operatorname { a r g m i n } } \sum _ { i = 1 } ^ { N } \sum _ { \ell : \mathbf { M } _ { i , \ell } ^ { ( t ) } \neq 0 } \hat { R } _ { i , \ell } ^ { ( t ) } \mathcal { L } ( Y _ { i , \ell } ^ { ( t ) } , \mathbf { W } _ { \ell } ^ { ( t ) \top } \Phi _ { d n n } ( \mathbf { x } _ { i } , \pmb { \theta } ^ { ( t - 1 ) * } ) ) + \lambda \| \mathbf { W } ^ { ( t ) } \| ^ { 2 } ,
+$$
+
+In practice, (11) is fast to compute since the semantic text feature for the previous layer $\Phi _ { c a t } ( \mathbf { X } , \pmb { \theta } ^ { ( t - 1 ) * } )$ is already computed and thus (11) can be solved very quickly on CPUs with a variety of parallel linear solvers, such as LIBLINEAR [49].
+
+Once the fine-tuning is complete, the refined HLT is constructed with the text representation that combines statistical text feature and fine-tuned semantic text embeddings. Then the ranking models are trained on top of the combined text features for the final prediction. The detailed training procedure is described in Algorithm 1 and 2.
+
+Inference. The inference cost of XR-Transformer consists mainly of two parts: cost to compute transformer embedding and to retrieve relevant labels through beam search. Therefore, the inference time complexity is $O ( T _ { d n n } + k d \log ( L ) )$ , where $k$ is the beam size, $d$ is the concatenated feature dimension and $T _ { d n n }$ is the time to compute $\Phi _ { d n n } ( \mathbf { x } )$ for a given input. Note that even the inference is done with beam search through the refined HLT, the transformer text embedding only need to be computed once per instance.
+
+Connections with other tree based methods. Although methods such as AttentionXML [8] also train on supervisions induced by label trees, the final model is a chain of sub-models which each on is learned on single-resolution. In particular, given a hierarchical label tree with depth $D$ , AttentionXML will train $D$ different text encoders on each layer of the tree where as XR-Transformer trains the same transformer encoder progressively on all layers of the tree. This difference leads to a longer inference time for AttentionXML than XR-Transformer since multiple text encoders need to be queried during inference, as shown in the comparison in the inference time in Appendix A.4.2.
+
+# 5 Experimental Results
+
+We evaluate XR-Transformer on 6 public XMC benchmarking datasets: Eurlex-4K, Wiki10-31K, AmazonCat-13K, Wiki-500K, Amazon-670K, Amazon-3M. Data statistics are given in Table 1. For fair comparison, we use the same raw text input, sparse feature representations and same train-test split as AttentionXML [8] and other latest works [12, 13]. The evaluation metric is Precision $@ \mathbf { k }$ $( \mathrm { P } @ \mathrm { k } )$ , which is widely-used in XMC literature [3, 8, 12, 13, 18, 28]. The results of Propensity-score Precision $@ \mathbf { k }$ $( { \mathrm { P S P } } @ \mathbf { k } )$ are defer to Appendix A.4.3, which focus more on tail labels’ performance.
+
+Table 1: Data statistics. $N _ { t r a i n } , N _ { t e s t }$ refer to the number of instances in the training and test sets, respectively. $L$ : the number of labels. $\bar { L }$ : the average number of positive labels per instance. $\bar { n }$ : average number of instances per label. $d _ { t f i d f }$ : the sparse feature dimension of $\bar { \Phi } _ { t f i d f } ( \cdot )$ . These six publicly available benchmark datasets, including the sparse TF-IDF features are downloaded from https://github.com/yourh/AttentionXML which are the same as AttentionXML [8] XTransformer [12] and LightXML [13] for fair comparison.   
+
+<table><tr><td>Dataset</td><td>Ntrain</td><td>Ntest</td><td>L</td><td>L</td><td>n</td><td>dtfidf</td></tr><tr><td>Eurlex-4K</td><td>15,449</td><td>3,865</td><td>3,956</td><td>5.30</td><td>20.79</td><td>186,104</td></tr><tr><td>Wiki10-31K</td><td>14,146</td><td>6,616</td><td>30.938</td><td>18.64</td><td>8.52</td><td>101,938</td></tr><tr><td>AmazonCat-13K</td><td>1,186,239</td><td>306,782</td><td>13,330</td><td>5.04</td><td>448.57</td><td>203,882</td></tr><tr><td>Wiki-500K</td><td>1,779,881</td><td>769,421</td><td>501,070</td><td>4.75</td><td>16.86</td><td>2,381,304</td></tr><tr><td>Amazon-670K</td><td>490,449</td><td>153,025</td><td>670.091</td><td>5.45</td><td>3.99</td><td>135,909</td></tr><tr><td>Amazon-3M</td><td>1,717,899</td><td>742,507</td><td>2,812,281</td><td>36.04</td><td>22.02</td><td>337,067</td></tr></table>
+
+Baseline Methods. We compare XR-Transformer with state-of-the-art (SOTA) XMC methods: AnnexML [28], DiSMEC [18], PfastreXML [41], Parabel [3], eXtremeText [24], Bonsai [50], XMLCNN [33], XR-Linear [7], AttentionXML [8], X-Transformer [12] and LightXML [13]. We obtain most baseline results from [8, Table 3] and [7, Table 3] except for the latest deep learning based algorithms [8, 12, 13]. To have fair comparison on training time, we use the same hardware (i.e., AWS p3.16xlarge) and the same inputs (i.e., raw text, vectorized features, data split) to obtain the results of AttentionXML, X-Transformer and LightXML. The hyper-parameter of XR-Transformer and more empirical results are included in Appendix A.3.
+
+Table 2: Comparison of XR-Transformer with recent XMC methods on six public datasets. Results with a trailing reference are taken from [8, Table 3] and [7, Table 3]. We obtain the results of AttentionXML∗, LightXML∗, X-Transformer∗ and XR-Transformer∗ on the same vectorized feature matrix provided in [8]. Due to GPU memory constraint, LightXML is not able to run on Amazon-3M. The $\mathrm { P S P } @ \mathrm { k }$ results are available in Appendix A.4.3.   
+
+<table><tr><td>Methods</td><td>P@1 P@3</td><td>P@5</td><td>P@1</td><td>P@3</td><td>P@5</td><td>P@1</td><td>P@3</td><td>P@5</td></tr><tr><td></td><td colspan="6">Eurlex-4K Wiki10-31K</td><td>AmazonCat-13K</td><td></td></tr><tr><td>AnnexML [28] DiSMEC[18]</td><td>79.66 83.21</td><td>64.94 70.39</td><td>53.52 58.73</td><td>86.46 84.13 83.57</td><td>74.28 74.72 68.61</td><td>64.20 65.94 59.10</td><td>93.54 78.36 93.81 79.08</td><td>63.30 64.06</td></tr><tr><td>PfastreXML [41] Parabel [3]</td><td>73.14 82.12</td><td>60.16 68.91</td><td>50.54 57.89</td><td>84.19</td><td>72.46 63.37</td><td>91.75 93.02</td><td>77.97 79.14</td><td>63.68 64.51</td></tr><tr><td>eXtremeText [24]</td><td>79.17</td><td>66.80</td><td>56.09</td><td>83.66 73.28</td><td>64.51</td><td>92.50</td><td>78.12</td><td>63.51</td></tr><tr><td>Bonsai [50]</td><td>82.30</td><td>69.55</td><td>58.35</td><td>84.52 73.76</td><td>64.69</td><td>92.98</td><td></td><td>64.46</td></tr><tr><td>XML-CNN [33]</td><td>75.32</td><td>60.14</td><td>49.21</td><td>81.41 66.23</td><td>56.11</td><td></td><td>79.13</td><td></td></tr><tr><td>XR-Linear [7]</td><td>84.14</td><td>72.05 60.67</td><td>85.75</td><td>75.79</td><td>66.69</td><td>93.26</td><td>77.06</td><td>61.40</td></tr><tr><td>AttentionXML*</td><td></td><td></td><td></td><td></td><td></td><td>94.64</td><td>79.98</td><td>64.79</td></tr><tr><td>X-Transformer*</td><td>86.93</td><td>74.12</td><td>62.16</td><td>87.34</td><td>78.18</td><td>69.07 95.84</td><td>82.39</td><td>67.32</td></tr><tr><td></td><td>87.61</td><td>75.39 75.95</td><td>63.05 63.45</td><td>88.26</td><td>78.51</td><td>69.68 96.48</td><td>83.41</td><td>68.19</td></tr><tr><td>LightXML*</td><td>87.15</td><td></td><td></td><td>89.67 79.06</td><td>69.87</td><td>96.77</td><td>83.98</td><td>68.63</td></tr><tr><td>XR-Transformer*</td><td>88.41 75.97</td><td>63.18</td><td>88.69</td><td>80.17</td><td>70.91</td><td>96.79</td><td>83.66</td><td>68.04</td></tr><tr><td>AnnexML [28]</td><td>Wiki-500K</td><td></td><td></td><td></td><td>Amazon-670K</td><td></td><td>Amazon-3M</td><td></td></tr><tr><td>DiSMEC[18]</td><td>64.22 70.21</td><td>43.15 50.57</td><td>32.79 39.68</td><td>42.09 44.78 36.84</td><td>36.61 39.72</td><td>32.75 36.17</td><td>49.30 45.55 47.34 44.96</td><td>43.11 42.80</td></tr><tr><td>PfastreXML [41] Parabel [3]</td><td>56.25</td><td>37.32 49.57</td><td>28.16</td><td>34.23</td><td>32.09</td><td>43.83</td><td>41.81</td><td>40.09</td></tr><tr><td>eXtremeText [24]</td><td>68.70</td><td></td><td>38.64</td><td>44.91 39.77</td><td>35.98</td><td>47.42</td><td>44.66</td><td>42.55</td></tr><tr><td></td><td>65.17</td><td>46.32</td><td>36.15</td><td>42.54 37.93</td><td>34.63</td><td>42.20</td><td>39.28</td><td>37.24</td></tr><tr><td>Bonsai [50]</td><td>69.26</td><td>49.80</td><td>38.83</td><td>45.58 40.39</td><td>36.60</td><td>48.45</td><td>45.65</td><td>43.49</td></tr><tr><td>XML-CNN [33]</td><td>1</td><td>1</td><td>1</td><td>33.41</td><td>30.00 27.42</td><td>1</td><td>-</td><td>1</td></tr><tr><td>XR-Linear [7]</td><td>65.59</td><td>46.72</td><td>36.46</td><td>43.38</td><td>38.40 34.77</td><td>47.40</td><td>44.15</td><td>41.87</td></tr><tr><td>AttentionXML*</td><td>76.74</td><td>58.18</td><td>45.95</td><td>47.68</td><td></td><td>50.86</td><td></td><td></td></tr><tr><td>X-Transformer*</td><td>77.09</td><td>57.51</td><td>45.28</td><td>48.07</td><td>42.70</td><td>38.99</td><td>48.00</td><td>45.82</td></tr><tr><td></td><td></td><td></td><td></td><td>42.96</td><td>39.12</td><td>51.20</td><td>47.81</td><td>45.07</td></tr><tr><td>LightXML* XR-Transformer*</td><td>77.89 79.40</td><td>58.98 59.02</td><td>45.71 46.25</td><td>49.32 44.17 50.11 44.56</td><td>40.25 40.64</td><td>= 54.20</td><td>= 50.81</td><td>48.26</td></tr></table>
+
+Table 3: Comparing training time (in hours) of DNN-based methods that produce the SOTA results in Table 2. The number following the model indicates the number of ensemble models used.   
+
+<table><tr><td>Dataset</td><td>AttentionXML-3</td><td>X-Transformer-9</td><td>LightXML-3</td><td>XR-Transformer-3</td></tr><tr><td>Eurlex-4K</td><td>0.9</td><td>7.5</td><td>16.9</td><td>0.8</td></tr><tr><td>Wiki10-31K</td><td>1.5</td><td>14.1</td><td>26.9</td><td>1.5</td></tr><tr><td>AmazonCat-13K</td><td>24.3</td><td>147.6</td><td>310.6</td><td>13.2</td></tr><tr><td>Wiki-500K</td><td>37.6</td><td>557.1</td><td>271.3</td><td>38.0</td></tr><tr><td>Amazon-670K</td><td>24.2</td><td>514.8</td><td>159.0</td><td>10.5</td></tr><tr><td>Amazon-3M</td><td>54.8</td><td>542.0</td><td>1</td><td>29.3</td></tr></table>
+
+Model Performance. The comparisons of Precision $@ \mathbf { k }$ $( \mathrm { P } @ \mathrm { k } )$ and training time are shown in Table 2 and Table 8, respectively. The proposed XR-Transformer follows AttentionXML and LightXML to use an ensemble of 3 models, while X-Transformer uses an ensemble of 9 models [12]. More details about the ensemble setting can be found in Appendix A.3. The proposed XR-Transformer framework achieves new SOTA results in 14 out of 18 evaluation columns (combination of datasets and $\mathrm { P } @ \mathrm { k } ,$ ), and outperforms competitive methods on the large datasets. Next, we show the training time of XR-Transformer is significantly less than other DNN-based models.
+
+Table 4: Single model comparison of DNN based XMC models. Training time on p3.16xlarge with 8 Nvidia V100 GPUs whereas time on singl $T _ { t r a i n } ^ { 8 }$ are reported ia V100 GPU entionXML, X-Transformer and XR-Transformer,is reported for LightXML and XR-Transformer. $T _ { t r a i n } ^ { 1 }$   
+
+<table><tr><td>Dataset</td><td>Method</td><td>P@1</td><td>P@3</td><td>P@5</td><td></td><td></td></tr><tr><td rowspan="4">Wiki10-31K</td><td>AttentionXML-1</td><td>87.1</td><td>77.8</td><td>68.8</td><td>1</td><td>0.5</td></tr><tr><td>X-Transformer-1</td><td>87.5</td><td>77.2</td><td>67.1</td><td>-</td><td>3.5</td></tr><tr><td>LightXML-1</td><td>87.8</td><td>77.3</td><td>68.0</td><td>6.7</td><td>-</td></tr><tr><td>XR-Transformer-1</td><td>88.0</td><td>78.7</td><td>69.1</td><td>1.3</td><td>0.5</td></tr><tr><td rowspan="4">Wiki-500K</td><td>AttentionXML-1</td><td>75.1</td><td>56.5</td><td>44.4</td><td>-</td><td>12.5</td></tr><tr><td>X-Transformer-1</td><td>44.8</td><td>40.1</td><td>34.6</td><td>-</td><td>56.0</td></tr><tr><td>LightXML-1</td><td>76.3</td><td>57.3</td><td>44.2</td><td>89.6</td><td>1</td></tr><tr><td>XR-Transformer-1</td><td>78.1</td><td>57.6</td><td>45.0</td><td>29.2</td><td>12.5</td></tr><tr><td rowspan="4">Amazon-670K</td><td>AttentionXML-1</td><td>45.7</td><td>40.7</td><td>36.9</td><td>-</td><td>8.1</td></tr><tr><td>X-Transformer-1</td><td>44.8</td><td>40.1</td><td>34.6</td><td>、</td><td>56.0</td></tr><tr><td>LightXML-1</td><td>47.3</td><td>42.2</td><td>38.5</td><td>53.0</td><td>-</td></tr><tr><td>XR-Transformer-1</td><td>49.1</td><td>43.8</td><td>40.0</td><td>8.1</td><td>3.4</td></tr></table>
+
+Training Cost. Table 8 shows the training time for these DNN-based models. To have fair comparison, all the experiments are conducted with float32 precision on AWS p3.16xlarge instance with 8 Nvidia V100 GPUs except for LightXML, which was run on single V100 GPU since multi-GPU training is not implemented. XR-Transformer consumes significantly less training time compared with other transformer based models and the shallow BiLSTM model AttentionXML. On Amazon3M, XR-Transformer has $2 0 x$ speedup over X-Transformer while achieving even better $\mathrm { P @ { k } }$ . Finally, in table 4, we compare XR-Transformer with LightXML under the single model setup (no ensemble), where XR-Transformer still consistently outperforms LightXML in $\mathbf { P } @ \mathbf { k }$ and training time.
+
+Table 5: Comparing XR-Transformer with Pre-Trained and word2vec embeddings concatenated with TF-IDF features.   
+
+<table><tr><td>Methods</td><td>P@1 P@3</td><td>P@5</td><td>P@1</td><td>P@3</td><td>P@5</td><td>P@1</td><td>P@3</td><td>P@5</td></tr><tr><td></td><td colspan="6">Eurlex-4K</td><td>AmazonCat-13K</td><td></td></tr><tr><td>TF-IDF</td><td>84.14 72.05</td><td>60.97</td><td>85.75</td><td>75.79</td><td>66.69</td><td>94.64</td><td>79.98</td><td>64.79</td></tr><tr><td>word2vec +TF-IDF</td><td>84.35 71.27</td><td>59.10</td><td>86.11</td><td>76.92</td><td>66.45</td><td>94.53</td><td>79.44</td><td>63.94</td></tr><tr><td>Pre-Trained +TF-IDF</td><td>84.92 71.40</td><td>59.36</td><td>85.78</td><td>78.30</td><td>68.33</td><td>95.05</td><td>80.12</td><td>64.53</td></tr><tr><td>XR-Transformer</td><td>88.41 75.97</td><td>63.18</td><td>88.69</td><td>80.17</td><td>70.91</td><td>96.79</td><td>83.66</td><td>68.04</td></tr><tr><td></td><td colspan="6">Wiki-500K Amazon-670K</td><td>Amazon-3M</td><td></td></tr><tr><td>TF-IDF</td><td>65.59</td><td>46.72 36.46</td><td>43.38</td><td>38.40</td><td>34.77</td><td>47.40</td><td>44.15</td><td>41.87</td></tr><tr><td>word2vec +TF-IDF</td><td>68.21</td><td>48.16 37.54</td><td>44.04</td><td>39.07</td><td>35.35</td><td>47.51</td><td>44.49</td><td>42.19</td></tr><tr><td>Pre-Trained +TF-IDF</td><td>70.18</td><td>49.82 38.75</td><td>44.55</td><td>38.91</td><td>34.77</td><td>49.66</td><td>46.41</td><td>43.96</td></tr><tr><td>XR-Transformer</td><td>79.40</td><td>59.02 46.25</td><td>50.11</td><td>44.56</td><td>40.64</td><td>54.20</td><td>50.81</td><td>48.26</td></tr></table>
+
+Comparison of Different Semantic Embeddings. To provide more empirical justifications, that the improvement in performance comes from better semantic embedding rather than the introducing of TF-IDF features, we further tested models using Pre-Trained Transformer and word2vec embeddings concatenated with the same TF-IDF features.
+
+Table 5 summarizes the performance of these models on all 6 datasets. In particular, word2vec is using token embedding from word2vec-google-news-300 and for Pre-Trained we use the same setting as XR-Transformer (3-model ensemble). On large datasets such as Wiki-500K/Amazon670K/Amazon-3M, Pre-Trained $+ \mathrm { T F }$ -IDF has marginal improvement compared to the baseline TF-IDF features. Nevertheless, our proposed XR-Transformer still enjoy significant gain compared to Pre-Trained $+ \mathrm { T F }$ -IDF. This suggests the major improvement is from learning more powerful neural semantic embeddings, rather than the use of TF-IDF.
+
+Effect of Cost-Sensitive Learning. In Table 6, we analyze the effect of cost sensitive learning on four XMC datasets with the largest output spaces. On most datasets, cost sensitive learning via aggregated labels yields better performance than those without. We also show that cost-sensitive learning is not only beneficial to XR-Transformer, but also useful to its linear counterpart XRLinear [7]. See Appendix A.4.1 for more results.
+
+Table 6: Ablation of cost-sensitive learning on the single XR-Transformer model with or without Cost Sensitive (CS). Precision $\boldsymbol { \ @ 1 , 3 , 5 } \ : \mathrm { P } ( \boldsymbol { \ @ } \mathrm { k } )$ and Recall $^ { ( a ) 1 , 3 , 5 }$ $( \mathbb { R } ^ { \circledcirc \mathrm { k } ) }$ are reported.   
+
+<table><tr><td>Dataset</td><td>Method</td><td>P@1</td><td>P@3</td><td>P@5</td><td>R@1</td><td>R@3</td><td>R@5</td></tr><tr><td>Wiki10-31K</td><td>XR-Transformer-1(w/o CS) XR-Transformer-1</td><td>86.8 88.0</td><td>77.6 78.7</td><td>68.8 69.1</td><td>5.2 5.3</td><td>13.6 13.8</td><td>19.8 19.9</td></tr><tr><td>Wiki-500K</td><td>XR-Transformer-1(w/o CS) XR-Transformer-1</td><td>77.6 78.1</td><td>57.4 57.6</td><td>44.9 45.0</td><td>25.8 26.1</td><td>48.1 48.5</td><td>57.8 58.1</td></tr><tr><td>Amazon-670K</td><td>XR-Transformer-1(w/o CS) XR-Transformer-1</td><td>49.1 49.0</td><td>43.8 43.7</td><td>40.0 39.9</td><td>10.3 10.4</td><td>25.6 25.7</td><td>37.7 37.7</td></tr><tr><td>Amazon-3M</td><td>XR-Transformer-1(w/o CS) XR-Transformer-1</td><td>50.2 52.6</td><td>47.6 49.4</td><td>45.4 46.9</td><td>3.4 3.8</td><td>8.4 9.3</td><td>12.4 13.6</td></tr></table>
+
+Effect of Label Resolution and Text Representation. Next, we compare the effect of label resolution on the quality of the finetuned transformer embeddings. We finetune transformer models in a non-recursive manner on a two layer HLT with different leaf cluster size. Then the fine-tuned transformer embeddings are used along or in combination with TF-IDF features to produce the predictions with refined HLT. From Figure 2 we can observe that a larger cluster size will result in worse semantic features. Figure 2 also shows that combining semantic features $\Phi _ { d n n }$ with statistical features $\Phi _ { t f i d f }$ could in general improve the model performance.
+
+![](images/03c79d8c35fdaa79ddede59d237f8e3c9058ea90641c96c6335f1749f2615180.jpg)  
+Figure 2: Comparison of BERT model fine-tuned with different label resolution. Larger cluster size means lower label resolution. Note that $\Phi _ { c a t }$ is the normalized concatenation of $\Phi _ { t f i d f }$ and $\Phi _ { d n n }$ .
+
+# 6 Conclusion and Future work
+
+In this paper, we have presented XR-Transformer approach, which is an XMC architecture that leverages multi-resolution objectives and cost sensitive learning to accelerate the fine-tuning of pre-trained transformer models. Experiments show that the proposed method establishes new stateof-the-art results on public XMC datasets while taking significantly less training time compared with earlier transformer based methods. Although the proposed architecture is designed for XMC, the ideas can be applied to other areas such as information retrieval or other DNN models such as CNNs/ResNets. Also, more extensive study is required to understand why the coarse-to-fine scheme would lead to not only faster training but better overall quality. A hypothesis is that the problem is being solved at multiple scales hence leading to more robust learning of deep transformer models.
+
+References   
+[1] Wei-Cheng Chang, Felix X. Yu, Yin-Wen Chang, Yiming Yang, and Sanjiv Kumar. Pre-training tasks for embedding-based large-scale retrieval. In International Conference on Learning Representations, 2020.   
+[2] Kenton Lee, Ming-Wei Chang, and Kristina Toutanova. Latent retrieval for weakly supervised open domain question answering. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics (ACL), 2019.   
+[3] Yashoteja Prabhu, Anil Kag, Shrutendra Harsola, Rahul Agrawal, and Manik Varma. Parabel: Partitioned label trees for extreme classification with application to dynamic search advertising. In WWW, 2018.   
+[4] Yashoteja Prabhu and Manik Varma. Fastxml: A fast, accurate and stable tree-classifier for extreme multi-label learning. In KDD, 2014.   
+[5] Wei-Cheng Chang, Daniel Jiang, Hsiang-Fu Yu, Choon-Hui Teo, Jiong Zhang, Kai Zhong, Kedarnath Kolluri, Qie Hu, Nikhil Shandilya, Vyacheslav Ievgrafov, Japinder Singh, and Inderjit S Dhillon. Extreme multi-label learning for semantic matching in product search. In KDD. ACM, 2021.   
+[6] Sujay Khandagale, Han Xiao, and Rohit Babbar. Bonsai: diverse and shallow trees for extreme multi-label classification. Machine Learning, 109(11):2099–2119, 2020.   
+[7] Hsiang-Fu Yu, Kai Zhong, and Inderjit S Dhillon. PECOS: Prediction for enormous and correlated output spaces. arXiv preprint arXiv:2010.05878, 2020.   
+[8] Ronghui You, Zihan Zhang, Ziye Wang, Suyang Dai, Hiroshi Mamitsuka, and Shanfeng Zhu. AttentionXML: Label tree-based attention-aware deep model for high-performance extreme multi-label text classification. In Advances in Neural Information Processing Systems, pages 5812–5822, 2019.   
+[9] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics (NAACL), 2019.   
+[10] Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. XLNet: Generalized autoregressive pretraining for language understanding. In NIPS, 2019.   
+[11] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. RoBERTa: A robustly optimized BERT pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   
+[12] Wei-Cheng Chang, Hsiang-Fu Yu, Kai Zhong, Yiming Yang, and Inderjit S Dhillon. Taming pretrained transformers for extreme multi-label text classification. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 3163–3171, 2020.   
+[13] Ting Jiang, Deqing Wang, Leilei Sun, Huayi Yang, Zhengyang Zhao, and Fuzhen Zhuang. LightXML: Transformer with dynamic negative sampling for high-performance extreme multilabel text classification. In AAAI, 2021.   
+[14] Wei-Sheng Lai, Jia-Bin Huang, Narendra Ahuja, and Ming-Hsuan Yang. Deep laplacian pyramid networks for fast and accurate super-resolution. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.   
+[15] Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. In ICLR, 2018.   
+[16] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4401–4410, 2019.
+
+[17] Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th annual international conference on machine learning, pages 41–48, 2009.
+
+[18] Rohit Babbar and Bernhard Schölkopf. DiSMEC: distributed sparse machines for extreme multi-label classification. In WSDM, 2017.
+
+[19] Ian EH Yen, Xiangru Huang, Kai Zhong, Pradeep Ravikumar, and Inderjit S Dhillon. PDSparse: A primal and dual sparse approach to extreme multiclass and multilabel classification. In International Conference on Machine Learning (ICML), 2016.
+
+[20] Ian EH Yen, Xiangru Huang, Wei Dai, Pradeep Ravikumar, Inderjit Dhillon, and Eric Xing. PPDsparse: A parallel primal-dual sparse method for extreme classification. In KDD. ACM, 2017.
+
+[21] Rohit Babbar and Bernhard Schölkopf. Data scarcity, robustness and extreme multi-label classification. Machine Learning, pages 1–23, 2019.
+
+[22] Anna E Choromanska and John Langford. Logarithmic time online multiclass prediction. Advances in Neural Information Processing Systems, 28:55–63, 2015.
+
+[23] Hal Daumé III, Nikos Karampatziakis, John Langford, and Paul Mineiro. Logarithmic time one-against-some. In International Conference on Machine Learning, pages 923–932. PMLR, 2017.
+
+[24] Marek Wydmuch, Kalina Jasinska, Mikhail Kuznetsov, Róbert Busa-Fekete, and Krzysztof Dembczynski. A no-regret generalization of hierarchical softmax to extreme multi-label classification. In NIPS, 2018.
+
+[25] Yashoteja Prabhu, Aditya Kusupati, Nilesh Gupta, and Manik Varma. Extreme regression for dynamic search advertising. In Proceedings of the 13th International Conference on Web Search and Data Mining, pages 456–464, 2020.
+
+[26] Kalina Jasinska-Kobus, Marek Wydmuch, Krzysztof Dembczynski, Mikhail Kuznetsov, and Robert Busa-Fekete. Probabilistic label trees for extreme multi-label classification. arXiv preprint arXiv:2009.11218, 2020.
+
+[27] Kalina Jasinska-Kobus, Marek Wydmuch, Devanathan Thiruvenkatachari, and Krzysztof Dembczynski. Online probabilistic label trees. In International Conference on Artificial Intelligence and Statistics, pages 1801–1809. PMLR, 2021.
+
+[28] Yukihiro Tagami. AnnexML: Approximate nearest neighbor search for extreme multi-label classification. In Proceedings of the 23rd ACM SIGKDD international conference on knowledge discovery and data mining, pages 455–464, 2017.
+
+[29] Himanshu Jain, Venkatesh Balasubramanian, Bhanu Chunduri, and Manik Varma. SLICE: Scalable linear extreme classifiers trained on 100 million labels for related searches. In Proceedings of the Twelfth ACM International Conference on Web Search and Data Mining, pages 528–536. ACM, 2019.
+
+[30] Y. A. Malkov and D. A. Yashunin. Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs. IEEE Transactions on Pattern Analysis and Machine Intelligence, 42(4):824–836, 2020.
+
+[31] Chuan Guo, Ali Mousavi, Xiang Wu, Daniel N Holtmann-Rice, Satyen Kale, Sashank Reddi, and Sanjiv Kumar. Breaking the glass ceiling for embedding-based classifiers for large output spaces. In Advances in Neural Information Processing Systems, pages 4944–4954, 2019.
+
+[32] Ruiqi Guo, Philip Sun, Erik Lindgren, Quan Geng, David Simcha, Felix Chern, and Sanjiv Kumar. Accelerating large-scale inference with anisotropic vector quantization. In International Conference on Machine Learning, pages 3887–3896. PMLR, 2020.
+
+[33] Jingzhou Liu, Wei-Cheng Chang, Yuexin Wu, and Yiming Yang. Deep learning for extreme multi-label text classification. In Proceedings of the 40th International ACM SIGIR Conference on Research and Development in Information Retrieval, pages 115–124. ACM, 2017.
+
+[34] Tharun Kumar Reddy Medini, Qixuan Huang, Yiqiu Wang, Vijai Mohan, and Anshumali Shrivastava. Extreme classification in log memory using count-min sketch: A case study of amazon search with $5 0 \mathrm { m }$ products. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   
+[35] Kunal Dahiya, Deepak Saini, Anshul Mittal, Ankush Shaw, Kushal Dave, Akshay Soni, Himanshu Jain, Sumeet Agarwal, and Manik Varma. DeepXML: A deep extreme multi-label learning framework applied to short text documents. In Proceedings of the 14th ACM International Conference on Web Search and Data Mining, pages 31–39, 2021.   
+[36] Anshul Mittal, Kunal Dahiya, Sheshansh Agrawal, Deepak Saini, Sumeet Agarwal, Purushottam Kar, and Manik Varma. DECAF: Deep extreme classification with label features. In Proceedings of the 14th ACM International Conference on Web Search and Data Mining, pages 49–57, 2021.   
+[37] D. Saini, A.K. Jain, K. Dave, J. Jiao, A. Singh, R. Zhang, and M. Varma. GalaXC: Graph neural networks with labelwise attention for extreme classification. In Proceedings of The Web Conference, April 2021.   
+[38] A. Mittal, N. Sachdeva, S. Agrawal, S. Agarwal, P. Kar, and M. Varma. ECLARE: Extreme classification with label graph correlations. In Proceedings of The ACM International World Wide Web Conference, April 2021.   
+[39] Hui Ye, Zhiyu Chen, Da-Han Wang, and Brian Davison. Pretrained generalized autoregressive model with adaptive probabilistic label clusters for extreme multi-label text classification. In International Conference on Machine Learning, pages 10809–10819. PMLR, 2020.   
+[40] Armand Joulin, Moustapha Cissé, David Grangier, Hervé Jégou, et al. Efficient softmax approximation for gpus. In International Conference on Machine Learning, pages 1302–1310. PMLR, 2017.   
+[41] Himanshu Jain, Yashoteja Prabhu, and Manik Varma. Extreme multi-label loss functions for recommendation, tagging, ranking & other missing label applications. In KDD, 2016.   
+[42] Marco Pedersoli, Andrea Vedaldi, Jordi Gonzalez, and Xavier Roca. A coarse-to-fine approach for fast deformable object detection. Pattern Recognition, 48(5):1844–1853, 2015.   
+[43] Shikun Liu, Andrew J Davison, and Edward Johns. Self-Supervised generalisation with meta auxiliary learning. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   
+[44] Charles Elkan. The foundations of cost-sensitive learning. In International joint conference on artificial intelligence, volume 17, pages 973–978. Lawrence Erlbaum Associates Ltd, 2001.   
+[45] Chun-Liang Li and Hsuan-Tien Lin. Condensed filter tree for cost-sensitive multi-label classification. In International Conference on Machine Learning, pages 423–431. PMLR, 2014.   
+[46] Kuan-Hao Huang and Hsuan-Tien Lin. Cost-sensitive label embedding for multi-label classification. Machine Learning, 106(9):1725–1746, 2017.   
+[47] Hsuan-Tien Lin. Advances in cost-sensitive multiclass and multilabel classification. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 3187–3188, 2019.   
+[48] Aditya K Menon, Ankit Singh Rawat, Sashank Reddi, and Sanjiv Kumar. Multilabel reductions: what is my loss optimising? In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   
+[49] Rong-En Fan, Kai-Wei Chang, Cho-Jui Hsieh, Xiang-Rui Wang, and Chih-Jen Lin. LIBLINEAR: a library for large linear classification. Journal of machine learning research, 9(Aug):1871–1874, 2008.

parse/train/gjBz22V93a/gjBz22V93a_content_list.json

@@ -0,0 +1,1243 @@
+[
+    {
+        "type": "text",
+        "text": "Fast Multi-Resolution Transformer Fine-tuning for Extreme Multi-label Text Classification ",
+        "text_level": 1,
+        "bbox": [
+            191,
+            122,
+            808,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiong Zhang   \nAmazon   \njiongz@amazon.com ",
+        "bbox": [
+            230,
+            222,
+            362,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wei-cheng Chang Amazon chanweic@amazon.com ",
+        "bbox": [
+            424,
+            222,
+            575,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hsiang-fu Yu   \nAmazon   \nrofu.yu@gmail.com ",
+        "bbox": [
+            635,
+            222,
+            769,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inderjit S. Dhillon UT Austin & Amazon inderjit@cs.utexas.edu ",
+        "bbox": [
+            413,
+            285,
+            584,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            363,
+            535,
+            378
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Extreme multi-label text classification (XMC) seeks to find relevant labels from an extreme large label collection for a given text input. Many real-world applications can be formulated as XMC problems, such as recommendation systems, document tagging and semantic search. Recently, transformer based XMC methods, such as XTransformer and LightXML, have shown significant improvement over other XMC methods. Despite leveraging pre-trained transformer models for text representation, the fine-tuning procedure of transformer models on large label space still has lengthy computational time even with powerful GPUs. In this paper, we propose a novel recursive approach, XR-Transformer to accelerate the procedure through recursively fine-tuning transformer models on a series of multi-resolution objectives related to the original XMC objective function. Empirical results show that XRTransformer takes significantly less training time compared to other transformerbased XMC models while yielding better state-of-the-art results. In particular, on the public Amazon-3M dataset with 3 million labels, XR-Transformer is not only 20x faster than X-Transformer but also improves the Precision $@ 1$ from $5 1 \\%$ to $5 4 \\%$ . Our code is publicly available at https://github.com/amzn/pecos. ",
+        "bbox": [
+            233,
+            392,
+            766,
+            614
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            312,
+            654
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many real-world applications such as open-domain question answering [1, 2], e-commerce dynamic search advertising [3, 4], and semantic matching [5], can be formulated as an extreme multi-label text classification (XMC) problem: given a text input, predict relevant labels from an enormous label collection of size $L$ . In these applications, $L$ ranges from tens of thousands to millions, which makes it very challenging to design XMC models that are both accurate and efficient to train. Recent works such as Parabel [3], Bonsai [6], XR-Linear [7] and AttentionXML [8], exploit the correlations among the labels to generate label partitions or hierarchical label trees (HLTs) which can be used to shortlist candidate labels to be considered during training and inference. While these methods are scalable in terms of the size of the label collection, most of them rely only on statistical representations (such as bag-of-words) or pooling from pre-generated token embeddings (such as word2vec) to vectorize text inputs. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            813
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In light of the recent success of deep pretrained transformers models such as BERT [9], XLNet [10] and RoBerta [11] in various NLP applications, X-Transformer [12] and LightXML [13] propose to fine-tune pre-trained transformer models on XMC tasks to obtain new state-of-the-art results over the aforementioned approaches. Although transformers are able to better capture semantic meaning of textual inputs than statistical representations, text truncation is often needed in practice to reduce GPU memory footprint and maintain model efficiency. For example, X-Transformer truncates input texts to contain the first 128 tokens before feeding it into transformer models. Efficiency of transformer fine-tuning poses another challenge for XMC applications. Directly fine-tuning transformer models on the original XMC task with a very large label collection is infeasible as both the training time and the memory consumption are linear in $L$ . In order to alleviate this, both $\\mathbf { X }$ -Transformer and LightXML adopt a similar approach to group $L$ labels into $K$ clusters of roughly equal size denoted by $B$ and fine-tune transformers on the task to identify relevant label clusters (instead of labels themselves). If $B \\approx { \\sqrt { L } }$ and $K \\approx { \\sqrt { L } }$ , then both the training time and the memory requirement of the fine-tuning can be reduced to $O ( \\sqrt { L } )$ from $O ( L )$ . However, as pointed out in [8], the model performance would deteriorate due to the information loss from label aggregation. Thus, both XTransformer and LightXML still choose a small constant $B$ $( \\leq 1 0 0 )$ as the size of the label clusters. As a result, transformers are still fine-tuned on a task with around $L / 1 0 0$ clusters, which leads to a much longer training time compared with non-transformer based models. For example, it takes X-Transformer 23 and 25 days respectively to train on Amazon-3M and Wiki- $5 0 0 \\mathsf { K }$ even with 8 Nvidia V100 GPUs. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            287
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address these issues, we propose XR-Transformer, an XMC architecture that leverages pre-trained transformer models and has much smaller training cost compared to other transformer-based XMC methods. Motivated by the multi-resolution learning in image generation [14–16] and curriculum learning [17], we formulate the XMC problem as a series of sub-problems with multi-resolution label signals and recursively fine-tune the pre-trained transformer on the coarse-to-fine objectives. In this paper, our contributions are as follows: ",
+        "bbox": [
+            174,
+            295,
+            825,
+            377
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose XR-Transformer, a transformer based framework for extreme multi-label text classification where the pre-trained transformer is recursively fine-tuned on a series of easyto-hard training objectives defined by a hierarchical label tree. This allows the transformers to be quickly fine-tuned for a XMC problem with a very large number label collection progressively. To get better text representation and mitigate the information loss in text truncation for transformers, we take into account statistical text features in addition to the transformer text embeddings in our model. Also, a cost sensitive learning scheme by label aggregation is proposed to introduce richer information on the coarsified labels.   \nWe conduct experiments on 6 public XMC benchmarking datasets and our model takes significantly lower training time compared to other transformer-based XMC models to yield better state-of-the-art results. For example, we improve the state-of-the-art Prec $@ 1$ result on Amazon-3M established by X-Transformer from $5 1 . 2 0 \\%$ to $5 4 . 0 4 \\%$ while reducing the required training time from 23 days to 29 hours using the same hardware. ",
+        "bbox": [
+            217,
+            385,
+            825,
+            578
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            589,
+            330,
+            606
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sparse Linear Models with Partitioning Techniques. Conventional XMC methods consider fixed input representations such as sparse TF-IDF features and study different partitioning techniques or surrogate loss functions on the large output spaces to reduce complexity. For example, sparse linear one-versus-all (OVA) methods such as DiSMEC [18], PPD-Sparse [19, 20], ProXML [21] explore parallelism to solve OVA losses and reduce the model size by weight truncations. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            683
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The inference time complexity of OVA models is linear in the output space, which can be greatly improved by partitioning methods or approximate nearest neighbor (ANN) indexing on the label spaces. Initial works on tree-based methods [22, 23] reduce the OVA problem to one-versus-some (OVS) with logarithmic depth trees. Down that path, recent works on sparse linear models including Parabel [3], eXtremeText [24], Bonsai [6], XReg [25], NAPKINXC [26, 27] and XR-Linear [7] partition labels with $B$ -array hierarchical label trees (HLT), leading to inference time complexity that is logarithmic in the output space. On the other hand, low-dimensional embedding-based models often leverage ANN methods to speed up the inference procedure. For example, AnnexML [28] and SLICE [29] consider graph-based methods such as HNSW [30] while GLaS [31] considers product quantization variants such as ScaNN [32]. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            828
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Shallow Embedding-based Methods. Neural-based XMC models employ various network architectures to learn semantic embeddings of the input text. XML-CNN [33] applies one-dimensional CNN on the input sequence and use the BCE loss without sampling, which is not scalable to XMC problems. AttentionXML [8] employs BiLSTMs and label-aware attention as scoring functions. For better scalability to large output spaces, only a small number of positive and hard negative labels are used in model GPU training. Shallow embedding-based methods [34–38] use word embedding lookup followed by shallow MLP layers to obtain input embeddings. For instance, MACH [34] learns MLP layers on several smaller XMC sub-problems induced by hashing tricks on the large label space. Similarly, DeepXML [35] and its variant (i.e., DECAF [36], GalaXC [37], ECLARE [38]) pre-train MLP encoders on XMC sub-problems induced by label clusters. They freeze the pre-trained word embedding and learn another MLP layer followed by a linear ranker with sampled hard negative labels from HNSW [30]. Importantly, shallow embedding-based methods only show competitive performance on short-text XMC problems where the number of input tokens is small [34, 35]. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            203
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep Transformer Models. Recently, pre-trained Transformer models [9–11] have been applied to XMC problems with promising results [12, 13, 39]. X-Transformer [12] considers a two-stage approach where the first stage transformer-based encoders are learned on XMC sub-problems induced by balanced label clusters, and the second stage sparse TF-IDF is combined with the learned neural embeddings as the input to linear OVA models. APLC-XLNet [39] fine-tunes XLNet encoder on adaptive imbalanced label clusters based on label frequency similar to Adaptive Softmax [40]. LightXML [13] fine-tunes Transformer encoders with the OVA loss function end-to-end via dynamic negative sampling from the matching network trained on label cluster signals. Nonetheless, Transformer-based XMC models have larger model size and require longer training time, which hinders its practical usage on different downstream XMC problems. ",
+        "bbox": [
+            173,
+            215,
+            826,
+            356
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Background Material ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            375,
+            387,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We assume we are given a training set $\\{ \\mathbf { x } _ { i } , \\mathbf { y } _ { i } \\} _ { i = 1 } ^ { N }$ where $\\mathbf { x } _ { i } \\in \\mathcal { D }$ is the ith input document and $\\mathbf { y } _ { i } \\in \\{ 0 , 1 \\} ^ { L }$ is the one hot label vector with $y _ { i , \\ell } = 1$ indicating that label $\\ell$ is relevant to instance $i$ The goal of eXtreme Multi-label Text Classification (XMC) is to learn a function $f : \\mathcal { D } \\times \\left[ L \\right] \\mapsto \\mathbb { R }$ , such that $f ( \\mathbf { x } , \\boldsymbol { \\ell } )$ denotes the relevance between the input $\\mathbf { x }$ and the label $\\ell$ . In practice, labels with the largest $k$ values are retrieved as the predicted relevant labels for a given input $\\mathbf { x }$ . The most straightforward model is one-versus-all (OVA) model: ",
+        "bbox": [
+            173,
+            405,
+            825,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ec3198af767bb5a54515f08126101587d3acd12c0d266b0c495a5b5977c3db0.jpg",
+        "text": "$$\nf ( \\mathbf { x } , \\boldsymbol { \\ell } ) = \\mathbf { w } _ { \\boldsymbol { \\ell } } ^ { \\top } \\boldsymbol { \\Phi } ( \\mathbf { x } ) ; \\boldsymbol { \\ell } \\in [ L ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            497,
+            594,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W } = [ \\mathbf { w } _ { 1 } , \\hdots , \\mathbf { w } _ { L } ] \\in \\mathbb { R } ^ { d \\times L }$ are the weight vectors and $\\Phi : \\mathcal { D } \\mapsto \\mathbb { R } ^ { d }$ is the text vectorizer that maps $\\mathbf { x }$ to $d$ -dimensional feature vector. $\\Phi ( \\cdot )$ could be a deterministic text vectorizer, such as the bag-of-words (BOW) model or Term Frequency-Inverse Document Frequency (TFIDF) model, or a vectorizer with learnable parameters. With the recent development in deep learning, using pre-trained transformer as the text vectorizer has shown promising results in many XMC applications [12, 13, 39]. When $L$ is large, however, training and inference of OVA model without sampling would be prohibitive due to the $O ( L )$ time complexity. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            623
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To handle the extremely large output space, recent approaches partition the label space to shortlist the labels considered during training and inference. In particular, [7, 12, 13, 34, 35, 39] follow a three stage framework: partitioning, shortlisting, and ranking. First, label features are constructed to group labels into $K$ clusters $\\mathbf { C } \\in \\overline { { \\{ 0 , 1 \\} } } ^ { L \\times K }$ where $C _ { \\ell , k } = 1$ denotes that label $\\ell$ is included in the $k$ -th cluster. Then a shortlisting model is learned to match input $\\mathbf { x }$ to relevant clusters in an OVA setting: ",
+        "bbox": [
+            173,
+            628,
+            825,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1087d2dff4123e4b8a14bc5321b422e54152659042d195dc70dc2b539d9f6fee.jpg",
+        "text": "$$\ng ( \\mathbf { x } , k ) = \\hat { \\mathbf { w } } _ { k } ^ { \\top } \\Phi _ { g } ( \\mathbf { x } ) ; k \\in [ K ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            705,
+            604,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, a classification model with output size $L$ is trained on the shortlisted labels: ",
+        "bbox": [
+            174,
+            731,
+            722,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b4fb324596ee247b85e54c35d0d014802e0040a627fa54a57a065e8d700a132d.jpg",
+        "text": "$$\nf ( \\mathbf { x } , \\boldsymbol { \\ell } ) = \\mathbf { w } _ { \\boldsymbol { \\ell } } ^ { \\top } \\boldsymbol { \\Phi } ( \\mathbf { x } ) ; \\boldsymbol { \\ell } \\in S _ { g } ( \\mathbf { x } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            752,
+            604,
+            771
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $S _ { g } ( \\mathbf { x } ) \\subset [ L ]$ is the label set shortlisted by $g ( \\mathbf { x } , \\cdot )$ . In the extreme case where only one label cluster is determined to be relevant to a input $\\mathbf { x }$ , the training and inference cost on √ √ $\\mathbf { x }$ would be $\\begin{array} { r } { O ( K + \\frac { L } { K } ) } \\end{array}$ , which in the best case scenario is $O ( \\sqrt { L } )$ when $\\bar { K } = \\sqrt { L }$ . ",
+        "bbox": [
+            174,
+            777,
+            825,
+            823
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For transformer based methods, the dominant time is the evaluation of $\\Phi ( \\mathbf { x } )$ . But $K$ being too big or too small could still be problematic. Empirical results show that the model performance deteriorates when clusters are too big [8]. This is because that the signals coming from $B$ labels within the same cluster will be aggregated and not distinguishable, where $B$ is the cluster size. Therefore, $B$ cannot be too big to ensure a reasonable label resolution for fine-tuning. Also, as pointed out in [12], fine-tuning transformer models on large output spaces can be prohibitive. As a result, the label clusters need to be constructed in a way to balance the model performance and fine-tuning efficiency. In practice, both the transformer-based XMC models, such as X-Transformer and LightXML, adopt a small fixed constant as the cluster size $B$ $3 ( \\leq 1 0 0 )$ , which means that training the shortlisting model $g ( \\mathbf { x } , k )$ is still very time consuming as the number of clusters $K \\approx L / B$ . ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/46f66c6210a2f96597b951ec90d598f4c129d57734107b7a3ab7444b5fdc94a5.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of fine-tuning on XMC tasks of different label resolutions. For an XMC task with a low label resolution, fine-tuning can be fast but model performance might deteriorate due to large deviation from the original XMC task. In practice, X-Transformer and LightXML adopt a XMC task with a relatively higher label resolution to ensure reasonable model performance at the cost of longer training time. The proposed XR-Transformer leverages multi-resolution learning and model bootstrapping that achieves both fast fine-tuning and good model performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            92,
+            815,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            342,
+            825,
+            398
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Proposed Method: XR-Transformer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            416,
+            508,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As noted above, the shortlisting problem (2) is itself an XMC problem with slightly smaller output size $\\frac { L } { B }$ where $B$ is the cluster size. In XR-Transformer, we apply the same three stage framework recursively on the shortlisting problem until a reasonably small output size is reached $\\frac { L } { B _ { - } ^ { D } }$ We can therefore follow the curriculum learning scheme and fine-tune the pre-trained transformers progressively on the sub-XMC problems with increasing output space $\\Big \\{ \\frac { \\dot { \\bf \\Phi } _ { L } } { B ^ { D } } , \\frac { L } { B ^ { D - 1 } } , \\ldots \\Big \\}$ . At each fine-tuning task, the candidate label set is shortlisted by the final model at the previous task. The recursive shortlisting ensures that for any input, the number of candidate labels to include in training and inference is $O ( B )$ and therefore the total number of considered labels is $O ( B \\log _ { B } ( L ) )$ . Also, we leverage the multi-step fine-tuning and use the embedding generated at the previous task to bootstrap the non pre-trained part for the current task. We now describe the model design in detail. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            589
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical Label Tree (HLT). Recursively generating label clusters $D$ times is equivalent to building a HLT [41] of depth $D$ . We first construct label features $\\mathbf { Z } \\in \\mathbb { R } ^ { L \\times \\hat { d } }$ . This could be done by applying text vectorizers on label text or from Positive Instance Feature Aggregation (PIFA): ",
+        "bbox": [
+            173,
+            602,
+            825,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/793d0704d8770faf4c2d6912beb60080a75cc092355e5f42573af6bd887c556b.jpg",
+        "text": "$$\n\\mathbf { Z } _ { \\ell } = { \\frac { \\mathbf { v } _ { \\ell } } { \\| \\mathbf { v } _ { \\ell } \\| } } ; { \\mathrm { w h e r e ~ } } \\mathbf { v } _ { \\ell } = \\sum _ { i : y _ { i , \\ell } = 1 } \\Phi ( \\mathbf { x } _ { i } ) , \\forall \\ell \\in [ L ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            651,
+            661,
+            688
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\Phi : \\mathcal { D } \\mapsto \\mathbb { R } ^ { d }$ it the text vectorizer. Then we follow similar procedures as [8] and [13] and use balanced $\\mathbf { k }$ -means ( $k = B ,$ ) to recursively partition label sets and generate the HLT in a top-down fashion. The HLT is represented with a series of indexing matrices $\\{ \\mathbf { C } ^ { ( t ) } \\} _ { t = 1 } ^ { D }$ )}Dt=1, such that $\\mathbf { C } ^ { ( t ) } \\in \\{ 0 , 1 \\} ^ { K _ { t } \\times K _ { t - 1 } }$ where $K _ { 0 } = 1$ and $K _ { D } = L$ . Equivalently, once $\\mathbf { C } ^ { ( D ) }$ is constructed, the HLT can be built from bottom up through joining $B$ adjacent clusters together. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Multi-resolution Output Space. Multi-resolution learning has been explored in different contexts such as computer vision [14, 42]. For instance, using an output scheme with coarse-to-fine resolutions results in better image quality for generative adversarial networks [15, 16]. As an another example in meta learning, [43] learns multiclass models via auxiliary meta classes by collapsing existing classes. Nevertheless, multi-resolution learning has not been well-explored in the XMC literature. In XR-Transformer, we leverage the label hierarchy defined by the HLT and train the transformer model on multi-resolution objectives. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The XMC task can be viewed as generating an 1-D image $\\mathbf { y } \\in \\{ 0 , 1 \\} ^ { L }$ with binary values based on input text x. Just like a coarsified image could be obtained by a max or mean pooling of nearby pixels, the coarse label vector can be obtained by max-pooling of labels which are nearby in the label feature space. Once the HLT is constructed using label features, the true labels at layer $\\mathbf { \\bar { Y } } ^ { ( t ) } \\in \\{ 0 , 1 \\} ^ { N \\times K _ { t } }$ can be determined by the true labels of the child clusters at $t + 1$ through a max-pooling like operation: ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            135
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0a2ffa103a53651fbc50486bf9aa594e067c9227c3816fec363a06616ce659b.jpg",
+        "text": "$$\n\\mathbf { Y } ^ { ( t ) } = \\mathrm { b i n a r i z e } ( \\mathbf { Y } ^ { ( t + 1 ) } \\mathbf { C } ^ { ( t + 1 ) } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            137,
+            607,
+            156
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and Y (D)i,\\` $Y _ { i , \\ell } ^ { ( D ) } = y _ { i , \\ell }$ is the original label matrix. This forms a series of learning signals with coarse-to-fine resolution and can be used to generate learning tasks with easy-to-hard objectives. ",
+        "bbox": [
+            171,
+            164,
+            823,
+            194
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Direct use of the binarized $\\mathbf { Y } ^ { ( t ) } \\in \\{ 0 , 1 \\} ^ { N \\times K _ { t } }$ in Eq (5) results in information loss when merging several positive labels into one cluster. Ideally, a cluster containing several positive children is more relevant than a cluster with only one positive child. To add this lower level information to higher level learning objectives, we introduce the relevance matrix ${ \\bf R } ^ { ( t ) } \\in \\mathbb { R } _ { \\pm } ^ { N \\times K _ { t } }$ for layer $t$ of the XMC sub-problem where $R _ { i , \\ell }$ defines the non-negative important weight for ith instance to \\`th cluster. Different from cost-sensitive learning [44] for MLC (CSMLC) setting [45–47] where there is only one cost matrix explicitly derived by evaluation metrics such as F1 score, in XR-Transformer, we consider the usage of cost-sensitive learning where the relevance matrices are recursively induced by the HLT structure. Specifically, given an HLT, we recursively construct relevance matrices for $t = 1 , \\ldots , D$ : ",
+        "bbox": [
+            173,
+            199,
+            826,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc071d9b3c5838055558c9f063021a0b3d7b6f31b1ddd6d0da5cbb2d1fbbd50a.jpg",
+        "text": "$$\n\\mathbf { R } ^ { ( t ) } = \\mathbf { R } ^ { ( t + 1 ) } \\mathbf { C } ^ { ( t + 1 ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            343,
+            575,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and $\\mathbf { R } ^ { ( D ) } = \\mathbf { Y } ^ { ( D ) }$ . Motivated by [48], we adopts the row-wise $\\ell _ { 1 }$ normalized relevance matrix: ",
+        "bbox": [
+            171,
+            368,
+            799,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6eb0b3cbcbb14a256454777e3d919411d7783a239b15d68239dbb2c8942b5886.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { R } _ { i , j } ^ { ( t ) } = \\left\\{ \\begin{array} { l l } { \\frac { R _ { i , j } ^ { ( t ) } } { \\| \\mathbf { R } _ { i } ^ { ( t ) } \\| _ { 1 } } } & { \\mathrm { ~ i f ~ } Y _ { i , j } ^ { ( t ) } = 1 , } \\\\ { \\alpha } & { \\mathrm { o t h e r w i s e } , } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            386,
+            604,
+            430
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ is the hyper parameter to balance positive and negative weights. ",
+        "bbox": [
+            174,
+            433,
+            648,
+            448
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Label Shortlisting. During training, XR-Transformer only focuses on discriminating the labels or clusters that have high chance of being positive. A necessary condition for a label at layer $t$ to be positive is that its parent label at level $t - 1$ is positive. Therefore, an intuitive approach would be to only train on the output space shortlisted by positive clusters of the parent layer. However, in practice we found this approach sometimes leads to sub-optimal result during inference with beam search. As an effort to balance explore and exploit, we further include the top- $k$ relevant clusters determined by the model learned on the parent layer to mimic the beam search during inference. Thus at layer $t$ , the labels considered during training are shortlisted by the parent layer $t - 1$ : ",
+        "bbox": [
+            173,
+            460,
+            826,
+            573
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a624c5a38a9d7b0ec381a0071e3f6f991bbe18f93f93895567a4766055f9cf84.jpg",
+        "text": "$$\n\\begin{array} { r } { \\begin{array} { r l } & { \\mathbf { P } ^ { ( t - 1 ) } = \\mathrm { T o p } ( \\mathbf { W } ^ { ( t - 1 ) \\top } \\Phi ( \\mathbf { X } , \\Theta ^ { ( t - 1 ) } ) , k ) , } \\\\ & { \\mathbf { M } ^ { ( t ) } = \\mathrm { b i n a r i z e } ( \\mathbf { P } ^ { ( t - 1 ) } \\mathbf { C } ^ { ( t ) \\top } ) + \\mathrm { b i n a r i z e } ( \\mathbf { Y } ^ { ( t - 1 ) } \\mathbf { C } ^ { ( t ) \\top } ) , } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            574,
+            696,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the $\\mathrm { T o p } ( \\cdot , k )$ operator zeros out elements in a matrix except the top- $k$ largest values in each row. For each instance $\\mathbf { x } _ { i }$ , only non-zero indices of $\\mathbf { M } _ { i }$ will be included into the training objective. We can therefore define a series of learning objectives for level $t \\in \\{ 1 , 2 , \\dots , D \\}$ as: ",
+        "bbox": [
+            176,
+            618,
+            826,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d7908ec90c0db1ac7d7c837fae6b9c8a5d62468ee9e32c967edcf82738b29263.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\mathbf { W } ^ { ( t ) } , \\Theta } \\sum _ { i = 1 } ^ { N } \\sum _ { \\ell : \\mathbf { M } _ { i , \\ell } ^ { ( t ) } \\neq 0 } \\hat { R } _ { i , \\ell } ^ { ( t ) } \\mathcal { L } ( Y _ { i , \\ell } ^ { ( t ) } , \\mathbf { W } _ { \\ell } ^ { ( t ) \\top } \\Phi ( \\mathbf { x } _ { i } , \\Theta ) ) + \\lambda \\| \\mathbf { W } ^ { ( t ) } \\| ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            662,
+            707,
+            714
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L }$ is a point-wise loss such as hinge loss, squared hinge loss or BCE loss, $\\mathbf { W } ^ { ( t ) }$ , $\\Theta$ are the model weights to be learned. ",
+        "bbox": [
+            174,
+            718,
+            823,
+            747
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Text Representation. Most previous works on XMC construct text feature representation in one of two ways: statistical feature representations and semantic feature representations. Although the latter, in particular transformer models, have shown promising results on various NLP benchmarks, the self-attention mechanism makes transformers unscalable w.r.t. sequence length. To ensure efficiency, input texts are usually truncated [12, 13] which result in loss of information. On the other hand, the statistical features, such as TFIDF, are fast to construct with the whole input taken into consideration. In XR-Transformer, we use a combination of these two feature representations and each component is a complement of lost information for the other one: ",
+        "bbox": [
+            173,
+            760,
+            826,
+            872
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/05ac6034ddd335c50ae5f16399b0065b6d503325440b34d2ab3000af2f12f74f.jpg",
+        "text": "$$\n\\Phi _ { c a t } ( \\mathbf { x } , \\Theta ) : = \\Big [ \\frac { \\Phi _ { t f i d f } ( \\mathbf { x } ) } { \\lVert \\Phi _ { t f i d f } ( \\mathbf { x } ) \\rVert } , \\frac { \\Phi _ { d n n } ( \\mathbf { x } , \\Theta ) } { \\lVert \\Phi _ { d n n } ( \\mathbf { x } , \\Theta ) \\rVert } \\Big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            876,
+            653,
+            910
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dddbd9097119a796c1bdf883385a003dacba4f9c20aa8bd6390fd617231c9b94.jpg",
+        "text": "$$\n\\perp \\theta ^ { * }  \\theta\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            208,
+            279,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0759b5c554a6a5a134f4dc0e1ad2705de7a164662e7e9d611850801776f923a3.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad \\lfloor \\mathbf { \\delta v } ^ { \\star } \\gets \\boldsymbol { \\sigma } } \\\\ & { \\mathbf { W } ^ { * } \\gets \\operatorname * { a r g m i n } _ { \\mathbf { W } } \\sum _ { i = 1 } ^ { N } \\sum _ { \\ell = 1 } ^ { m } \\hat { R } _ { i , \\ell } ^ { ( t ) } \\mathcal { L } ( Y _ { i , \\ell } , \\mathbf { W } _ { \\ell } ^ { \\top } \\Phi _ { c a t } ( \\mathbf { x } _ { i } , \\boldsymbol { \\Theta } ) ) + \\lambda \\| \\mathbf { W } \\| ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            217,
+            673,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d36239b9437014d8da9642e0ec81e8d502ef03319011c4fc6ce3a8bab7e2e8f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad \\bigcup \\mathbf { \\phi } \\in \\mathbf { \\phi }  \\theta } \\\\ & { \\mathbf { W } ^ { * }  \\operatorname { a r g m i n } _ { \\mathbf { W } } \\sum _ { i = 1 } ^ { N } \\sum _ { \\ell : \\mathbf { M } _ { i , \\ell } \\neq 0 } \\hat { R } _ { i , \\ell } ^ { ( t ) } \\mathcal { L } ( Y _ { i , \\ell } , \\mathbf { W } _ { \\ell } ^ { \\top } \\Phi _ { c a t } ( \\mathbf { x } _ { i } , \\theta ^ { * } ) ) + \\lambda \\Vert \\mathbf { W } \\Vert ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            328,
+            705,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: XR-Transformer training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            433,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Input :X, $\\mathbf { Y }$ , pre-trained transformer $\\Phi _ { d n n } ( \\cdot , \\pmb { \\theta } _ { 0 } )$   \n$\\hat { \\mathbf { Z } } _ { \\ell } = \\mathbf { v } _ { \\ell } / \\| \\mathbf { v } _ { \\ell } \\|$ ; where $\\begin{array} { r } { \\mathbf { v } _ { \\ell } = \\sum _ { i : y _ { i , \\ell } = 1 } \\Phi _ { t f i d f } ( \\mathbf { x } _ { i } ) , \\forall \\ell \\in [ L ] } \\end{array}$   \n$\\{ \\hat { \\mathbf { C } } ^ { ( t ) } \\} _ { t = 1 } ^ { \\hat { D } }  \\mathbf { k }$ -means-clustering $( \\hat { \\mathbf { Z } } )$   \nGenerate label hierarchy {Yˆ (t)}Dˆt= using 5   \n${ \\pmb \\theta } ^ { * } = { \\pmb \\theta } _ { 0 }$ , ${ \\bf P } = N o n e$   \nfor $t$ in $1 , 2 , 3 , \\cdots , \\hat { D } $ do $\\hat { \\mathbf { W } } , \\pmb { \\theta } ^ { * } \\gets$ Iterative_Learn(X, Yˆ (t), Cˆ (t), θ∗, P) $\\mathbf { P } \\gets \\mathrm { T o p } ( \\hat { \\mathbf { W } } ^ { \\top } \\Phi _ { c a t } ( \\mathbf { X } , \\pmb { \\theta } ^ { * } ) , k )$   \n$\\mathbf { Z } _ { \\ell } = \\mathbf { v } _ { \\ell } / \\| \\mathbf { v } _ { \\ell } \\|$ ; where $\\begin{array} { r } { \\mathbf { v } _ { \\ell } = \\sum _ { i : y _ { i , \\ell } = 1 } \\Phi _ { c a t } ( \\mathbf { x } _ { i } ) , \\forall \\ell \\in [ L ] } \\end{array}$   \n$\\{ \\mathbf { C } ^ { ( t ) } \\} _ { t = 1 } ^ { D }  \\mathbf { k }$ -means-clustering $( \\mathbf { Z } )$   \nGenerate label hierarchy $\\{ \\mathbf { Y } ^ { ( t ) } \\} _ { t = 1 } ^ { \\hat { D } }$ using 5   \nFix $\\pmb { \\theta } ^ { * }$ , ${ \\bf P } = N o n e$   \nfor $t$ in $1 , 2 , 3 , \\cdots , D$ do   \nR $\\begin{array} { r l } & { \\mathbf { W } ^ { ( t ) } , \\ldots  \\mathrm { I t e r a t i v e \\_ L e a r n } ( \\mathbf { X } , \\mathbf { Y } ^ { ( t ) } , \\mathbf { C } ^ { ( t ) } , \\pmb { \\theta } ^ { * } , \\mathbf { P } ) } \\\\ & { \\mathbf { P }  \\mathrm { T o p } ( \\mathbf { W } ^ { ( t ) \\top } \\Phi _ { c a t } ( \\mathbf { X } , \\pmb { \\theta } ^ { * } ) , k ) } \\\\ & { \\mathbf { e t u r n } : \\Phi _ { c a t } ( \\cdot , \\pmb { \\theta } ^ { * } ) , \\{ \\mathbf { C } ^ { ( t ) } \\} _ { t = 1 } ^ { D } , \\{ \\mathbf { W } ^ { ( t ) } \\} _ { t = 1 } ^ { D } } \\end{array}$ ",
+        "bbox": [
+            173,
+            429,
+            565,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\Phi _ { d n n } ( \\cdot , \\Theta )$ is the transformer parametrized by $\\Theta$ . Once the text representation is constructed, predictions can be made by simply applying a linear projection on top of the text representation through (1). ",
+        "bbox": [
+            176,
+            727,
+            823,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training with bootstrapping. The training of XR-Transformer consists of three steps. At first, a preliminary HLT is constructed using raw statistical features. Then a pre-trained transformer model is fine-tuned recursively from low resolution output to high resolution. At each layer $t$ , fine-tuning objective (9) is optimized with initialization $\\Theta = \\pmb \\theta ^ { ( t - 1 ) * }$ the best transformer weights of layer $t - 1$ ${ \\pmb \\theta } ^ { ( 0 ) * }$ denotes the pre-trained transformer weights. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            862
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Unlike the transformer warmed-up with pre-trained weights, the projection weights $\\mathbf { W } ^ { ( t ) }$ is trained from scratch without good initialization. At the beginning of fine-tuning, gradient flow through these cold-start (usually randomly initialized) weights will usually worsen the pre-trained components. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We leverage the recursive learning structure to tackle this issue by model bootstrapping. Concretely, $\\mathbf { W } ^ { ( t ) }$ is initialized as: ",
+        "bbox": [
+            171,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7766ae7b1871b0d6d494fe0e44767e9c15a8e55536f98597301597eb46a87368.jpg",
+        "text": "$$\n\\mathbf { W } _ { i n i t } ^ { ( t ) } : = \\underset { \\mathbf { W } ^ { ( t ) } } { \\operatorname { a r g m i n } } \\sum _ { i = 1 } ^ { N } \\sum _ { \\ell : \\mathbf { M } _ { i , \\ell } ^ { ( t ) } \\neq 0 } \\hat { R } _ { i , \\ell } ^ { ( t ) } \\mathcal { L } ( Y _ { i , \\ell } ^ { ( t ) } , \\mathbf { W } _ { \\ell } ^ { ( t ) \\top } \\Phi _ { d n n } ( \\mathbf { x } _ { i } , \\pmb { \\theta } ^ { ( t - 1 ) * } ) ) + \\lambda \\| \\mathbf { W } ^ { ( t ) } \\| ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            207,
+            121,
+            761,
+            171
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In practice, (11) is fast to compute since the semantic text feature for the previous layer $\\Phi _ { c a t } ( \\mathbf { X } , \\pmb { \\theta } ^ { ( t - 1 ) * } )$ is already computed and thus (11) can be solved very quickly on CPUs with a variety of parallel linear solvers, such as LIBLINEAR [49]. ",
+        "bbox": [
+            174,
+            175,
+            823,
+            219
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Once the fine-tuning is complete, the refined HLT is constructed with the text representation that combines statistical text feature and fine-tuned semantic text embeddings. Then the ranking models are trained on top of the combined text features for the final prediction. The detailed training procedure is described in Algorithm 1 and 2. ",
+        "bbox": [
+            174,
+            226,
+            825,
+            281
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Inference. The inference cost of XR-Transformer consists mainly of two parts: cost to compute transformer embedding and to retrieve relevant labels through beam search. Therefore, the inference time complexity is $O ( T _ { d n n } + k d \\log ( L ) )$ , where $k$ is the beam size, $d$ is the concatenated feature dimension and $T _ { d n n }$ is the time to compute $\\Phi _ { d n n } ( \\mathbf { x } )$ for a given input. Note that even the inference is done with beam search through the refined HLT, the transformer text embedding only need to be computed once per instance. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Connections with other tree based methods. Although methods such as AttentionXML [8] also train on supervisions induced by label trees, the final model is a chain of sub-models which each on is learned on single-resolution. In particular, given a hierarchical label tree with depth $D$ , AttentionXML will train $D$ different text encoders on each layer of the tree where as XR-Transformer trains the same transformer encoder progressively on all layers of the tree. This difference leads to a longer inference time for AttentionXML than XR-Transformer since multiple text encoders need to be queried during inference, as shown in the comparison in the inference time in Appendix A.4.2. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            491
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            508,
+            385,
+            526
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate XR-Transformer on 6 public XMC benchmarking datasets: Eurlex-4K, Wiki10-31K, AmazonCat-13K, Wiki-500K, Amazon-670K, Amazon-3M. Data statistics are given in Table 1. For fair comparison, we use the same raw text input, sparse feature representations and same train-test split as AttentionXML [8] and other latest works [12, 13]. The evaluation metric is Precision $@ \\mathbf { k }$ $( \\mathrm { P } @ \\mathrm { k } )$ , which is widely-used in XMC literature [3, 8, 12, 13, 18, 28]. The results of Propensity-score Precision $@ \\mathbf { k }$ $( { \\mathrm { P S P } } @ \\mathbf { k } )$ are defer to Appendix A.4.3, which focus more on tail labels’ performance. ",
+        "bbox": [
+            173,
+            539,
+            826,
+            623
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/0772d7a7a39801db959dbcad4c5945786d23b4f91b4062fc61cf4476df412aa0.jpg",
+        "table_caption": [
+            "Table 1: Data statistics. $N _ { t r a i n } , N _ { t e s t }$ refer to the number of instances in the training and test sets, respectively. $L$ : the number of labels. $\\bar { L }$ : the average number of positive labels per instance. $\\bar { n }$ : average number of instances per label. $d _ { t f i d f }$ : the sparse feature dimension of $\\bar { \\Phi } _ { t f i d f } ( \\cdot )$ . These six publicly available benchmark datasets, including the sparse TF-IDF features are downloaded from https://github.com/yourh/AttentionXML which are the same as AttentionXML [8] XTransformer [12] and LightXML [13] for fair comparison. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Ntrain</td><td>Ntest</td><td>L</td><td>L</td><td>n</td><td>dtfidf</td></tr><tr><td>Eurlex-4K</td><td>15,449</td><td>3,865</td><td>3,956</td><td>5.30</td><td>20.79</td><td>186,104</td></tr><tr><td>Wiki10-31K</td><td>14,146</td><td>6,616</td><td>30.938</td><td>18.64</td><td>8.52</td><td>101,938</td></tr><tr><td>AmazonCat-13K</td><td>1,186,239</td><td>306,782</td><td>13,330</td><td>5.04</td><td>448.57</td><td>203,882</td></tr><tr><td>Wiki-500K</td><td>1,779,881</td><td>769,421</td><td>501,070</td><td>4.75</td><td>16.86</td><td>2,381,304</td></tr><tr><td>Amazon-670K</td><td>490,449</td><td>153,025</td><td>670.091</td><td>5.45</td><td>3.99</td><td>135,909</td></tr><tr><td>Amazon-3M</td><td>1,717,899</td><td>742,507</td><td>2,812,281</td><td>36.04</td><td>22.02</td><td>337,067</td></tr></table>",
+        "bbox": [
+            176,
+            726,
+            821,
+            848
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baseline Methods. We compare XR-Transformer with state-of-the-art (SOTA) XMC methods: AnnexML [28], DiSMEC [18], PfastreXML [41], Parabel [3], eXtremeText [24], Bonsai [50], XMLCNN [33], XR-Linear [7], AttentionXML [8], X-Transformer [12] and LightXML [13]. We obtain most baseline results from [8, Table 3] and [7, Table 3] except for the latest deep learning based algorithms [8, 12, 13]. To have fair comparison on training time, we use the same hardware (i.e., AWS p3.16xlarge) and the same inputs (i.e., raw text, vectorized features, data split) to obtain the results of AttentionXML, X-Transformer and LightXML. The hyper-parameter of XR-Transformer and more empirical results are included in Appendix A.3. ",
+        "bbox": [
+            173,
+            869,
+            826,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2795a38d1ddfe1301c5e182e240ce1fa292a865a8ed9fa203546f2db14c1d9ac.jpg",
+        "table_caption": [
+            "Table 2: Comparison of XR-Transformer with recent XMC methods on six public datasets. Results with a trailing reference are taken from [8, Table 3] and [7, Table 3]. We obtain the results of AttentionXML∗, LightXML∗, X-Transformer∗ and XR-Transformer∗ on the same vectorized feature matrix provided in [8]. Due to GPU memory constraint, LightXML is not able to run on Amazon-3M. The $\\mathrm { P S P } @ \\mathrm { k }$ results are available in Appendix A.4.3. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>P@1 P@3</td><td>P@5</td><td>P@1</td><td>P@3</td><td>P@5</td><td>P@1</td><td>P@3</td><td>P@5</td></tr><tr><td></td><td colspan=\"6\">Eurlex-4K Wiki10-31K</td><td>AmazonCat-13K</td><td></td></tr><tr><td>AnnexML [28] DiSMEC[18]</td><td>79.66 83.21</td><td>64.94 70.39</td><td>53.52 58.73</td><td>86.46 84.13 83.57</td><td>74.28 74.72 68.61</td><td>64.20 65.94 59.10</td><td>93.54 78.36 93.81 79.08</td><td>63.30 64.06</td></tr><tr><td>PfastreXML [41] Parabel [3]</td><td>73.14 82.12</td><td>60.16 68.91</td><td>50.54 57.89</td><td>84.19</td><td>72.46 63.37</td><td>91.75 93.02</td><td>77.97 79.14</td><td>63.68 64.51</td></tr><tr><td>eXtremeText [24]</td><td>79.17</td><td>66.80</td><td>56.09</td><td>83.66 73.28</td><td>64.51</td><td>92.50</td><td>78.12</td><td>63.51</td></tr><tr><td>Bonsai [50]</td><td>82.30</td><td>69.55</td><td>58.35</td><td>84.52 73.76</td><td>64.69</td><td>92.98</td><td></td><td>64.46</td></tr><tr><td>XML-CNN [33]</td><td>75.32</td><td>60.14</td><td>49.21</td><td>81.41 66.23</td><td>56.11</td><td></td><td>79.13</td><td></td></tr><tr><td>XR-Linear [7]</td><td>84.14</td><td>72.05 60.67</td><td>85.75</td><td>75.79</td><td>66.69</td><td>93.26</td><td>77.06</td><td>61.40</td></tr><tr><td>AttentionXML*</td><td></td><td></td><td></td><td></td><td></td><td>94.64</td><td>79.98</td><td>64.79</td></tr><tr><td>X-Transformer*</td><td>86.93</td><td>74.12</td><td>62.16</td><td>87.34</td><td>78.18</td><td>69.07 95.84</td><td>82.39</td><td>67.32</td></tr><tr><td></td><td>87.61</td><td>75.39 75.95</td><td>63.05 63.45</td><td>88.26</td><td>78.51</td><td>69.68 96.48</td><td>83.41</td><td>68.19</td></tr><tr><td>LightXML*</td><td>87.15</td><td></td><td></td><td>89.67 79.06</td><td>69.87</td><td>96.77</td><td>83.98</td><td>68.63</td></tr><tr><td>XR-Transformer*</td><td>88.41 75.97</td><td>63.18</td><td>88.69</td><td>80.17</td><td>70.91</td><td>96.79</td><td>83.66</td><td>68.04</td></tr><tr><td>AnnexML [28]</td><td>Wiki-500K</td><td></td><td></td><td></td><td>Amazon-670K</td><td></td><td>Amazon-3M</td><td></td></tr><tr><td>DiSMEC[18]</td><td>64.22 70.21</td><td>43.15 50.57</td><td>32.79 39.68</td><td>42.09 44.78 36.84</td><td>36.61 39.72</td><td>32.75 36.17</td><td>49.30 45.55 47.34 44.96</td><td>43.11 42.80</td></tr><tr><td>PfastreXML [41] Parabel [3]</td><td>56.25</td><td>37.32 49.57</td><td>28.16</td><td>34.23</td><td>32.09</td><td>43.83</td><td>41.81</td><td>40.09</td></tr><tr><td>eXtremeText [24]</td><td>68.70</td><td></td><td>38.64</td><td>44.91 39.77</td><td>35.98</td><td>47.42</td><td>44.66</td><td>42.55</td></tr><tr><td></td><td>65.17</td><td>46.32</td><td>36.15</td><td>42.54 37.93</td><td>34.63</td><td>42.20</td><td>39.28</td><td>37.24</td></tr><tr><td>Bonsai [50]</td><td>69.26</td><td>49.80</td><td>38.83</td><td>45.58 40.39</td><td>36.60</td><td>48.45</td><td>45.65</td><td>43.49</td></tr><tr><td>XML-CNN [33]</td><td>1</td><td>1</td><td>1</td><td>33.41</td><td>30.00 27.42</td><td>1</td><td>-</td><td>1</td></tr><tr><td>XR-Linear [7]</td><td>65.59</td><td>46.72</td><td>36.46</td><td>43.38</td><td>38.40 34.77</td><td>47.40</td><td>44.15</td><td>41.87</td></tr><tr><td>AttentionXML*</td><td>76.74</td><td>58.18</td><td>45.95</td><td>47.68</td><td></td><td>50.86</td><td></td><td></td></tr><tr><td>X-Transformer*</td><td>77.09</td><td>57.51</td><td>45.28</td><td>48.07</td><td>42.70</td><td>38.99</td><td>48.00</td><td>45.82</td></tr><tr><td></td><td></td><td></td><td></td><td>42.96</td><td>39.12</td><td>51.20</td><td>47.81</td><td>45.07</td></tr><tr><td>LightXML* XR-Transformer*</td><td>77.89 79.40</td><td>58.98 59.02</td><td>45.71 46.25</td><td>49.32 44.17 50.11 44.56</td><td>40.25 40.64</td><td>= 54.20</td><td>= 50.81</td><td>48.26</td></tr></table>",
+        "bbox": [
+            176,
+            166,
+            823,
+            578
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0b60d47264d16986f79138a29c1cb39f639dbef44d81775aa15dab1e782ecec5.jpg",
+        "table_caption": [
+            "Table 3: Comparing training time (in hours) of DNN-based methods that produce the SOTA results in Table 2. The number following the model indicates the number of ensemble models used. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>AttentionXML-3</td><td>X-Transformer-9</td><td>LightXML-3</td><td>XR-Transformer-3</td></tr><tr><td>Eurlex-4K</td><td>0.9</td><td>7.5</td><td>16.9</td><td>0.8</td></tr><tr><td>Wiki10-31K</td><td>1.5</td><td>14.1</td><td>26.9</td><td>1.5</td></tr><tr><td>AmazonCat-13K</td><td>24.3</td><td>147.6</td><td>310.6</td><td>13.2</td></tr><tr><td>Wiki-500K</td><td>37.6</td><td>557.1</td><td>271.3</td><td>38.0</td></tr><tr><td>Amazon-670K</td><td>24.2</td><td>514.8</td><td>159.0</td><td>10.5</td></tr><tr><td>Amazon-3M</td><td>54.8</td><td>542.0</td><td>1</td><td>29.3</td></tr></table>",
+        "bbox": [
+            176,
+            632,
+            821,
+            737
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            767,
+            825,
+            837
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Model Performance. The comparisons of Precision $@ \\mathbf { k }$ $( \\mathrm { P } @ \\mathrm { k } )$ and training time are shown in Table 2 and Table 8, respectively. The proposed XR-Transformer follows AttentionXML and LightXML to use an ensemble of 3 models, while X-Transformer uses an ensemble of 9 models [12]. More details about the ensemble setting can be found in Appendix A.3. The proposed XR-Transformer framework achieves new SOTA results in 14 out of 18 evaluation columns (combination of datasets and $\\mathrm { P } @ \\mathrm { k } ,$ ), and outperforms competitive methods on the large datasets. Next, we show the training time of XR-Transformer is significantly less than other DNN-based models. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d595bdb193ef1fad339bfd123d22816ab0553f72b8dc824894f4d161c6730334.jpg",
+        "table_caption": [
+            "Table 4: Single model comparison of DNN based XMC models. Training time on p3.16xlarge with 8 Nvidia V100 GPUs whereas time on singl $T _ { t r a i n } ^ { 8 }$ are reported ia V100 GPU entionXML, X-Transformer and XR-Transformer,is reported for LightXML and XR-Transformer. $T _ { t r a i n } ^ { 1 }$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Method</td><td>P@1</td><td>P@3</td><td>P@5</td><td></td><td></td></tr><tr><td rowspan=\"4\">Wiki10-31K</td><td>AttentionXML-1</td><td>87.1</td><td>77.8</td><td>68.8</td><td>1</td><td>0.5</td></tr><tr><td>X-Transformer-1</td><td>87.5</td><td>77.2</td><td>67.1</td><td>-</td><td>3.5</td></tr><tr><td>LightXML-1</td><td>87.8</td><td>77.3</td><td>68.0</td><td>6.7</td><td>-</td></tr><tr><td>XR-Transformer-1</td><td>88.0</td><td>78.7</td><td>69.1</td><td>1.3</td><td>0.5</td></tr><tr><td rowspan=\"4\">Wiki-500K</td><td>AttentionXML-1</td><td>75.1</td><td>56.5</td><td>44.4</td><td>-</td><td>12.5</td></tr><tr><td>X-Transformer-1</td><td>44.8</td><td>40.1</td><td>34.6</td><td>-</td><td>56.0</td></tr><tr><td>LightXML-1</td><td>76.3</td><td>57.3</td><td>44.2</td><td>89.6</td><td>1</td></tr><tr><td>XR-Transformer-1</td><td>78.1</td><td>57.6</td><td>45.0</td><td>29.2</td><td>12.5</td></tr><tr><td rowspan=\"4\">Amazon-670K</td><td>AttentionXML-1</td><td>45.7</td><td>40.7</td><td>36.9</td><td>-</td><td>8.1</td></tr><tr><td>X-Transformer-1</td><td>44.8</td><td>40.1</td><td>34.6</td><td>、</td><td>56.0</td></tr><tr><td>LightXML-1</td><td>47.3</td><td>42.2</td><td>38.5</td><td>53.0</td><td>-</td></tr><tr><td>XR-Transformer-1</td><td>49.1</td><td>43.8</td><td>40.0</td><td>8.1</td><td>3.4</td></tr></table>",
+        "bbox": [
+            254,
+            138,
+            738,
+            316
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            345,
+            823,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Training Cost. Table 8 shows the training time for these DNN-based models. To have fair comparison, all the experiments are conducted with float32 precision on AWS p3.16xlarge instance with 8 Nvidia V100 GPUs except for LightXML, which was run on single V100 GPU since multi-GPU training is not implemented. XR-Transformer consumes significantly less training time compared with other transformer based models and the shallow BiLSTM model AttentionXML. On Amazon3M, XR-Transformer has $2 0 x$ speedup over X-Transformer while achieving even better $\\mathrm { P @ { k } }$ . Finally, in table 4, we compare XR-Transformer with LightXML under the single model setup (no ensemble), where XR-Transformer still consistently outperforms LightXML in $\\mathbf { P } @ \\mathbf { k }$ and training time. ",
+        "bbox": [
+            173,
+            405,
+            826,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/858a53d365f0bdf078ae194e7e819d64eb47489e4a776e30f1688906827aa0e7.jpg",
+        "table_caption": [
+            "Table 5: Comparing XR-Transformer with Pre-Trained and word2vec embeddings concatenated with TF-IDF features. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>P@1 P@3</td><td>P@5</td><td>P@1</td><td>P@3</td><td>P@5</td><td>P@1</td><td>P@3</td><td>P@5</td></tr><tr><td></td><td colspan=\"6\">Eurlex-4K</td><td>AmazonCat-13K</td><td></td></tr><tr><td>TF-IDF</td><td>84.14 72.05</td><td>60.97</td><td>85.75</td><td>75.79</td><td>66.69</td><td>94.64</td><td>79.98</td><td>64.79</td></tr><tr><td>word2vec +TF-IDF</td><td>84.35 71.27</td><td>59.10</td><td>86.11</td><td>76.92</td><td>66.45</td><td>94.53</td><td>79.44</td><td>63.94</td></tr><tr><td>Pre-Trained +TF-IDF</td><td>84.92 71.40</td><td>59.36</td><td>85.78</td><td>78.30</td><td>68.33</td><td>95.05</td><td>80.12</td><td>64.53</td></tr><tr><td>XR-Transformer</td><td>88.41 75.97</td><td>63.18</td><td>88.69</td><td>80.17</td><td>70.91</td><td>96.79</td><td>83.66</td><td>68.04</td></tr><tr><td></td><td colspan=\"6\">Wiki-500K Amazon-670K</td><td>Amazon-3M</td><td></td></tr><tr><td>TF-IDF</td><td>65.59</td><td>46.72 36.46</td><td>43.38</td><td>38.40</td><td>34.77</td><td>47.40</td><td>44.15</td><td>41.87</td></tr><tr><td>word2vec +TF-IDF</td><td>68.21</td><td>48.16 37.54</td><td>44.04</td><td>39.07</td><td>35.35</td><td>47.51</td><td>44.49</td><td>42.19</td></tr><tr><td>Pre-Trained +TF-IDF</td><td>70.18</td><td>49.82 38.75</td><td>44.55</td><td>38.91</td><td>34.77</td><td>49.66</td><td>46.41</td><td>43.96</td></tr><tr><td>XR-Transformer</td><td>79.40</td><td>59.02 46.25</td><td>50.11</td><td>44.56</td><td>40.64</td><td>54.20</td><td>50.81</td><td>48.26</td></tr></table>",
+        "bbox": [
+            207,
+            568,
+            787,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison of Different Semantic Embeddings. To provide more empirical justifications, that the improvement in performance comes from better semantic embedding rather than the introducing of TF-IDF features, we further tested models using Pre-Trained Transformer and word2vec embeddings concatenated with the same TF-IDF features. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 5 summarizes the performance of these models on all 6 datasets. In particular, word2vec is using token embedding from word2vec-google-news-300 and for Pre-Trained we use the same setting as XR-Transformer (3-model ensemble). On large datasets such as Wiki-500K/Amazon670K/Amazon-3M, Pre-Trained $+ \\mathrm { T F }$ -IDF has marginal improvement compared to the baseline TF-IDF features. Nevertheless, our proposed XR-Transformer still enjoy significant gain compared to Pre-Trained $+ \\mathrm { T F }$ -IDF. This suggests the major improvement is from learning more powerful neural semantic embeddings, rather than the use of TF-IDF. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of Cost-Sensitive Learning. In Table 6, we analyze the effect of cost sensitive learning on four XMC datasets with the largest output spaces. On most datasets, cost sensitive learning via aggregated labels yields better performance than those without. We also show that cost-sensitive learning is not only beneficial to XR-Transformer, but also useful to its linear counterpart XRLinear [7]. See Appendix A.4.1 for more results. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/e9f29c7df33ad81e9aabae342361c3a0ab104fddb72155d78c9fc074d04a64e7.jpg",
+        "table_caption": [
+            "Table 6: Ablation of cost-sensitive learning on the single XR-Transformer model with or without Cost Sensitive (CS). Precision $\\boldsymbol { \\ @ 1 , 3 , 5 } \\ : \\mathrm { P } ( \\boldsymbol { \\ @ } \\mathrm { k } )$ and Recall $^ { ( a ) 1 , 3 , 5 }$ $( \\mathbb { R } ^ { \\circledcirc \\mathrm { k } ) }$ are reported. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Method</td><td>P@1</td><td>P@3</td><td>P@5</td><td>R@1</td><td>R@3</td><td>R@5</td></tr><tr><td>Wiki10-31K</td><td>XR-Transformer-1(w/o CS) XR-Transformer-1</td><td>86.8 88.0</td><td>77.6 78.7</td><td>68.8 69.1</td><td>5.2 5.3</td><td>13.6 13.8</td><td>19.8 19.9</td></tr><tr><td>Wiki-500K</td><td>XR-Transformer-1(w/o CS) XR-Transformer-1</td><td>77.6 78.1</td><td>57.4 57.6</td><td>44.9 45.0</td><td>25.8 26.1</td><td>48.1 48.5</td><td>57.8 58.1</td></tr><tr><td>Amazon-670K</td><td>XR-Transformer-1(w/o CS) XR-Transformer-1</td><td>49.1 49.0</td><td>43.8 43.7</td><td>40.0 39.9</td><td>10.3 10.4</td><td>25.6 25.7</td><td>37.7 37.7</td></tr><tr><td>Amazon-3M</td><td>XR-Transformer-1(w/o CS) XR-Transformer-1</td><td>50.2 52.6</td><td>47.6 49.4</td><td>45.4 46.9</td><td>3.4 3.8</td><td>8.4 9.3</td><td>12.4 13.6</td></tr></table>",
+        "bbox": [
+            207,
+            209,
+            787,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Effect of Label Resolution and Text Representation. Next, we compare the effect of label resolution on the quality of the finetuned transformer embeddings. We finetune transformer models in a non-recursive manner on a two layer HLT with different leaf cluster size. Then the fine-tuned transformer embeddings are used along or in combination with TF-IDF features to produce the predictions with refined HLT. From Figure 2 we can observe that a larger cluster size will result in worse semantic features. Figure 2 also shows that combining semantic features $\\Phi _ { d n n }$ with statistical features $\\Phi _ { t f i d f }$ could in general improve the model performance. ",
+        "bbox": [
+            173,
+            377,
+            452,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/03c79d8c35fdaa79ddede59d237f8e3c9058ea90641c96c6335f1749f2615180.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of BERT model fine-tuned with different label resolution. Larger cluster size means lower label resolution. Note that $\\Phi _ { c a t }$ is the normalized concatenation of $\\Phi _ { t f i d f }$ and $\\Phi _ { d n n }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            467,
+            393,
+            821,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion and Future work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            617,
+            446,
+            633
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have presented XR-Transformer approach, which is an XMC architecture that leverages multi-resolution objectives and cost sensitive learning to accelerate the fine-tuning of pre-trained transformer models. Experiments show that the proposed method establishes new stateof-the-art results on public XMC datasets while taking significantly less training time compared with earlier transformer based methods. Although the proposed architecture is designed for XMC, the ideas can be applied to other areas such as information retrieval or other DNN models such as CNNs/ResNets. Also, more extensive study is required to understand why the coarse-to-fine scheme would lead to not only faster training but better overall quality. A hypothesis is that the problem is being solved at multiple scales hence leading to more robust learning of deep transformer models. ",
+        "bbox": [
+            173,
+            648,
+            826,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Wei-Cheng Chang, Felix X. Yu, Yin-Wen Chang, Yiming Yang, and Sanjiv Kumar. Pre-training tasks for embedding-based large-scale retrieval. In International Conference on Learning Representations, 2020.   \n[2] Kenton Lee, Ming-Wei Chang, and Kristina Toutanova. Latent retrieval for weakly supervised open domain question answering. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics (ACL), 2019.   \n[3] Yashoteja Prabhu, Anil Kag, Shrutendra Harsola, Rahul Agrawal, and Manik Varma. Parabel: Partitioned label trees for extreme classification with application to dynamic search advertising. In WWW, 2018.   \n[4] Yashoteja Prabhu and Manik Varma. Fastxml: A fast, accurate and stable tree-classifier for extreme multi-label learning. In KDD, 2014.   \n[5] Wei-Cheng Chang, Daniel Jiang, Hsiang-Fu Yu, Choon-Hui Teo, Jiong Zhang, Kai Zhong, Kedarnath Kolluri, Qie Hu, Nikhil Shandilya, Vyacheslav Ievgrafov, Japinder Singh, and Inderjit S Dhillon. Extreme multi-label learning for semantic matching in product search. In KDD. ACM, 2021.   \n[6] Sujay Khandagale, Han Xiao, and Rohit Babbar. Bonsai: diverse and shallow trees for extreme multi-label classification. Machine Learning, 109(11):2099–2119, 2020.   \n[7] Hsiang-Fu Yu, Kai Zhong, and Inderjit S Dhillon. PECOS: Prediction for enormous and correlated output spaces. arXiv preprint arXiv:2010.05878, 2020.   \n[8] Ronghui You, Zihan Zhang, Ziye Wang, Suyang Dai, Hiroshi Mamitsuka, and Shanfeng Zhu. AttentionXML: Label tree-based attention-aware deep model for high-performance extreme multi-label text classification. In Advances in Neural Information Processing Systems, pages 5812–5822, 2019.   \n[9] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics (NAACL), 2019.   \n[10] Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. XLNet: Generalized autoregressive pretraining for language understanding. In NIPS, 2019.   \n[11] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. RoBERTa: A robustly optimized BERT pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   \n[12] Wei-Cheng Chang, Hsiang-Fu Yu, Kai Zhong, Yiming Yang, and Inderjit S Dhillon. Taming pretrained transformers for extreme multi-label text classification. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 3163–3171, 2020.   \n[13] Ting Jiang, Deqing Wang, Leilei Sun, Huayi Yang, Zhengyang Zhao, and Fuzhen Zhuang. LightXML: Transformer with dynamic negative sampling for high-performance extreme multilabel text classification. In AAAI, 2021.   \n[14] Wei-Sheng Lai, Jia-Bin Huang, Narendra Ahuja, and Ming-Hsuan Yang. Deep laplacian pyramid networks for fast and accurate super-resolution. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.   \n[15] Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. In ICLR, 2018.   \n[16] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4401–4410, 2019. ",
+        "bbox": [
+            173,
+            39,
+            828,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th annual international conference on machine learning, pages 41–48, 2009. ",
+        "bbox": [
+            171,
+            90,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[18] Rohit Babbar and Bernhard Schölkopf. DiSMEC: distributed sparse machines for extreme multi-label classification. In WSDM, 2017. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Ian EH Yen, Xiangru Huang, Kai Zhong, Pradeep Ravikumar, and Inderjit S Dhillon. PDSparse: A primal and dual sparse approach to extreme multiclass and multilabel classification. In International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            174,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Ian EH Yen, Xiangru Huang, Wei Dai, Pradeep Ravikumar, Inderjit Dhillon, and Eric Xing. PPDsparse: A parallel primal-dual sparse method for extreme classification. In KDD. ACM, 2017. ",
+        "bbox": [
+            174,
+            228,
+            825,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Rohit Babbar and Bernhard Schölkopf. Data scarcity, robustness and extreme multi-label classification. Machine Learning, pages 1–23, 2019. ",
+        "bbox": [
+            173,
+            279,
+            823,
+            308
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Anna E Choromanska and John Langford. Logarithmic time online multiclass prediction. Advances in Neural Information Processing Systems, 28:55–63, 2015. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Hal Daumé III, Nikos Karampatziakis, John Langford, and Paul Mineiro. Logarithmic time one-against-some. In International Conference on Machine Learning, pages 923–932. PMLR, 2017. ",
+        "bbox": [
+            176,
+            352,
+            825,
+            393
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Marek Wydmuch, Kalina Jasinska, Mikhail Kuznetsov, Róbert Busa-Fekete, and Krzysztof Dembczynski. A no-regret generalization of hierarchical softmax to extreme multi-label classification. In NIPS, 2018. ",
+        "bbox": [
+            173,
+            401,
+            823,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Yashoteja Prabhu, Aditya Kusupati, Nilesh Gupta, and Manik Varma. Extreme regression for dynamic search advertising. In Proceedings of the 13th International Conference on Web Search and Data Mining, pages 456–464, 2020. ",
+        "bbox": [
+            174,
+            452,
+            823,
+            496
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Kalina Jasinska-Kobus, Marek Wydmuch, Krzysztof Dembczynski, Mikhail Kuznetsov, and Robert Busa-Fekete. Probabilistic label trees for extreme multi-label classification. arXiv preprint arXiv:2009.11218, 2020. ",
+        "bbox": [
+            174,
+            502,
+            823,
+            545
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Kalina Jasinska-Kobus, Marek Wydmuch, Devanathan Thiruvenkatachari, and Krzysztof Dembczynski. Online probabilistic label trees. In International Conference on Artificial Intelligence and Statistics, pages 1801–1809. PMLR, 2021. ",
+        "bbox": [
+            174,
+            553,
+            823,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Yukihiro Tagami. AnnexML: Approximate nearest neighbor search for extreme multi-label classification. In Proceedings of the 23rd ACM SIGKDD international conference on knowledge discovery and data mining, pages 455–464, 2017. ",
+        "bbox": [
+            174,
+            603,
+            821,
+            647
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Himanshu Jain, Venkatesh Balasubramanian, Bhanu Chunduri, and Manik Varma. SLICE: Scalable linear extreme classifiers trained on 100 million labels for related searches. In Proceedings of the Twelfth ACM International Conference on Web Search and Data Mining, pages 528–536. ACM, 2019. ",
+        "bbox": [
+            176,
+            654,
+            825,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Y. A. Malkov and D. A. Yashunin. Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs. IEEE Transactions on Pattern Analysis and Machine Intelligence, 42(4):824–836, 2020. ",
+        "bbox": [
+            171,
+            718,
+            823,
+            761
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Chuan Guo, Ali Mousavi, Xiang Wu, Daniel N Holtmann-Rice, Satyen Kale, Sashank Reddi, and Sanjiv Kumar. Breaking the glass ceiling for embedding-based classifiers for large output spaces. In Advances in Neural Information Processing Systems, pages 4944–4954, 2019. ",
+        "bbox": [
+            171,
+            767,
+            823,
+            811
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Ruiqi Guo, Philip Sun, Erik Lindgren, Quan Geng, David Simcha, Felix Chern, and Sanjiv Kumar. Accelerating large-scale inference with anisotropic vector quantization. In International Conference on Machine Learning, pages 3887–3896. PMLR, 2020. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            862
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Jingzhou Liu, Wei-Cheng Chang, Yuexin Wu, and Yiming Yang. Deep learning for extreme multi-label text classification. In Proceedings of the 40th International ACM SIGIR Conference on Research and Development in Information Retrieval, pages 115–124. ACM, 2017. ",
+        "bbox": [
+            174,
+            868,
+            826,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Tharun Kumar Reddy Medini, Qixuan Huang, Yiqiu Wang, Vijai Mohan, and Anshumali Shrivastava. Extreme classification in log memory using count-min sketch: A case study of amazon search with $5 0 \\mathrm { m }$ products. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   \n[35] Kunal Dahiya, Deepak Saini, Anshul Mittal, Ankush Shaw, Kushal Dave, Akshay Soni, Himanshu Jain, Sumeet Agarwal, and Manik Varma. DeepXML: A deep extreme multi-label learning framework applied to short text documents. In Proceedings of the 14th ACM International Conference on Web Search and Data Mining, pages 31–39, 2021.   \n[36] Anshul Mittal, Kunal Dahiya, Sheshansh Agrawal, Deepak Saini, Sumeet Agarwal, Purushottam Kar, and Manik Varma. DECAF: Deep extreme classification with label features. In Proceedings of the 14th ACM International Conference on Web Search and Data Mining, pages 49–57, 2021.   \n[37] D. Saini, A.K. Jain, K. Dave, J. Jiao, A. Singh, R. Zhang, and M. Varma. GalaXC: Graph neural networks with labelwise attention for extreme classification. In Proceedings of The Web Conference, April 2021.   \n[38] A. Mittal, N. Sachdeva, S. Agrawal, S. Agarwal, P. Kar, and M. Varma. ECLARE: Extreme classification with label graph correlations. In Proceedings of The ACM International World Wide Web Conference, April 2021.   \n[39] Hui Ye, Zhiyu Chen, Da-Han Wang, and Brian Davison. Pretrained generalized autoregressive model with adaptive probabilistic label clusters for extreme multi-label text classification. In International Conference on Machine Learning, pages 10809–10819. PMLR, 2020.   \n[40] Armand Joulin, Moustapha Cissé, David Grangier, Hervé Jégou, et al. Efficient softmax approximation for gpus. In International Conference on Machine Learning, pages 1302–1310. PMLR, 2017.   \n[41] Himanshu Jain, Yashoteja Prabhu, and Manik Varma. Extreme multi-label loss functions for recommendation, tagging, ranking & other missing label applications. In KDD, 2016.   \n[42] Marco Pedersoli, Andrea Vedaldi, Jordi Gonzalez, and Xavier Roca. A coarse-to-fine approach for fast deformable object detection. Pattern Recognition, 48(5):1844–1853, 2015.   \n[43] Shikun Liu, Andrew J Davison, and Edward Johns. Self-Supervised generalisation with meta auxiliary learning. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   \n[44] Charles Elkan. The foundations of cost-sensitive learning. In International joint conference on artificial intelligence, volume 17, pages 973–978. Lawrence Erlbaum Associates Ltd, 2001.   \n[45] Chun-Liang Li and Hsuan-Tien Lin. Condensed filter tree for cost-sensitive multi-label classification. In International Conference on Machine Learning, pages 423–431. PMLR, 2014.   \n[46] Kuan-Hao Huang and Hsuan-Tien Lin. Cost-sensitive label embedding for multi-label classification. Machine Learning, 106(9):1725–1746, 2017.   \n[47] Hsuan-Tien Lin. Advances in cost-sensitive multiclass and multilabel classification. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 3187–3188, 2019.   \n[48] Aditya K Menon, Ankit Singh Rawat, Sashank Reddi, and Sanjiv Kumar. Multilabel reductions: what is my loss optimising? In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   \n[49] Rong-En Fan, Kai-Wei Chang, Cho-Jui Hsieh, Xiang-Rui Wang, and Chih-Jen Lin. LIBLINEAR: a library for large linear classification. Journal of machine learning research, 9(Aug):1871–1874, 2008. ",
+        "bbox": [
+            171,
+            49,
+            828,
+            920
+        ],
+        "page_idx": 12
+    }
+]

parse/train/r1rhWnZkg/r1rhWnZkg.md

@@ -0,0 +1,424 @@
+# HADAMARD PRODUCT FOR LOW-RANK BILINEAR POOLING
+
+Jin-Hwa Kim   
+Interdisciplinary Program in Cognitive Science   
+Seoul National University   
+Seoul 08826, Republic of Korea   
+jhkim@bi.snu.ac.kr   
+Kyoung-Woon On   
+School of Computer Science and Engineering   
+Seoul National University   
+Seoul 08826, Republic of Korea   
+kwon@bi.snu.ac.kr
+
+Woosang Lim School of Computing, KAIST Daejeon 34141, Republic of Korea quasar17@kaist.ac.kr
+
+Jeonghee Kim & Jung-Woo Ha NAVER LABS Corp. & NAVER Corp. Gyeonggi-do 13561, Republic of Korea {jeonghee.kim,jungwoo.ha}@navercorp.com
+
+Byoung-Tak Zhang   
+School of Computer Science and Engineering & Interdisciplinary Program in Cognitive Science   
+Seoul National University & Surromind Robotics   
+Seoul 08826, Republic of Korea   
+btzhang@bi.snu.ac.kr
+
+# ABSTRACT
+
+Bilinear models provide rich representations compared with linear models. They have been applied in various visual tasks, such as object recognition, segmentation, and visual question-answering, to get state-of-the-art performances taking advantage of the expanded representations. However, bilinear representations tend to be high-dimensional, limiting the applicability to computationally complex tasks. We propose low-rank bilinear pooling using Hadamard product for an efficient attention mechanism of multimodal learning. We show that our model outperforms compact bilinear pooling in visual question-answering tasks with the state-of-the-art results on the VQA dataset, having a better parsimonious property.
+
+# 1 INTRODUCTION
+
+Bilinear models (Tenenbaum & Freeman, 2000) provide richer representations than linear models. To exploit this advantage, fully-connected layers in neural networks can be replaced with bilinear pooling. The outer product of two vectors (or Kroneker product for matrices) is involved in bilinear pooling, as a result of this, all pairwise interactions among given features are considered. Recently, a successful application of this technique is used for fine-grained visual recognition (Lin et al., 2015).
+
+However, bilinear pooling produces a high-dimensional feature of quadratic expansion, which may constrain a model structure and computational resources. For example, an outer product of two feature vectors, both of which have 1K-dimensionality, produces a million-dimensional feature vector. Therefore, for classification problems, the choice of the number of target classes is severely constrained, because the number of parameters for a standard linear classifier is determined by multiplication of the size of the high-dimensional feature vector and the number of target classes.
+
+Compact bilinear pooling (Gao et al., 2016) reduces the quadratic expansion of dimensionality by two orders of magnitude, retaining the performance of the full bilinear pooling. This approximation uses sampling-based computation, Tensor Sketch Projection (Charikar et al., 2002; Pham & Pagh, 2013), which utilizes an useful property that $\Psi ( x \otimes y , h , s ) = \Psi ( x , h , s ) * \Psi ( y , h , s )$ , which means the projection of outer product of two vectors is the convolution of two projected vectors. Here, $\Psi$ is the proposed projection function, and, $h$ and $s$ are randomly sampled parameters by the algorithm.
+
+Nevertheless, compact bilinear pooling embraces two shortcomings. One comes from the sampling approach. Compact bilinear pooling relies on a favorable property, $E [ \langle \Psi ( x , h , s ) , \Psi ( y , h , s ) \rangle ] \stackrel { - } { = }$ $\langle { \bar { x } } , y \rangle$ , which provides a basis to use projected features instead of original features. Yet, calculating the exact expectation is computationally intractable, so, the random parameters, $h$ and $s$ are fixed during training and evaluation. This practical choice leads to the second. The projected dimension of compact bilinear pooling should be large enough to minimize the bias from the fixed parameters. Practical choices are 10K and 16K for 512 and 4096-dimensional inputs, respectively (Gao et al., 2016; Fukui et al., 2016). Though, these compacted dimensions are reduced ones by two orders of magnitude compared with full bilinear pooling, such high-dimensional features could be a bottleneck for computationally complex models.
+
+We propose low-rank bilinear pooling using Hadamard product (element-wise multiplication), which is commonly used in various scientific computing frameworks as one of tensor operations. The proposed method factors a three-dimensional weight tensor for bilinear pooling into three twodimensional weight matrices, which enforces the rank of the weight tensor to be low-rank. As a result, two input feature vectors linearly projected by two weight matrices, respectively, are computed by Hadamard product, then, followed by a linear projection using the third weight matrix. For example, the projected vector $\mathbf { z }$ is represented by $\mathbf { W } _ { z } ^ { T } ( \mathbf { \bar { W } } _ { \mathbf { x } } ^ { T } \mathbf { x } \circ \mathbf { W } _ { \mathbf { y } } ^ { T } \mathbf { y } )$ , where $\circ$ denotes Hadamard product.
+
+We also explore to add non-linearity using non-linear activation functions into the low-rank bilinear pooling, and shortcut connections inspired by deep residual learning (He et al., 2016). Then, we show that it becomes a simple baseline model (Antol et al., 2015) or one-learning block of Multimodal Residual Networks (Kim et al., 2016b) as a low-rank bilinear model, yet, this interpretation has not be done.
+
+Our contributions are as follows: First, we propose low-rank bilinear pooling to approximate full bilinear pooling to substitute compact bilinear pooling. Second, Multimodal Low-rank Bilinear Attention Networks (MLB) having an efficient attention mechanism using low-rank bilinear pooling is proposed for visual question-answering tasks. MLB achieves a new state-of-the-art performance, and has a better parsimonious property. Finally, ablation studies to explore alternative choices, e.g. network depth, non-linear functions, and shortcut connections, are conducted.
+
+# 2 LOW-RANK BILINEAR MODEL
+
+Bilinear models use a quadratic expansion of linear transformation considering every pair of features.
+
+$$
+f _ { i } = \sum _ { j = 1 } ^ { N } \sum _ { k = 1 } ^ { M } w _ { i j k } x _ { j } y _ { k } + b _ { i } = \mathbf { x } ^ { T } \mathbf { W } _ { i } \mathbf { y } + b _ { i }
+$$
+
+where $\mathbf { x }$ and $\mathbf { y }$ are input vectors, ${ \bf W } _ { i } \in \mathbb { R } ^ { N \times M }$ is a weight matrix for the output $f _ { i }$ , and $b _ { i }$ is a bias for the output $f _ { i }$ . Notice that the number of parameters is $L \times ( N \times M + 1 )$ including a bias vector b, where $L$ is the number of output features.
+
+Pirsiavash et al. (2009) suggest a low-rank bilinear method to reduce the rank of the weight matrix $\mathbf { W } _ { i }$ to have less number of parameters for regularization. They rewrite the weight matrix as $\mathbf { W } _ { i } =$ $\mathbf { U } _ { i } \mathbf { V } _ { i } ^ { T }$ where $\mathbf { U } _ { i } \in \mathbb { R } ^ { N \times d }$ and $\mathbf { V } _ { i } \in \mathbb { R } ^ { M \times d }$ , which imposes a restriction on the rank of $\mathbf { W } _ { i }$ to be at most $d \leq \operatorname* { m i n } ( N , M )$ .
+
+Based on this idea, $f _ { i }$ can be rewritten as follows:
+
+$$
+f _ { i } = \mathbf { x } ^ { T } \mathbf { W } _ { i } \mathbf { y } + b _ { i } = \mathbf { x } ^ { T } \mathbf { U } _ { i } \mathbf { V } _ { i } ^ { T } \mathbf { y } + b _ { i } = \mathbb { 1 } ^ { T } ( \mathbf { U } _ { i } ^ { T } \mathbf { x } \circ \mathbf { V } _ { i } ^ { T } \mathbf { y } ) + b _ { i }
+$$
+
+where $\mathbb { 1 } \in \mathbb { R } ^ { d }$ denotes a column vector of ones, and $\circ$ denotes Hadamard product. Still, we need two third-order tensors, $\mathbf { U }$ and $\mathbf { V }$ , for a feature vector f , whose elements are $\{ f _ { i } \}$ . To reduce the order of the weight tensors by one, we replace $\mathbb { 1 }$ with $\mathbf { P } \in \mathbb { R } ^ { d \times c }$ and $b _ { i }$ with $\mathbf { b } \in \mathbb { R } ^ { c }$ , then, redefine as ${ \bf U } \in \mathbb { R } ^ { N \times d }$ and $\mathbf { V } \in \mathbb { R } ^ { M \times d }$ to get a projected feature vector $\mathbf { f } \in \mathbb { R } ^ { c }$ . Then, we get:
+
+$$
+\mathbf { f } = \mathbf { P } ^ { T } ( \mathbf { U } ^ { T } \mathbf { x } \circ \mathbf { V } ^ { T } \mathbf { y } ) + \mathbf { b }
+$$
+
+where $d$ and $c$ are hyperparameters to decide the dimension of joint embeddings and the output dimension of low-rank bilinear models, respectively.
+
+# 3 LOW-RANK BILINEAR POOLING
+
+A low-rank bilinear model in Equation 3 can be implemented using two linear mappings without biases for embedding two input vectors, Hadamard product to learn joint representations in a multiplicative way, and a linear mapping with a bias to project the joint representations into an output vector for a given output dimension. Then, we use this structure as a pooling method for deep neural networks. Now, we discuss possible variations of low-rank bilinear pooling based on this model inspired by studies of neural networks.
+
+# 3.1 FULL MODEL
+
+In Equation 3, linear projections, $U$ and $V$ , can have their own bias vectors. As a result, linear models for each input vectors, $\mathbf { x }$ and $\mathbf { y }$ , are integrated in an additive form, called as full model for linear regression in statistics:
+
+$$
+\begin{array} { r } { \begin{array} { c } { \mathbf { f } = \mathbf { P } ^ { T } \big ( ( \mathbf { U } ^ { T } \mathbf { x } + \mathbf { b } _ { x } \big ) \circ ( \mathbf { V } ^ { T } \mathbf { y } + \mathbf { b } _ { y } ) \big ) + \mathbf { b } } \\ { = \mathbf { P } ^ { T } ( \mathbf { U } ^ { T } \mathbf { x } \circ \mathbf { V } ^ { T } \mathbf { y } + \mathbf { U } ^ { T } \mathbf { x } + \mathbf { V } ^ { \prime T } \mathbf { y } ) + \mathbf { b } ^ { \prime } . } \\ { \mathbf { J } ^ { \prime T } = \mathrm { d i a g } ( \mathbf { b } _ { y } ) \cdot \mathbf { U } ^ { T } , \mathbf { V } ^ { \prime T } = \mathrm { d i a g } ( \mathbf { b } _ { x } ) \cdot \mathbf { V } ^ { T } , \mathrm { a n d } \ \mathbf { b } ^ { \prime } = \mathbf { b } + \mathbf { P } ^ { T } ( \mathbf { b } _ { x } \circ \mathbf { b } _ { y } ) . } \end{array} } \end{array}
+$$
+
+# 3.2 NONLINEAR ACTIVATION
+
+Applying non-linear activation functions may help to increase representative capacity of model. The first candidate is to apply non-linear activation functions right after linear mappings for input vectors.
+
+$$
+\mathbf { f } = \mathbf { P } ^ { T } \big ( \sigma ( \mathbf { U } ^ { T } \mathbf { x } ) \circ \sigma ( \mathbf { V } ^ { T } \mathbf { y } ) \big ) + \mathbf { b }
+$$
+
+where $\sigma$ denotes an arbitrary non-linear activation function, which maps any real values into a finite interval, e.g. sigmoid or tanh. If two inputs come from different modalities, statistics of two inputs may be quite different from each other, which may result an interference. Since the gradient with respect to each input is directly dependent on the other input in Hadamard product of two inputs.
+
+Additional applying an activation function after the Hadamard product is not appropriate, since activation functions doubly appear in calculating gradients. However, applying the activation function only after the Hadamard product would be alternative choice (We explore this option in Section 5) as follows:
+
+$$
+\mathbf { f } = \mathbf { P } ^ { T } \sigma \big ( \mathbf { U } ^ { T } \mathbf { x } \circ \mathbf { V } ^ { T } \mathbf { y } \big ) + \mathbf { b } .
+$$
+
+Note that using the activation function in low-rank bilinear pooling can be found in an implementation of simple baseline for the VQA dataset (Antol et al., 2015) without an interpretation of low-rank bilinear pooling. However, notably, Wu et al. (2016c) studied learning behavior of multiplicative integration in RNNs with discussions and empirical evidences.
+
+# 3.3 SHORTCUT CONNECTION
+
+When we apply two previous techniques, full model and non-linear activation, linear models of two inputs are nested by the non-linear activation functions. To avoid this unfortunate situation, we add shortcut connections as explored in residual learning (He et al., 2016).
+
+$$
+\mathbf { f } = \mathbf { P } ^ { T } \big ( \sigma ( \mathbf { U } ^ { T } \mathbf { x } ) \circ \sigma ( \mathbf { V } ^ { T } \mathbf { y } ) \big ) + h _ { x } ( \mathbf { x } ) + h _ { y } ( \mathbf { y } ) + \mathbf { b }
+$$
+
+where $h _ { x }$ and $h _ { y }$ are shortcut mappings. For linear projection, the shortcut mappings are linear mappings. Notice that this formulation is a generalized form of the one-block layered MRN (Kim et al., 2016b). Though, the shortcut connections are not used in our proposed model, as explained in Section 6.
+
+# 4 MULTIMODAL LOW-RANK BILINEAR ATTENTION NETWORKS
+
+In this section, we apply low-rank bilinear pooling to propose an efficient attention mechanism for visual question-answering tasks, based on the interpretation of previous section. We assumed that inputs are a question embedding vector $\mathbf { q }$ and a set of visual feature vectors $\mathbf { F }$ over $S \times S$ lattice space.
+
+# 4.1 LOW-RANK BILINEAR POOLING IN ATTENTION MECHANISM
+
+Attention mechanism uses an attention probability distribution $\alpha$ over $S \times S$ lattice space. Here, using low-rank bilinear pooling, $\alpha$ is defined as
+
+$$
+\alpha = \mathrm { s o f t m a x } \Big ( \mathbf { P } _ { \alpha } ^ { T } \big ( \sigma ( \mathbf { U } _ { \mathbf { q } } ^ { T } \mathbf { q } \cdot \mathbb { 1 } ^ { T } ) \circ \sigma ( \mathbf { V } _ { \mathbf { F } } ^ { T } \mathbf { F } ^ { T } ) \big ) \Big )
+$$
+
+where $\alpha \in \mathbb { R } ^ { G \times S ^ { 2 } }$ , $\mathbf { P } _ { \alpha } \in \mathbb { R } ^ { d \times G }$ , $\sigma$ is a hyperbolic tangent function, ${ \bf U _ { q } } \in \mathbb { R } ^ { N \times d }$ , ${ \bf q } \in \mathbb { R } ^ { N }$ , $\mathbb { 1 } \in \mathbb { R } ^ { S ^ { 2 } }$ , ${ \bf V _ { F } } \in \mathbb { R } ^ { M \times d }$ , and $\mathbf { F } \in \mathbb { R } ^ { S ^ { 2 } \times M }$ . If $G > 1$ , multiple glimpses are explicitly expressed as in Fukui et al. (2016), conceptually similar to Jaderberg et al. (2015). And, the softmax function applies to each row vector of $\alpha$ . The bias terms are omitted for simplicity.
+
+# 4.2 MULTIMODAL LOW-RANK BILINEAR ATTENTION NETWORKS
+
+Attended visual feature $\hat { \mathbf { v } }$ is a linear combination of $\mathbf { F } _ { i }$ with coefficients $\alpha _ { g , i }$ . Each attention probability distribution $\alpha _ { g }$ is for a glimpse $g$ . For $G > 1$ , $\hat { \mathbf { v } }$ is the concatenation of resulting vectors $\hat { \mathbf { v } } _ { g }$ as
+
+$$
+\hat { \mathbf { v } } = \prod _ { g = 1 } ^ { G } \sum _ { s = 1 } ^ { S ^ { 2 } } \alpha _ { g , s } \mathbf { F } _ { s }
+$$
+
+where $| |$ denotes concatenation of vectors. The posterior probability distribution is an output of a softmax function, whose input is the result of another low-rank bilinear pooling of $\mathbf { q }$ and $\hat { \mathbf { v } }$ as
+
+$$
+\begin{array} { r } { p ( a | \mathbf { q } , \mathbf { F } ; \Theta ) = \underset { a \in \Omega } { \mathrm { s o f t m a x } } \left( \mathbf { P } _ { o } ^ { T } \big ( \sigma ( \mathbf { W } _ { \mathbf { q } } ^ { T } \mathbf { q } ) \circ \sigma ( \mathbf { V } _ { \hat { \mathbf { v } } } ^ { T } \hat { \mathbf { v } } ) \big ) \right) } \\ { \hat { a } = \underset { a \in \Omega } { \mathrm { a r g m a x } } p ( a | \mathbf { q } , \mathbf { F } ; \Theta ) \quad } \end{array}
+$$
+
+where $\hat { a }$ denotes a predicted answer, $\Omega$ is a set of candidate answers and $\Theta$ is an aggregation of entire model parameters.
+
+# 5 EXPERIMENTS
+
+In this section, we conduct six experiments to select the proposed model, Multimodal Low-rank Bilinear Attention Networks (MLB). Each experiment controls other factors except one factor to assess the effect on accuracies. Based on MRN (Kim et al., 2016b), we start our assessments with an initial option of $G = 1$ and shortcut connections of MRN, called as Multimodal Attention Residual Networks (MARN). Notice that we use one embeddings for each visual feature for better performance, based on our preliminary experiment (not shown). We attribute this choice to the attention mechanism for visual features, which provides more capacity to learn visual features. We use the same hyper-parameters of MRN (Kim et al., 2016b), without any explicit mention of this.
+
+The VQA dataset (Antol et al., 2015) is used as a primary dataset, and, for data augmentation, question-answering annotations of Visual Genome (Krishna et al., 2016) are used. Validation is performed on the VQA test-dev split, and model comparison is based on the results of the VQA test-standard split. For the comprehensive reviews of VQA tasks, please refer to Wu et al. (2016a) and Kafle & Kanan (2016a). The details about preprocessing, question and vision embedding, and hyperparameters used in our experiments are described in Appendix A. The source code for the experiments is available in Github repository1.
+
+Number of Learning Blocks Kim et al. (2016b) argue that three-block layered MRN shows the best performance among one to four-block layered models, taking advantage of residual learning. However, we speculate that an introduction of attention mechanism makes deep networks hard to optimize. Therefore, we explore the number of learning blocks of MARN, which have an attention mechanism using low-rank bilinear pooling.
+
+Number of Glimpses Fukui et al. (2016) show that the attention mechanism of two glimpses was an optimal choice. In a similar way, we assess one, two, and four-glimpse models.
+
+Table 1: The accuracies of our experimental model, Multimodal Attention Residual Networks (MARN), with respect to the number of learning blocks (L#), the number of glimpse (G#), the position of activation functions (tanh), answer sampling, shortcut connections, and data augmentation using Visual Genome dataset, for VQA test-dev split and Open-Ended task. Note that our proposed model, Multimodal Low-rank Bilinear Attention Networks (MLB) have no shortcut connections, compared with MARN. MODEL: model name, SIZE: number of parameters, ALL: overall accuracy in percentage, Y/N: yes/no, NUM: numbers, and ETC: others. Since Fukui et al. (2016) only report the accuracy of the ensemble model on the test-standard, the test-dev results of their single models are included in the last sector. Some figures have different precisions which are rounded. $^ *$ indicates the selected model for each experiment.
+
+<table><tr><td>MODEL</td><td>SIZE</td><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td></tr><tr><td>MRN-L3</td><td>65.0M</td><td>61.68</td><td>82.28</td><td></td><td></td></tr><tr><td>MARN-L3</td><td>65.5M</td><td></td><td>82.31</td><td>38.82</td><td>49.25 50.83</td></tr><tr><td></td><td></td><td>62.37</td><td></td><td>38.06</td><td></td></tr><tr><td>MARN-L2</td><td>56.3M</td><td>63.92</td><td>82.88</td><td>37.98</td><td>53.59</td></tr><tr><td>* MARN-L1</td><td>47.0M</td><td>63.79</td><td>82.73</td><td>37.92</td><td>53.46</td></tr><tr><td>MARN-L1-G1</td><td>47.0M</td><td>63.79</td><td>82.73</td><td>37.92</td><td>53.46</td></tr><tr><td>* MARN-L1-G2</td><td>57.7M</td><td>64.53</td><td>83.41</td><td>37.82</td><td>54.43</td></tr><tr><td>MARN-L1-G4</td><td>78.9M</td><td>64.61</td><td>83.72</td><td>37.86</td><td>54.33</td></tr><tr><td>No Tanh</td><td>57.7M</td><td>63.58</td><td>83.18</td><td>37.23</td><td>52.79</td></tr><tr><td>* Before-Product</td><td>57.7M</td><td>64.53</td><td>83.41</td><td>37.82</td><td>54.43</td></tr><tr><td>After-Product</td><td>57.7M</td><td>64.53</td><td>83.53</td><td>37.06</td><td>54.50</td></tr><tr><td>Mode Answer</td><td>57.7M</td><td>64.53</td><td>83.41</td><td>37.82</td><td>54.43</td></tr><tr><td> * Sampled Answer</td><td>57.7M</td><td>64.80</td><td>83.59</td><td>38.38</td><td>54.73</td></tr><tr><td>Shortcut * No Shortcut</td><td>57.7M 51.9M</td><td>64.80</td><td>83.59</td><td>38.38</td><td>54.73</td></tr><tr><td>MLB</td><td>51.9M</td><td>65.08</td><td>84.14</td><td>38.21</td><td>54.87</td></tr><tr><td>MLB+VG</td><td>51.9M</td><td>65.08 65.84</td><td>84.14 83.87</td><td>38.21 37.87</td><td>54.87</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>56.76</td></tr><tr><td>MCB+Att (Fukui et al., 2016)</td><td>69.2M</td><td>64.2</td><td>82.2</td><td>37.7</td><td>54.8</td></tr><tr><td>MCB+Att+GloVe (Fukui et al., 2016) MCB+Att+Glove+VG (Fukui et al., 2016)</td><td>70.5M 70.5M</td><td>64.7 65.4</td><td>82.5 82.3</td><td>37.6 37.2</td><td>55.6 57.4</td></tr></table>
+
+Non-Linearity We assess three options applying non-linearity on low-rank bilinear pooling, vanilla, before Hadamard product as in Equation 5, and after Hadamard product as in Equation 6.
+
+Answer Sampling VQA (Antol et al., 2015) dataset has ten answers from unique persons for each question, while Visual Genome (Krishna et al., 2016) dataset has a single answer for each question. Since difficult or ambiguous questions may have divided answers, the probabilistic sampling from the distribution of answers can be utilized to optimize for the multiple answers. An instance 2 can be found in Fukui et al. (2016). We simplify the procedure as follows:
+
+$$
+\begin{array} { r } { p ( a _ { 1 } ) = \left\{ \begin{array} { l l } { | a _ { 1 } | / { \Sigma _ { i } } | a _ { i } | , } & { \mathrm { i f ~ } | a _ { 1 } | \geq 3 } \\ { 0 , } & { \mathrm { o t h e r w i s e } } \end{array} \right. } \\ { p ( a _ { 0 } ) = 1 - p ( a _ { 1 } ) } \end{array}
+$$
+
+where $\left| a _ { i } \right|$ denotes the number of unique answer $a _ { i }$ in a set of multiple answers, $a _ { 0 }$ denotes a mode, which is the most frequent answer, and $a _ { 1 }$ denotes the secondly most frequent answer. We define the divided answers as having at least three answers which are the secondly frequent one, for the evaluation metric of VQA (Antol et al., 2015),
+
+$$
+\begin{array} { r } { \mathrm { a c c u r a c y } ( a _ { k } ) = \operatorname* { m i n } \left( | a _ { k } | / 3 , 1 \right) . } \end{array}
+$$
+
+Table 2: The VQA test-standard results to compare with state-of-the-art. Notice that these results are trained by provided VQA train and validation splits, without any data augmentation.   
+
+<table><tr><td rowspan="2">MODEL</td><td colspan="3">Open-Ended</td><td colspan="2">MC</td></tr><tr><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td><td>ALL</td></tr><tr><td>iBOWIMG (Zhou et al., 2015)</td><td>55.89</td><td></td><td>34.98</td><td>42.62</td><td></td></tr><tr><td>DPPnet (Noh et al., 2016)</td><td>57.36</td><td>76.76 80.28</td><td>36.92</td><td>42.24</td><td>61.97 62.69</td></tr><tr><td>Deeper LSTM+Normalized CNN (Antol et al., 2015)</td><td>58.16</td><td>80.56</td><td>36.53</td><td>43.73</td><td>63.09</td></tr><tr><td>SMem (Xu&amp; Saenko,2016)</td><td>58.24</td><td>80.80</td><td>37.53</td><td>43.48</td><td>1</td></tr><tr><td>Ask Your Neurons (Malinowski et al., 2016)</td><td>58.43</td><td>78.24</td><td>36.27</td><td>46.32</td><td></td></tr><tr><td>SAN (Yang et al., 2016)</td><td>58.85</td><td>79.11</td><td>36.41</td><td>46.42</td><td>=</td></tr><tr><td>D-NMN (Andreas et al., 2016)</td><td>59.44</td><td>80.98</td><td>37.48</td><td>45.81</td><td>=</td></tr><tr><td>ACK (Wu et al., 2016b)</td><td>59.44</td><td>81.07</td><td>37.12</td><td>45.83</td><td>=</td></tr><tr><td>FDA (Ilievski et al., 2016)</td><td>59.54</td><td>81.34</td><td></td><td></td><td>=</td></tr><tr><td>HYBRID (Kafle &amp; Kanan,2016b)</td><td>60.06</td><td>80.34</td><td>35.67 37.82</td><td>46.10</td><td>64.18</td></tr><tr><td>DMN+ (Xiong et al., 2016)</td><td>60.36</td><td></td><td></td><td>47.56</td><td>1</td></tr><tr><td></td><td></td><td>80.43</td><td>36.82</td><td>48.33</td><td>1</td></tr><tr><td>MRN (Kim et al., 2016b)</td><td>61.84</td><td>82.39</td><td>38.23</td><td>49.41</td><td>66.33</td></tr><tr><td>HieCoAtt (Lu et al., 2016)</td><td>62.06</td><td>79.95</td><td>38.22</td><td>51.95</td><td>66.07</td></tr><tr><td>RAU (Noh &amp; Han,2016)</td><td>63.2</td><td>81.7</td><td>38.2</td><td>52.8</td><td>67.3</td></tr><tr><td>MLB (ours)</td><td>65.07</td><td>84.02</td><td>37.90</td><td>54.77</td><td>68.89</td></tr></table>
+
+The rate of the divided answers is approximately $1 6 . 4 0 \%$ , and only $0 . 2 3 \%$ of questions have more than two divided answers in VQA dataset. We assume that it eases the difficulty of convergence without severe degradation of performance.
+
+Shortcut Connection The contribution of shortcut connections for residual learning is explored based on the observation of the competitive performance of single-block layered model. Since the usefulness of shortcut connections is linked to the network depth (He et al., 2016).
+
+Data Augmentation The data augmentation with Visual Genome (Krishna et al., 2016) question answer annotations is explored. Visual Genome (Krishna et al., 2016) originally provides 1.7 Million visual question answer annotations. After aligning to VQA, the valid number of question-answering pairs for training is 837,298, which is for distinct 99,280 images.
+
+# 6 RESULTS
+
+The six experiments are conducted sequentially. Each experiment determines experimental variables one by one. Refer to Table 1, which has six sectors divided by mid-rules.
+
+# 6.1 SIX EXPERIMENT RESULTS
+
+Number of Learning Blocks Though, MRN (Kim et al., 2016b) has the three-block layered architecture, MARN shows the best performance with two-block layered models $( 6 3 . 9 2 \% )$ . For the multiple glimpse models in the next experiment, we choose one-block layered model for its simplicity to extend, and competitive performance $( 6 3 . 7 9 \% )$ ).
+
+Number of Glimpses Compared with the results of Fukui et al. (2016), four-glimpse MARN $( 6 4 . 6 1 \% )$ is better than other comparative models. However, for a parsimonious choice, two-glimpse MARN $( 6 4 . 5 3 \% )$ is chosen for later experiments. We speculate that multiple glimpses are one of key factors for the competitive performance of MCB (Fukui et al., 2016), based on a large margin in accuracy, compared with one-glimpse MARN $( 6 3 . 7 9 \%$ ).
+
+Non-Linearity The results confirm that activation functions are useful to improve performances. Surprisingly, there is no empirical difference between two options, before-Hadamard product and after-Hadamard product. This result may build a bridge to relate with studies on multiplicative integration with recurrent neural networks (Wu et al., 2016c).
+
+Answer Sampling Sampled answers $( 6 4 . 8 0 \% )$ result better performance than mode answers $( 6 4 . 5 3 \% )$ . It confirms that the distribution of answers from annotators can be used to improve the performance. However, the number of multiple answers is usually limited due to the cost of data collection.
+
+Shortcut Connection Though, MRN (Kim et al., 2016b) effectively uses shortcut connections to improve model performance, one-block layered MARN shows better performance without the shortcut connection. In other words, the residual learning is not used in our proposed model, MLB. It seems that there is a trade-off between introducing attention mechanism and residual learning. We leave a careful study on this trade-off for future work.
+
+Data Augmentation Data augmentation using Visual Genome (Krishna et al., 2016) question answer annotations significantly improves the performance by $0 . 7 6 \%$ in accuracy for VQA test-dev split. Especially, the accuracy of others (ETC)-type answers is notably improved from the data augmentation.
+
+# 6.2 COMPARISON WITH STATE-OF-THE-ART
+
+The comparison with other single models on VQA test-standard is shown in Table 2. The overall accuracy of our model is approximately $1 . 9 \%$ above the next best model (Noh & Han, 2016) on the Open-Ended task of VQA. The major improvements are from yes-or-no (Y/N) and others (ETC)- type answers. In Table 3, we also report the accuracy of our ensemble model to compare with other ensemble models on VQA test-standard, which won 1st to 5th places in VQA Challenge $2 0 1 6 ^ { 3 }$ . We beat the previous state-of-the-art with a margin of $0 . 4 2 \%$ .
+
+Table 3: The VQA test-standard results for ensemble models to compare with state-of-the-art. For unpublished entries, their team names are used instead of their model names. Some of their figures are updated after the challenge.   
+
+<table><tr><td rowspan="2">MODEL</td><td colspan="4">Open-Ended</td><td>MC</td></tr><tr><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td><td>ALL</td></tr><tr><td>RAU (Noh &amp; Han,2016)</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>64.12</td><td>83.33</td><td>38.02</td><td>53.37</td><td>67.34</td></tr><tr><td>MRN (Kim et al., 2016b)</td><td>63.18</td><td>83.16</td><td>39.14</td><td>51.33</td><td>67.54</td></tr><tr><td>DLAIT (not published)</td><td>64.83</td><td>83.23</td><td>40.80</td><td>54.32</td><td>68.30</td></tr><tr><td>Naver Labs (not published)</td><td>64.79</td><td>83.31</td><td>38.70</td><td>54.79</td><td>69.26</td></tr><tr><td>MCB (Fukui et al., 2016)</td><td>66.47</td><td>83.24</td><td>39.47</td><td>58.00</td><td>70.10</td></tr><tr><td>MLB (ours)</td><td>66.89</td><td>84.61</td><td>39.07</td><td>57.79</td><td>70.29</td></tr><tr><td>Human (Antol et al., 2015)</td><td>83.30</td><td>95.77</td><td>83.39</td><td>72.67</td><td>91.54</td></tr></table>
+
+# 7 RELATED WORKS
+
+MRN (Kim et al., 2016b) proposes multimodal residual learning with Hadamard product of low-rank bilinear pooling. However, their utilization of low-rank bilinear pooling is limited to joint residual mapping function for multimodal residual learning. Higher-order Boltzmann Machines (Memisevic & Hinton, 2007; 2010) use Hadamard product to capture the interactions of input, output, and hidden representations for energy function. Wu et al. (2016c) propose the recurrent neural networks using Hadamard product to integrate multiplicative interactions among hidden representations in the model. For details of these related works, please refer to Appendix D.
+
+Yet, compact bilinear pooling or multimodal compact bilinear pooling (Gao et al., 2016; Fukui et al., 2016) is worth to discuss and carefully compare with our method.
+
+# 7.1 COMPACT BILINEAR POOLING
+
+Compact bilinear pooling (Gao et al., 2016) approximates full bilinear pooling using a samplingbased computation, Tensor Sketch Projection (Charikar et al., 2002; Pham & Pagh, 2013):
+
+$$
+\begin{array} { r l } & { \Psi ( x \otimes y , h , s ) = \Psi ( x , h , s ) * \Psi ( y , h , s ) } \\ & { \qquad = \mathrm { F F T } ^ { - 1 } ( \mathrm { F F T } ( \Psi ( x , h , s ) \circ \mathrm { F F T } ( \Psi ( y , h , s ) ) } \end{array}
+$$
+
+where $\otimes$ denotes outer product, $^ *$ denotes convolution, $\begin{array} { r } { \Psi ( v , h , s ) _ { i } : = \sum _ { j : h _ { j } = i } s _ { j } \cdot v _ { j } } \end{array}$ , FFT denotes Fast Fourier Transform, $d$ denotes an output dimension, $x , y , h , s \in \mathbb { R } ^ { n }$ , $x$ and $y$ are inputs, and $h$ and $s$ are random variables. $h _ { i }$ is sampled from $\{ 1 , . . . , d \}$ , and $s _ { i }$ is sampled from $\{ - 1 , 1 \}$ , then, both random variables are fixed for further usage. Even if the dimensions of $x$ and $y$ are different from each other, it can be used for multimodal learning (Fukui et al., 2016).
+
+Similarly to Equation 1, compact bilinear pooling can be described as follows:
+
+$$
+f _ { i } = \mathbf { x } ^ { T } \mathcal { W } _ { i } \mathbf { y }
+$$
+
+where $\mathcal { W } _ { i j k } = s _ { i j k } w _ { i j k }$ if $s _ { i j k }$ is sampled from $\{ - 1 , 1 \}$ , $w _ { i j k }$ is sampled from $\{ \mathbf { P } _ { i 1 } , \mathbf { P } _ { i 2 } , \dots , \mathbf { P } _ { i d } \}$ , and the compact bilinear pooling is followed by a fully connected layer $\mathbf { P } \in \mathbb { R } ^ { | \Omega | \times d }$ . Then, this method can be formulated as a hashing trick (Weinberger et al., 2009; Chen et al., 2015) to share randomly chosen bilinear weights using $d$ parameters for a output value, in a way that a single parameter is shared by $N M / d$ bilinear terms in expectation, with the variance of $\dot { N } M ( d - 1 ) \big / { d ^ { 2 } }$ (See Appendix B).
+
+In comparison with our method, their method approximates a three-dimensional weight tensor in bilinear pooling with a two-dimensional matrix $\mathbf { P }$ , which is larger than the concatenation of three two-dimensional matrices for low-rank bilinear pooling. The ratio of the number of parameters for a single output to the total number of parameters for $| \Omega |$ outputs is $d / d | \Omega | = 1 / | \Omega |$ (Fukui et al., 2016), vs. $d ( N + M + 1 ) / d ( N + M + | \Omega | ) = ( N + M + 1 ) / ( N + M + | \Omega | ) \approx 2 / 3$ (ours), since our method uses a three-way factorization. Hence, more parameters are allocated to each bilinear approximation than compact bilinear pooling does, effectively managing overall parameters guided by back-propagation algorithm.
+
+MCB (Fukui et al., 2016), which uses compact bilinear pooling for multimodal tasks, needs to set the dimension of output $d$ to 16K, to reduce the bias induced by the fixed random variables $h$ and $s$ . As a result, the majority of model parameters $( 1 6 \mathsf { K } \times 3 \mathsf { K } = 4 8 \mathsf { M } )$ are concentrated on the last fully connected layer, which makes a fan-out structure. So, the total number of parameters of MCB is highly sensitive to the number of classes, which is approximately $6 9 . 2 \mathbf { M }$ for $M C B + a t t$ , and $7 0 . 5 \mathbf { M }$ for $M C B + a t t + G l o V e$ . Yet, the total number of parameters of our proposed model (MLB) is 51.9M, which is more robust to the number of classes having $d = 1 . 2 \mathrm { K }$ , which has a similar role in model architecture.
+
+# 8 CONCLUSIONS
+
+We suggest a low-rank bilinear pooling method to replace compact bilinear pooling, which has a fan-out structure, and needs complex computations. Low-rank bilinear pooling has a flexible structure using linear mapping and Hadamard product, and a better parsimonious property, compared with compact bilinear pooling. We achieve new state-of-the-art results on the VQA dataset using a similar architecture of Fukui et al. (2016), replacing compact bilinear pooling with low-rank bilinear pooling. We believe our method could be applicable to other bilinear learning tasks.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to thank Patrick Emaase for helpful comments and editing. Also, we are thankful to anonymous reviewers who provided comments to improve this paper. This work was supported by NAVER LABS Corp. & NAVER Corp. and partly by the Korea government (IITP-R0126-16-1072-SW.StarLab, KEIT10044009-HRI.MESSI, KEIT-10060086-RISF, ADD-UD130070ID-BMRR). The part of computing resources used in this study was generously shared by Standigm Inc.
+
+# REFERENCES
+
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Learning to Compose Neural Networks for Question Answering. arXiv preprint arXiv:1601.01705, 2016.
+
+Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence Zitnick, and Devi Parikh. VQA: Visual Question Answering. IEEE International Conference on Computer Vision, 2015.
+
+Moses Charikar, Kevin Chen, and Martin Farach-Colton. Finding frequent items in data streams. In International Colloquium on Automata, Languages, and Programming, pp. 693–703. Springer, 2002.
+
+Wenlin Chen, James T. Wilson, Stephen Tyree, Kilian Q. Weinberger, and Yixin Chen. Compressing Neural Networks with the Hashing Trick. In 32nd International Conference on Machine Learning, pp. 2285–2294, 2015.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger ¨ Schwenk, and Yoshua Bengio. Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation. In 2014 Conference on Empirical Methods in Natural Language Processing, pp. 1724–1734, 2014.
+
+Akira Fukui, Dong Huk Park, Daylen Yang, Anna Rohrbach, Trevor Darrell, and Marcus Rohrbach. Multimodal Compact Bilinear Pooling for Visual Question Answering and Visual Grounding. arXiv preprint arXiv:1606.01847, 2016.
+
+Yarin Gal. A Theoretically Grounded Application of Dropout in Recurrent Neural Networks. arXiv preprint arXiv:1512.05287, 2015.
+
+Yang Gao, Oscar Beijbom, Ning Zhang, and Trevor Darrell. Compact Bilinear Pooling. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural computation, 9(8):1735–1780, 1997.
+
+Ilija Ilievski, Shuicheng Yan, and Jiashi Feng. A Focused Dynamic Attention Model for Visual Question Answering. arXiv preprint arXiv:1604.01485, 2016.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, and Koray Kavukcuoglu. Spatial Transformer Networks. In Advances in Neural Information Processing Systems 28, pp. 2008–2016, 2015.
+
+Kushal Kafle and Christopher Kanan. Visual Question Answering: Datasets, Algorithms, and Future Challenges. arXiv preprint arXiv:1610.01465, 2016a.
+
+Kushal Kafle and Christopher Kanan. Answer-Type Prediction for Visual Question Answering. IEEE Conference on Computer Vision and Pattern Recognition, pp. 4976–4984, 2016b.
+
+Jin-Hwa Kim, Jeonghee Kim, Jung-Woo Ha, and Byoung-Tak Zhang. TrimZero: A Torch Recurrent Module for Efficient Natural Language Processing. In KIIS Spring Conference, volume 26, pp. 165–166, 2016a.
+
+Jin-Hwa Kim, Sang-Woo Lee, Dong-Hyun Kwak, Min-Oh Heo, Jeonghee Kim, Jung-Woo Ha, and Byoung-Tak Zhang. Multimodal Residual Learning for Visual QA. arXiv preprint arXiv:1606.01455, 2016b.
+
+Ryan Kiros, Yukun Zhu, Ruslan Salakhutdinov, Richard S. Zemel, Antonio Torralba, Raquel Urtasun, and Sanja Fidler. Skip-Thought Vectors. In Advances in Neural Information Processing Systems 28, pp. 3294–3302, 2015.
+
+Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A Shamma, Michael Bernstein, and Li Fei-Fei. Visual genome: Connecting language and vision using crowdsourced dense image annotations. arXiv preprint arXiv:1602.07332, 2016.
+
+Nicholas Leonard, Sagar Waghmare, Yang Wang, and Jin-Hwa Kim. rnn´ $:$ Recurrent Library for Torch. arXiv preprint arXiv:1511.07889, 2015.
+
+Tsung-Yu Lin, Aruni RoyChowdhury, and Subhransu Maji. Bilinear CNN Models for Fine-grained Visual Recognition. In IEEE International Conference on Computer Vision, pp. 1449–1457, 2015.
+
+Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical Question-Image Co-Attention for Visual Question Answering. arXiv preprint arXiv:1606.00061, 2016.
+
+Mateusz Malinowski, Marcus Rohrbach, and Mario Fritz. Ask Your Neurons: A Deep Learning Approach to Visual Question Answering. arXiv preprint arXiv:1605.02697, 2016.   
+Roland Memisevic and Geoffrey E Hinton. Unsupervised learning of image transformations. In IEEE Conference on Computer Vision and Pattern Recognition, 2007.   
+Roland Memisevic and Geoffrey E Hinton. Learning to represent spatial transformations with factored higherorder Boltzmann machines. Neural computation, 22(6):1473–1492, 2010.   
+Hyeonwoo Noh and Bohyung Han. Training Recurrent Answering Units with Joint Loss Minimization for VQA. arXiv preprint arXiv:1606.03647, 2016.   
+Hyeonwoo Noh, Paul Hongsuck Seo, and Bohyung Han. Image Question Answering using Convolutional Neural Network with Dynamic Parameter Prediction. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.   
+Ninh Pham and Rasmus Pagh. Fast and scalable polynomial kernels via explicit feature maps. In 19th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 239–247. ACM, 2013.   
+Hamed Pirsiavash, Deva Ramanan, and Charless C. Fowlkes. Bilinear classifiers for visual recognition. In Advances in Neural Information Processing Systems 22, pp. 1482–1490, 2009.   
+Joshua B Tenenbaum and William T Freeman. Separating style and content with bilinear models. Neural computation, 12(6):1247–1283, 2000.   
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 4, 2012.   
+Kilian Weinberger, Anirban Dasgupta, John Langford, Alex Smola, and Josh Attenberg. Feature hashing for large scale multitask learning. In 26th International Conference on Machine Learning, pp. 1113–1120, 2009.   
+Qi Wu, Damien Teney, Peng Wang, Chunhua Shen, Anthony Dick, and Anton van den Hengel. Visual Question Answering: A Survey of Methods and Datasets. arXiv preprint arXiv:1607.05910, 2016a.   
+Qi Wu, Peng Wang, Chunhua Shen, Anthony Dick, and Anton van den Hengel. Ask Me Anything: Free-form Visual Question Answering Based on Knowledge from External Sources. In IEEE Conference on Computer Vision and Pattern Recognition, 2016b.   
+Yuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan Salakhutdinov. On Multiplicative Integration with Recurrent Neural Networks. arXiv preprint arXiv:1606.06630, 2016c.   
+Caiming Xiong, Stephen Merity, and Richard Socher. Dynamic Memory Networks for Visual and Textual Question Answering. In 33rd International Conference on Machine Learning, 2016.   
+Huijuan Xu and Kate Saenko. Ask, Attend and Answer: Exploring Question-Guided Spatial Attention for Visual Question Answering. In European Conference on Computer Vision, 2016.   
+Zichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alex Smola. Stacked Attention Networks for Image Question Answering. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.   
+Bolei Zhou, Yuandong Tian, Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Simple Baseline for Visual Question Answering. arXiv preprint arXiv:1512.02167, 2015.
+
+# Appendix
+
+A EXPERIMENT DETAILS
+
+A.1 PREPROCESSING
+
+We follow the preprocessing procedure of Kim et al. (2016b). Here, we remark some details of it, and changes.
+
+# A.1.1 QUESTION EMBEDDING
+
+The $9 0 . 4 5 \%$ of questions for the 2K-most frequent answers are used. The vocabulary size of questions is 15,031. GRU (Cho et al., 2014) is used for question embedding. Based on earlier studies (Noh et al., 2016; Kim et al., 2016b), a word embedding matrix and a GRU are initialized with Skip-thought Vector pre-trained model (Kiros et al., 2015). As a result, question vectors have 2,400 dimensions.
+
+For efficient computation of variable-length questions, Kim et al. (2016a) is used for the GRU. Moreover, for regularization, Bayesian Dropout (Gal, 2015) which is implemented in Leonard et al. (2015) is applied while ´ training.
+
+# A.2 VISION EMBEDDING
+
+ResNet-152 networks (He et al., 2016) are used for feature extraction. The dimensionality of an input image is $3 \times 4 4 8 \times 4 4 8$ . The outputs of the last convolution layer is used, which have $2 , 0 4 8 \times 1 4 \times 1 4$ dimensions.
+
+# A.3 HYPERPARAMETERS
+
+The hyperparameters used in MLB of Table 2 are described in Table 4. The batch size is 100, and the number of iterations is fixed to 250K. For data augmented models, a simplified early stopping is used, starting from 250K to 350K-iteration for every 25K iterations (250K, 275K, 300K, 325K, and 350K; at most five points) to avoid exhaustive submissions to VQA test-dev evaluation server. RMSProp (Tieleman & Hinton, 2012) is used for optimization.
+
+Though, the size of joint embedding size $d$ is borrowed from Kim et al. (2016b), a grid search on $d$ confirms this choice in our model as shown in Table 5.
+
+Table 4: Hyperparameters used in MLB (single model in Table 2).   
+
+<table><tr><td>SYMBOL</td><td>VALUE</td><td>DESCRIPTION</td></tr><tr><td>S</td><td>14</td><td></td></tr><tr><td>N</td><td>2,400</td><td>attention lattice size</td></tr><tr><td>M</td><td>2.048</td><td>question embedding size channel size of extracted visual features</td></tr><tr><td>d</td><td>1,200</td><td>joint embedding size</td></tr><tr><td>G</td><td>2</td><td>number of glimpses</td></tr><tr><td>||</td><td>2,000</td><td>number of candidate answers</td></tr><tr><td>n</td><td>3e-4</td><td>learning rate</td></tr><tr><td>入</td><td>0.99997592083</td><td>learning rate decay factor at every iteration</td></tr><tr><td>p</td><td>0.5</td><td>dropout rate</td></tr><tr><td>0</td><td>±10</td><td>gradient clipping threshold</td></tr></table>
+
+# A.4 MODEL SCHEMA
+
+Figure 1 shows a schematic diagram of MLB, where ◦ denotes Hadamard product, and $\Sigma$ denotes a linear combination of visual feature vectors using coefficients, which is the output of softmax function. If $G > 1$ , the softmax function is applied to each row vectors of an output matrix (Equation 8), and we concatenate the resulting vectors of the $G$ linear combinations (Equation 9).
+
+# A.5 ENSEMBLE OF SEVEN MODELS
+
+The test-dev results for individual models consisting of our ensemble model is presented in Table 6.
+
+Table 5: The effect of joint embedding size $d$   
+
+<table><tr><td colspan="6">Open-Ended</td></tr><tr><td>d</td><td>SIZE</td><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td></tr><tr><td>800</td><td>45.0M</td><td>64.89</td><td>84.08</td><td>38.15</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>54.55</td></tr><tr><td>1000</td><td>48.4M</td><td>65.06</td><td>84.18</td><td>38.01</td><td>54.85</td></tr><tr><td>1200</td><td>51.9M</td><td>65.08</td><td>84.14</td><td>38.21</td><td>54.87</td></tr><tr><td>1400</td><td>55.4M</td><td>64.94</td><td>84.13</td><td>38.00</td><td>54.64</td></tr><tr><td>1600</td><td>58.8M</td><td>65.02</td><td>84.15</td><td>37.79</td><td>54.85</td></tr></table>
+
+![](images/02dfd00cc4bb19b3dfb924b4f29abc92eecf2d16eabbc678aa69dd6173ad0cbb.jpg)  
+Figure 1: A schematic diagram of MLB. Replicate module copies an question embedding vector to match with $S ^ { 2 }$ visual feature vectors. Conv modules indicate $1 \times 1$ convolution to transform a given channel space, which is computationally equivalent to linear projection for channels.
+
+Table 6: The individual models used in our ensemble model in Table 3.   
+
+<table><tr><td colspan="2"></td><td colspan="4">Open-Ended</td></tr><tr><td>MODEL</td><td>GLIMPSE</td><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>MLB MLB</td><td>２2</td><td>64.89 65.08</td><td>84.13 84.14</td><td>37.85 38.21</td><td>54.57 54.87</td></tr><tr><td>MLB</td><td>4</td><td>65.01</td><td>84.09</td><td>37.66</td><td>54.88</td></tr><tr><td>MLB-VG</td><td>2</td><td>65.76</td><td>83.64</td><td>37.57</td><td>56.86</td></tr><tr><td>MLB-VG</td><td>2</td><td>65.84</td><td>83.87</td><td>37.87</td><td>56.76</td></tr><tr><td>MLB-VG</td><td>3</td><td>66.05</td><td>83.88</td><td>38.13</td><td>57.13</td></tr><tr><td>MLB-VG</td><td>4</td><td>66.09</td><td>83.59</td><td>38.32</td><td>57.42</td></tr><tr><td>Ensemble</td><td></td><td>66.77</td><td>84.54</td><td>39.21</td><td>57.81</td></tr></table>
+
+# B UNDERSTANDING OF MULTIMODAL COMPACT BILINEAR POOLING
+
+In this section, the algorithm of multimodal compact bilinear pooling (MCB) (Gao et al., 2016; Fukui et al., 2016) is described as a kind of hashing tick (Chen et al., 2015).
+
+$\mathbf { x } \in \mathbb { R } ^ { n _ { x } }$ and $\mathbf { y } \in \mathbb { R } ^ { n _ { y } }$ are the given inputs, $\Phi ( \mathbf { x } , \mathbf { y } ) \in \mathbb { R } ^ { d }$ is the output. Random variables $\mathbf { h } _ { x } \in \mathbb { N } ^ { n _ { x } }$ and $\mathbf { h } _ { y } \in \mathbb { N } ^ { n _ { y } }$ are uniformly sampled from $\{ 1 , \ldots , d \}$ , and $\mathbf { s } _ { x } \in \mathbb { Z } ^ { n _ { x } }$ and $\mathbf { s } _ { y } \in \mathbb { Z } ^ { n _ { y } }$ are uniformly sampled from $\{ - 1 , 1 \}$ . Then, Count Sketch projection function $\Psi$ (Charikar et al., 2002) projects $\mathbf { x }$ and $\mathbf { y }$ to intermediate representations $\Psi ( \mathbf { x } , \mathbf { h } _ { \boldsymbol { x } } , \mathbf { s } _ { \boldsymbol { x } } ) \in \mathbb { R } ^ { d }$ and $\boldsymbol { \Psi } ( \mathbf { y } , \mathbf { h } _ { y } , \mathbf { s } _ { y } ) \in \mathbb { R } ^ { d }$ , which is defined as:
+
+$$
+\Psi ( \mathbf { v } , \mathbf { h } , \mathbf { s } ) _ { i } : = \sum _ { j : h _ { j } = i } s _ { j } \cdot v _ { j }
+$$
+
+Notice that both $\mathbf { h }$ and s remain as constants after initialization (Fukui et al., 2016).
+
+The probability of $h _ { x j } = i$ and $h _ { y j } = i$ for the given $j$ is $1 / d ^ { 2 }$ . Hence, the expected number of bilinear terms in $\Psi ( \mathbf { x } , \mathbf { h } _ { x } , \mathbf { s } _ { x } ) _ { i } \Psi ( \mathbf { y } , \mathbf { h } _ { y } , \mathbf { s } _ { y } ) _ { i }$ is $\dot { ( } n _ { x } n _ { y } ) / d ^ { 2 }$ . Since, the output $\Phi ( \mathbf { x } , \mathbf { y } )$ is a result of circular convolution of $\Psi ( \mathbf { x } , \mathbf { h } _ { x } , \mathbf { s } _ { x } )$ and $\Psi ( \mathbf { y } , \mathbf { h } _ { y } , \mathbf { s } _ { y } )$ , the expected number of bilinear terms in $\Phi ( \mathbf { x } , \mathbf { y } ) _ { i }$ is $( n _ { x } n _ { y } ) / d$ . Likewise, the probability of that a bilinear term is allocated in $\Phi ( \mathbf { x } , \mathbf { y } ) _ { i }$ is $1 / d$ . The probability distribution of the number of bilinear terms in $\Phi ( \mathbf { x } , \mathbf { y } ) _ { i }$ follows a multinomial distribution, whose mean is $( n _ { x } n _ { y } ) / d$ and variance is $( n _ { x } n _ { y } ) ( d - 1 ) / d ^ { 2 }$ .
+
+Linear projection after the multimodal compact bilinear pooling provides weights on the bilinear terms, in a way that a shared weight is assigned to $\Phi ( \bar { \mathbf { x } } , \mathbf { y } ) _ { i }$ , which has $( n _ { x } n _ { y } ) / d$ bilinear terms in expectation, though each bilinear term can have a different sign induced by both ${ \bf s } _ { x }$ and $\mathbf { s } _ { y }$ .
+
+HashedNets (Chen et al., 2015) propose a method to compress neural networks using a low-cost hashing function (Weinberger et al., 2009), which is the same function of $\Psi ( \mathbf { v } , \mathbf { h } , \mathbf { s } )$ . They randomly group a portion of connections in neural networks to share a single weight. We speculate that multimodal compact bilinear pooling uses the hashing tick to reduce the number of full bilinear weights with the rate of $d / ( n _ { x } n _ { y } )$ . However, this approximation is limited to two-way interaction, compared with three-way factorization in our method.
+
+# C REPLACEMENT OF LOW-RANK BILINEAR POOLING
+
+For the explicit comparison with compact bilinear pooling, we explicitly substitute compact bilinear pooling for low-rank bilinear pooling to control everything else, which means that the rest of the model architecture is exactly the same.
+
+According to Fukui et al. (2016), we use MCB followed by Signed Square Root, L2-Normalization, Dropout $( p { = } 0 . 1 )$ , and linear projection from 16,000-dimension to the target dimension. Also, Dropout $\scriptstyle ( p = 0 . 3 )$ for a question embedding vector. Note that an overall architecture for multimodal learning of both is the same. Experimental details are referenced from the implementation 4 of Fukui et al. (2016).
+
+For test-dev split, our version of MCB gets $6 1 . 4 8 \%$ for overall accuracy (yes/no: $8 2 . 4 8 \%$ , number: $3 7 . 0 6 \%$ , and other: $4 9 . 0 7 \%$ ) vs. $6 5 . 0 8 \%$ (ours, MLB in Table 1). Additionally, if the nonlinearity in getting attention distributions is increased as the original MCB does using ReLU, we get $6 2 . 1 1 \%$ for overall accuracy (yes/no: $8 2 . 5 5 \%$ , number: $3 7 . 1 8 \%$ , and other: $5 0 . 3 0 \%$ ), which is still the below of our performance 5.
+
+We do not see it as a decisive evidence of the better performance of MLB, but as a reference (the comparison of test-dev results may be also unfair.), since an optimal architecture and hyperparameters may be required for each method.
+
+# D RELATED WORKS
+
+D.1 MULTIMODAL RESIDUAL NETWORKS
+
+MRN (Kim et al., 2016b) is an implicit attentional model using multimodal residual learning with Hadamard product which does not have any explicit attention mechanism.
+
+$$
+\begin{array} { r l } & { \mathcal { F } ^ { ( k ) } ( \mathbf { q } , \mathbf { v } ) = \sigma ( \mathbf { W } _ { \mathbf { q } } ^ { ( k ) } \mathbf { q } ) \circ \sigma ( \mathbf { W } _ { 2 } ^ { ( k ) } \sigma ( \mathbf { W } _ { 1 } ^ { ( k ) } \mathbf { v } ) ) } \\ & { \quad H _ { L } ( \mathbf { q } , \mathbf { v } ) = \mathbf { W } _ { \mathbf { q } ^ { \prime } } \mathbf { q } + \displaystyle \sum _ { l = 1 } ^ { L } \mathbf { W } _ { \mathcal { F } ^ { ( l ) } } \mathcal { F } ^ { ( l ) } ( H _ { l - 1 } , \mathbf { v } ) } \end{array}
+$$
+
+where $\mathbf { W } _ { * }$ are parameter matrices, $L$ is the number of learning blocks, $H _ { 0 } = \mathbf { q }$ , $\mathbf { W _ { q ^ { \prime } } } = \Pi _ { l = 1 } ^ { L } \mathbf { W } _ { \mathbf { q ^ { \prime } } } ^ { ( l ) }$ , an d $\mathbf { W } _ { \mathcal { F } ^ { ( l ) } } = \Pi _ { m = l + 1 } ^ { L } \mathbf { W } _ { \mathbf { q } ^ { \prime } } ^ { ( m ) }$ . Notice that these equations can be generalized by Equation 7.
+
+However, an explicit attention mechanism allows the use of lower-level visual features than fully-connected layers, and, more importantly, spatially selective learning. Recent state-of-the-art methods use a variant of an explicit attention mechanism in their models (Lu et al., 2016; Noh & Han, 2016; Fukui et al., 2016). Note that shortcut connections of MRN are not used in the proposed Multimodal Low-rank Bilinear (MLB) model. Since, it does not have any performance gain due to not stacking multiple layers in MLB. We leave the study of residual learning for MLB for future work, which may leverage the excellency of bilinear models as suggested in Wu et al. (2016a).
+
+# D.2 HIGHER-ORDER BOLTZMANN MACHINES
+
+A similar model can be found in a study of Higher-Order Boltzmann Machines (Memisevic & Hinton, 2007; 2010). They suggest a factoring method for the three-way energy function to capture correlations among input, output, and hidden representations.
+
+$$
+\begin{array} { l } { { \displaystyle - E ( { \bf y } , { \bf h } ; { \bf x } ) = \sum _ { f } \big ( \sum _ { i } x _ { i } w _ { i f } ^ { x } \big ) \big ( \sum _ { j } y _ { j } w _ { j f } ^ { y } \big ) \big ( \sum _ { k } h _ { k } w _ { k f } ^ { h } \big ) + \sum _ { k } w _ { k } ^ { h } h _ { k } + \sum _ { j } w _ { j } ^ { y } y _ { j } } \ ~ } \\ { { \displaystyle = \big ( { \bf x } ^ { T } { \bf W } ^ { x } \circ { \bf y } ^ { T } { \bf W } ^ { y } \circ { \bf h } ^ { T } { \bf W } ^ { h } \big ) \mathbb { 1 } + { \bf h } ^ { T } { \bf w } ^ { h } + { \bf y } ^ { T } { \bf w } ^ { y } } } \end{array}
+$$
+
+Setting aside of bias terms, the $I \times J \times K$ parameter tensor of unfactored Higher-Order Boltzmann Machines is replaced with three matrices, $\mathbf { W } ^ { x } \in \mathbb { R } ^ { I \times F }$ , $\mathbf { W } ^ { y } \in \mathbb { R } ^ { J \times F }$ , and $\mathbf { W } ^ { h } \in \mathbb { R } ^ { K \times F }$ .
+
+# D.3 MULTIPLICATIVE INTEGRATION WITH RECURRENT NEURAL NETWORKS
+
+Most of recurrent neural networks, including vanilla RNNs, Long Short Term Memory networks (Hochreiter & Schmidhuber, 1997) and Gated Recurrent Units (Cho et al., 2014), share a common expression as follows:
+
+$$
+\phi ( \mathbf { W _ { X } } + \mathbf { U _ { h } } + \mathbf { b } )
+$$
+
+where $\phi$ is a non-linear function, $\mathbf { W } \in \mathbb { R } ^ { d \times n }$ , $\mathbf { x } \in \mathbb { R } ^ { n }$ , $\mathbf { U } \in \mathbb { R } ^ { d \times m }$ , $\mathbf { h } \in \mathbb { R } ^ { m }$ , and $\mathbf { b } \in \mathbb { R } ^ { d }$ is a bias vector.   
+Note that, usually, $\mathbf { x }$ is an input state vector and $\mathbf { h }$ is an hidden state vector in recurrent neural networks.
+
+Wu et al. (2016c) propose a new design to replace the additive expression with a multiplicative expression using Hadamard product as
+
+$$
+\phi ( \mathbf { W } \mathbf { x } \circ \mathbf { U } \mathbf { h } + \mathbf { b } ) .
+$$
+
+Moreover, a general formulation of this multiplicative integration can be described as
+
+$$
+\phi ( \pmb { \alpha } \circ \mathbf { W } \mathbf { x } \circ \mathbf { U } \mathbf { h } + \mathbf { W } \mathbf { x } \circ \pmb { \beta } _ { 1 } + \mathbf { U } \mathbf { h } \circ \pmb { \beta } _ { 2 } + \mathbf { b } )
+$$
+
+which is reminiscent of full model in Section 3.1.

parse/train/r1rhWnZkg/r1rhWnZkg_content_list.json

@@ -0,0 +1,2019 @@
+[
+    {
+        "type": "text",
+        "text": "HADAMARD PRODUCT FOR LOW-RANK BILINEAR POOLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            612,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jin-Hwa Kim   \nInterdisciplinary Program in Cognitive Science   \nSeoul National University   \nSeoul 08826, Republic of Korea   \njhkim@bi.snu.ac.kr   \nKyoung-Woon On   \nSchool of Computer Science and Engineering   \nSeoul National University   \nSeoul 08826, Republic of Korea   \nkwon@bi.snu.ac.kr ",
+        "bbox": [
+            183,
+            170,
+            491,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            513,
+            170,
+            813,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Woosang Lim School of Computing, KAIST Daejeon 34141, Republic of Korea quasar17@kaist.ac.kr ",
+        "bbox": [
+            184,
+            261,
+            413,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jeonghee Kim & Jung-Woo Ha NAVER LABS Corp. & NAVER Corp. Gyeonggi-do 13561, Republic of Korea {jeonghee.kim,jungwoo.ha}@navercorp.com ",
+        "bbox": [
+            433,
+            261,
+            813,
+            318
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Byoung-Tak Zhang   \nSchool of Computer Science and Engineering & Interdisciplinary Program in Cognitive Science   \nSeoul National University & Surromind Robotics   \nSeoul 08826, Republic of Korea   \nbtzhang@bi.snu.ac.kr ",
+        "bbox": [
+            184,
+            338,
+            812,
+            407
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            444,
+            544,
+            459
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bilinear models provide rich representations compared with linear models. They have been applied in various visual tasks, such as object recognition, segmentation, and visual question-answering, to get state-of-the-art performances taking advantage of the expanded representations. However, bilinear representations tend to be high-dimensional, limiting the applicability to computationally complex tasks. We propose low-rank bilinear pooling using Hadamard product for an efficient attention mechanism of multimodal learning. We show that our model outperforms compact bilinear pooling in visual question-answering tasks with the state-of-the-art results on the VQA dataset, having a better parsimonious property. ",
+        "bbox": [
+            233,
+            479,
+            764,
+            604
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            638,
+            336,
+            654
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bilinear models (Tenenbaum & Freeman, 2000) provide richer representations than linear models. To exploit this advantage, fully-connected layers in neural networks can be replaced with bilinear pooling. The outer product of two vectors (or Kroneker product for matrices) is involved in bilinear pooling, as a result of this, all pairwise interactions among given features are considered. Recently, a successful application of this technique is used for fine-grained visual recognition (Lin et al., 2015). ",
+        "bbox": [
+            174,
+            672,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, bilinear pooling produces a high-dimensional feature of quadratic expansion, which may constrain a model structure and computational resources. For example, an outer product of two feature vectors, both of which have 1K-dimensionality, produces a million-dimensional feature vector. Therefore, for classification problems, the choice of the number of target classes is severely constrained, because the number of parameters for a standard linear classifier is determined by multiplication of the size of the high-dimensional feature vector and the number of target classes. ",
+        "bbox": [
+            173,
+            750,
+            823,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Compact bilinear pooling (Gao et al., 2016) reduces the quadratic expansion of dimensionality by two orders of magnitude, retaining the performance of the full bilinear pooling. This approximation uses sampling-based computation, Tensor Sketch Projection (Charikar et al., 2002; Pham & Pagh, 2013), which utilizes an useful property that $\\Psi ( x \\otimes y , h , s ) = \\Psi ( x , h , s ) * \\Psi ( y , h , s )$ , which means the projection of outer product of two vectors is the convolution of two projected vectors. Here, $\\Psi$ is the proposed projection function, and, $h$ and $s$ are randomly sampled parameters by the algorithm. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nevertheless, compact bilinear pooling embraces two shortcomings. One comes from the sampling approach. Compact bilinear pooling relies on a favorable property, $E [ \\langle \\Psi ( x , h , s ) , \\Psi ( y , h , s ) \\rangle ] \\stackrel { - } { = }$ $\\langle { \\bar { x } } , y \\rangle$ , which provides a basis to use projected features instead of original features. Yet, calculating the exact expectation is computationally intractable, so, the random parameters, $h$ and $s$ are fixed during training and evaluation. This practical choice leads to the second. The projected dimension of compact bilinear pooling should be large enough to minimize the bias from the fixed parameters. Practical choices are 10K and 16K for 512 and 4096-dimensional inputs, respectively (Gao et al., 2016; Fukui et al., 2016). Though, these compacted dimensions are reduced ones by two orders of magnitude compared with full bilinear pooling, such high-dimensional features could be a bottleneck for computationally complex models. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose low-rank bilinear pooling using Hadamard product (element-wise multiplication), which is commonly used in various scientific computing frameworks as one of tensor operations. The proposed method factors a three-dimensional weight tensor for bilinear pooling into three twodimensional weight matrices, which enforces the rank of the weight tensor to be low-rank. As a result, two input feature vectors linearly projected by two weight matrices, respectively, are computed by Hadamard product, then, followed by a linear projection using the third weight matrix. For example, the projected vector $\\mathbf { z }$ is represented by $\\mathbf { W } _ { z } ^ { T } ( \\mathbf { \\bar { W } } _ { \\mathbf { x } } ^ { T } \\mathbf { x } \\circ \\mathbf { W } _ { \\mathbf { y } } ^ { T } \\mathbf { y } )$ , where $\\circ$ denotes Hadamard product. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We also explore to add non-linearity using non-linear activation functions into the low-rank bilinear pooling, and shortcut connections inspired by deep residual learning (He et al., 2016). Then, we show that it becomes a simple baseline model (Antol et al., 2015) or one-learning block of Multimodal Residual Networks (Kim et al., 2016b) as a low-rank bilinear model, yet, this interpretation has not be done. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            438
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are as follows: First, we propose low-rank bilinear pooling to approximate full bilinear pooling to substitute compact bilinear pooling. Second, Multimodal Low-rank Bilinear Attention Networks (MLB) having an efficient attention mechanism using low-rank bilinear pooling is proposed for visual question-answering tasks. MLB achieves a new state-of-the-art performance, and has a better parsimonious property. Finally, ablation studies to explore alternative choices, e.g. network depth, non-linear functions, and shortcut connections, are conducted. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 LOW-RANK BILINEAR MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            457,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Bilinear models use a quadratic expansion of linear transformation considering every pair of features. ",
+        "bbox": [
+            174,
+            579,
+            820,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b2d37c1aa53127ee64092ac63a94e7823e9aca19d7706f5a4c637af482aed212.jpg",
+        "text": "$$\nf _ { i } = \\sum _ { j = 1 } ^ { N } \\sum _ { k = 1 } ^ { M } w _ { i j k } x _ { j } y _ { k } + b _ { i } = \\mathbf { x } ^ { T } \\mathbf { W } _ { i } \\mathbf { y } + b _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            608,
+            647,
+            654
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { x }$ and $\\mathbf { y }$ are input vectors, ${ \\bf W } _ { i } \\in \\mathbb { R } ^ { N \\times M }$ is a weight matrix for the output $f _ { i }$ , and $b _ { i }$ is a bias for the output $f _ { i }$ . Notice that the number of parameters is $L \\times ( N \\times M + 1 )$ including a bias vector b, where $L$ is the number of output features. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Pirsiavash et al. (2009) suggest a low-rank bilinear method to reduce the rank of the weight matrix $\\mathbf { W } _ { i }$ to have less number of parameters for regularization. They rewrite the weight matrix as $\\mathbf { W } _ { i } =$ $\\mathbf { U } _ { i } \\mathbf { V } _ { i } ^ { T }$ where $\\mathbf { U } _ { i } \\in \\mathbb { R } ^ { N \\times d }$ and $\\mathbf { V } _ { i } \\in \\mathbb { R } ^ { M \\times d }$ , which imposes a restriction on the rank of $\\mathbf { W } _ { i }$ to be at most $d \\leq \\operatorname* { m i n } ( N , M )$ . ",
+        "bbox": [
+            174,
+            707,
+            825,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on this idea, $f _ { i }$ can be rewritten as follows: ",
+        "bbox": [
+            174,
+            770,
+            500,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8ba30439def76dbdaae3686d1e9ce0183a81d8ca50e2570334a474435dd4529.jpg",
+        "text": "$$\nf _ { i } = \\mathbf { x } ^ { T } \\mathbf { W } _ { i } \\mathbf { y } + b _ { i } = \\mathbf { x } ^ { T } \\mathbf { U } _ { i } \\mathbf { V } _ { i } ^ { T } \\mathbf { y } + b _ { i } = \\mathbb { 1 } ^ { T } ( \\mathbf { U } _ { i } ^ { T } \\mathbf { x } \\circ \\mathbf { V } _ { i } ^ { T } \\mathbf { y } ) + b _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            787,
+            714,
+            806
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { 1 } \\in \\mathbb { R } ^ { d }$ denotes a column vector of ones, and $\\circ$ denotes Hadamard product. Still, we need two third-order tensors, $\\mathbf { U }$ and $\\mathbf { V }$ , for a feature vector f , whose elements are $\\{ f _ { i } \\}$ . To reduce the order of the weight tensors by one, we replace $\\mathbb { 1 }$ with $\\mathbf { P } \\in \\mathbb { R } ^ { d \\times c }$ and $b _ { i }$ with $\\mathbf { b } \\in \\mathbb { R } ^ { c }$ , then, redefine as ${ \\bf U } \\in \\mathbb { R } ^ { N \\times d }$ and $\\mathbf { V } \\in \\mathbb { R } ^ { M \\times d }$ to get a projected feature vector $\\mathbf { f } \\in \\mathbb { R } ^ { c }$ . Then, we get: ",
+        "bbox": [
+            173,
+            813,
+            825,
+            869
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b35d4f381a8613802c6e7a8eaa32ece584c94a7fdc512375af705b620af8fc5.jpg",
+        "text": "$$\n\\mathbf { f } = \\mathbf { P } ^ { T } ( \\mathbf { U } ^ { T } \\mathbf { x } \\circ \\mathbf { V } ^ { T } \\mathbf { y } ) + \\mathbf { b }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            872,
+            591,
+            891
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $d$ and $c$ are hyperparameters to decide the dimension of joint embeddings and the output dimension of low-rank bilinear models, respectively. ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 LOW-RANK BILINEAR POOLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            472,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A low-rank bilinear model in Equation 3 can be implemented using two linear mappings without biases for embedding two input vectors, Hadamard product to learn joint representations in a multiplicative way, and a linear mapping with a bias to project the joint representations into an output vector for a given output dimension. Then, we use this structure as a pooling method for deep neural networks. Now, we discuss possible variations of low-rank bilinear pooling based on this model inspired by studies of neural networks. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 FULL MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            232,
+            310,
+            247
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Equation 3, linear projections, $U$ and $V$ , can have their own bias vectors. As a result, linear models for each input vectors, $\\mathbf { x }$ and $\\mathbf { y }$ , are integrated in an additive form, called as full model for linear regression in statistics: ",
+        "bbox": [
+            173,
+            258,
+            825,
+            300
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/060811fc702dd44e96df44d884cd979f014c1548c72ec172e2418d9dcc7cbe00.jpg",
+        "text": "$$\n\\begin{array} { r } { \\begin{array} { c } { \\mathbf { f } = \\mathbf { P } ^ { T } \\big ( ( \\mathbf { U } ^ { T } \\mathbf { x } + \\mathbf { b } _ { x } \\big ) \\circ ( \\mathbf { V } ^ { T } \\mathbf { y } + \\mathbf { b } _ { y } ) \\big ) + \\mathbf { b } } \\\\ { = \\mathbf { P } ^ { T } ( \\mathbf { U } ^ { T } \\mathbf { x } \\circ \\mathbf { V } ^ { T } \\mathbf { y } + \\mathbf { U } ^ { T } \\mathbf { x } + \\mathbf { V } ^ { \\prime T } \\mathbf { y } ) + \\mathbf { b } ^ { \\prime } . } \\\\ { \\mathbf { J } ^ { \\prime T } = \\mathrm { d i a g } ( \\mathbf { b } _ { y } ) \\cdot \\mathbf { U } ^ { T } , \\mathbf { V } ^ { \\prime T } = \\mathrm { d i a g } ( \\mathbf { b } _ { x } ) \\cdot \\mathbf { V } ^ { T } , \\mathrm { a n d } \\ \\mathbf { b } ^ { \\prime } = \\mathbf { b } + \\mathbf { P } ^ { T } ( \\mathbf { b } _ { x } \\circ \\mathbf { b } _ { y } ) . } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            176,
+            301,
+            710,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 NONLINEAR ACTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            377,
+            392,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Applying non-linear activation functions may help to increase representative capacity of model. The first candidate is to apply non-linear activation functions right after linear mappings for input vectors. ",
+        "bbox": [
+            174,
+            404,
+            823,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e3f87de598c474780ba63f7337254c539d18f27d536c782a8eb440b9b0cec4d.jpg",
+        "text": "$$\n\\mathbf { f } = \\mathbf { P } ^ { T } \\big ( \\sigma ( \\mathbf { U } ^ { T } \\mathbf { x } ) \\circ \\sigma ( \\mathbf { V } ^ { T } \\mathbf { y } ) \\big ) + \\mathbf { b }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            434,
+            614,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma$ denotes an arbitrary non-linear activation function, which maps any real values into a finite interval, e.g. sigmoid or tanh. If two inputs come from different modalities, statistics of two inputs may be quite different from each other, which may result an interference. Since the gradient with respect to each input is directly dependent on the other input in Hadamard product of two inputs. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Additional applying an activation function after the Hadamard product is not appropriate, since activation functions doubly appear in calculating gradients. However, applying the activation function only after the Hadamard product would be alternative choice (We explore this option in Section 5) as follows: ",
+        "bbox": [
+            174,
+            518,
+            825,
+            574
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3991245d523220c91566d09eaab166e69961ce7e24b397cc5c2149fdef0db04d.jpg",
+        "text": "$$\n\\mathbf { f } = \\mathbf { P } ^ { T } \\sigma \\big ( \\mathbf { U } ^ { T } \\mathbf { x } \\circ \\mathbf { V } ^ { T } \\mathbf { y } \\big ) + \\mathbf { b } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            575,
+            598,
+            595
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that using the activation function in low-rank bilinear pooling can be found in an implementation of simple baseline for the VQA dataset (Antol et al., 2015) without an interpretation of low-rank bilinear pooling. However, notably, Wu et al. (2016c) studied learning behavior of multiplicative integration in RNNs with discussions and empirical evidences. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 SHORTCUT CONNECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            669,
+            390,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "When we apply two previous techniques, full model and non-linear activation, linear models of two inputs are nested by the non-linear activation functions. To avoid this unfortunate situation, we add shortcut connections as explored in residual learning (He et al., 2016). ",
+        "bbox": [
+            174,
+            695,
+            825,
+            737
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b64d3aea3793525d7a3e16fc54e72954c7bf4c32a561f69d396367f588230a3c.jpg",
+        "text": "$$\n\\mathbf { f } = \\mathbf { P } ^ { T } \\big ( \\sigma ( \\mathbf { U } ^ { T } \\mathbf { x } ) \\circ \\sigma ( \\mathbf { V } ^ { T } \\mathbf { y } ) \\big ) + h _ { x } ( \\mathbf { x } ) + h _ { y } ( \\mathbf { y } ) + \\mathbf { b }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            739,
+            674,
+            760
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $h _ { x }$ and $h _ { y }$ are shortcut mappings. For linear projection, the shortcut mappings are linear mappings. Notice that this formulation is a generalized form of the one-block layered MRN (Kim et al., 2016b). Though, the shortcut connections are not used in our proposed model, as explained in Section 6. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 MULTIMODAL LOW-RANK BILINEAR ATTENTION NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            717,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we apply low-rank bilinear pooling to propose an efficient attention mechanism for visual question-answering tasks, based on the interpretation of previous section. We assumed that inputs are a question embedding vector $\\mathbf { q }$ and a set of visual feature vectors $\\mathbf { F }$ over $S \\times S$ lattice space. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 LOW-RANK BILINEAR POOLING IN ATTENTION MECHANISM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            637,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Attention mechanism uses an attention probability distribution $\\alpha$ over $S \\times S$ lattice space. Here, using low-rank bilinear pooling, $\\alpha$ is defined as ",
+        "bbox": [
+            174,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d26281b6dc4975caf2cb42be3291c8a09cd926a8a49c2999336a19b0abcfd910.jpg",
+        "text": "$$\n\\alpha = \\mathrm { s o f t m a x } \\Big ( \\mathbf { P } _ { \\alpha } ^ { T } \\big ( \\sigma ( \\mathbf { U } _ { \\mathbf { q } } ^ { T } \\mathbf { q } \\cdot \\mathbb { 1 } ^ { T } ) \\circ \\sigma ( \\mathbf { V } _ { \\mathbf { F } } ^ { T } \\mathbf { F } ^ { T } ) \\big ) \\Big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            161,
+            656,
+            189
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha \\in \\mathbb { R } ^ { G \\times S ^ { 2 } }$ , $\\mathbf { P } _ { \\alpha } \\in \\mathbb { R } ^ { d \\times G }$ , $\\sigma$ is a hyperbolic tangent function, ${ \\bf U _ { q } } \\in \\mathbb { R } ^ { N \\times d }$ , ${ \\bf q } \\in \\mathbb { R } ^ { N }$ , $\\mathbb { 1 } \\in \\mathbb { R } ^ { S ^ { 2 } }$ , ${ \\bf V _ { F } } \\in \\mathbb { R } ^ { M \\times d }$ , and $\\mathbf { F } \\in \\mathbb { R } ^ { S ^ { 2 } \\times M }$ . If $G > 1$ , multiple glimpses are explicitly expressed as in Fukui et al. (2016), conceptually similar to Jaderberg et al. (2015). And, the softmax function applies to each row vector of $\\alpha$ . The bias terms are omitted for simplicity. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            255
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 MULTIMODAL LOW-RANK BILINEAR ATTENTION NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            270,
+            642,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Attended visual feature $\\hat { \\mathbf { v } }$ is a linear combination of $\\mathbf { F } _ { i }$ with coefficients $\\alpha _ { g , i }$ . Each attention probability distribution $\\alpha _ { g }$ is for a glimpse $g$ . For $G > 1$ , $\\hat { \\mathbf { v } }$ is the concatenation of resulting vectors $\\hat { \\mathbf { v } } _ { g }$ as ",
+        "bbox": [
+            174,
+            295,
+            823,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/334e708bd36ad81cd722a89136a921a113ccb06ebd4325ebfd669fed6de7f14e.jpg",
+        "text": "$$\n\\hat { \\mathbf { v } } = \\prod _ { g = 1 } ^ { G } \\sum _ { s = 1 } ^ { S ^ { 2 } } \\alpha _ { g , s } \\mathbf { F } _ { s }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            339,
+            566,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $| |$ denotes concatenation of vectors. The posterior probability distribution is an output of a softmax function, whose input is the result of another low-rank bilinear pooling of $\\mathbf { q }$ and $\\hat { \\mathbf { v } }$ as ",
+        "bbox": [
+            171,
+            390,
+            823,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7d94a3be2ec366015937f30f7a83c89469138999e83b1d6246d8cc76c8bc42b.jpg",
+        "text": "$$\n\\begin{array} { r } { p ( a | \\mathbf { q } , \\mathbf { F } ; \\Theta ) = \\underset { a \\in \\Omega } { \\mathrm { s o f t m a x } } \\left( \\mathbf { P } _ { o } ^ { T } \\big ( \\sigma ( \\mathbf { W } _ { \\mathbf { q } } ^ { T } \\mathbf { q } ) \\circ \\sigma ( \\mathbf { V } _ { \\hat { \\mathbf { v } } } ^ { T } \\hat { \\mathbf { v } } ) \\big ) \\right) } \\\\ { \\hat { a } = \\underset { a \\in \\Omega } { \\mathrm { a r g m a x } } p ( a | \\mathbf { q } , \\mathbf { F } ; \\Theta ) \\quad } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            421,
+            676,
+            476
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { a }$ denotes a predicted answer, $\\Omega$ is a set of candidate answers and $\\Theta$ is an aggregation of entire model parameters. ",
+        "bbox": [
+            171,
+            478,
+            825,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            326,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct six experiments to select the proposed model, Multimodal Low-rank Bilinear Attention Networks (MLB). Each experiment controls other factors except one factor to assess the effect on accuracies. Based on MRN (Kim et al., 2016b), we start our assessments with an initial option of $G = 1$ and shortcut connections of MRN, called as Multimodal Attention Residual Networks (MARN). Notice that we use one embeddings for each visual feature for better performance, based on our preliminary experiment (not shown). We attribute this choice to the attention mechanism for visual features, which provides more capacity to learn visual features. We use the same hyper-parameters of MRN (Kim et al., 2016b), without any explicit mention of this. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The VQA dataset (Antol et al., 2015) is used as a primary dataset, and, for data augmentation, question-answering annotations of Visual Genome (Krishna et al., 2016) are used. Validation is performed on the VQA test-dev split, and model comparison is based on the results of the VQA test-standard split. For the comprehensive reviews of VQA tasks, please refer to Wu et al. (2016a) and Kafle & Kanan (2016a). The details about preprocessing, question and vision embedding, and hyperparameters used in our experiments are described in Appendix A. The source code for the experiments is available in Github repository1. ",
+        "bbox": [
+            173,
+            675,
+            825,
+            773
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Number of Learning Blocks Kim et al. (2016b) argue that three-block layered MRN shows the best performance among one to four-block layered models, taking advantage of residual learning. However, we speculate that an introduction of attention mechanism makes deep networks hard to optimize. Therefore, we explore the number of learning blocks of MARN, which have an attention mechanism using low-rank bilinear pooling. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Number of Glimpses Fukui et al. (2016) show that the attention mechanism of two glimpses was an optimal choice. In a similar way, we assess one, two, and four-glimpse models. ",
+        "bbox": [
+            176,
+            872,
+            823,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1: The accuracies of our experimental model, Multimodal Attention Residual Networks (MARN), with respect to the number of learning blocks (L#), the number of glimpse (G#), the position of activation functions (tanh), answer sampling, shortcut connections, and data augmentation using Visual Genome dataset, for VQA test-dev split and Open-Ended task. Note that our proposed model, Multimodal Low-rank Bilinear Attention Networks (MLB) have no shortcut connections, compared with MARN. MODEL: model name, SIZE: number of parameters, ALL: overall accuracy in percentage, Y/N: yes/no, NUM: numbers, and ETC: others. Since Fukui et al. (2016) only report the accuracy of the ensemble model on the test-standard, the test-dev results of their single models are included in the last sector. Some figures have different precisions which are rounded. $^ *$ indicates the selected model for each experiment. ",
+        "bbox": [
+            173,
+            111,
+            825,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/65a519c64e15f98760a05ac16a1fef9b0faef3efd620c1d904939ba3cf174189.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>MODEL</td><td>SIZE</td><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td></tr><tr><td>MRN-L3</td><td>65.0M</td><td>61.68</td><td>82.28</td><td></td><td></td></tr><tr><td>MARN-L3</td><td>65.5M</td><td></td><td>82.31</td><td>38.82</td><td>49.25 50.83</td></tr><tr><td></td><td></td><td>62.37</td><td></td><td>38.06</td><td></td></tr><tr><td>MARN-L2</td><td>56.3M</td><td>63.92</td><td>82.88</td><td>37.98</td><td>53.59</td></tr><tr><td>* MARN-L1</td><td>47.0M</td><td>63.79</td><td>82.73</td><td>37.92</td><td>53.46</td></tr><tr><td>MARN-L1-G1</td><td>47.0M</td><td>63.79</td><td>82.73</td><td>37.92</td><td>53.46</td></tr><tr><td>* MARN-L1-G2</td><td>57.7M</td><td>64.53</td><td>83.41</td><td>37.82</td><td>54.43</td></tr><tr><td>MARN-L1-G4</td><td>78.9M</td><td>64.61</td><td>83.72</td><td>37.86</td><td>54.33</td></tr><tr><td>No Tanh</td><td>57.7M</td><td>63.58</td><td>83.18</td><td>37.23</td><td>52.79</td></tr><tr><td>* Before-Product</td><td>57.7M</td><td>64.53</td><td>83.41</td><td>37.82</td><td>54.43</td></tr><tr><td>After-Product</td><td>57.7M</td><td>64.53</td><td>83.53</td><td>37.06</td><td>54.50</td></tr><tr><td>Mode Answer</td><td>57.7M</td><td>64.53</td><td>83.41</td><td>37.82</td><td>54.43</td></tr><tr><td> * Sampled Answer</td><td>57.7M</td><td>64.80</td><td>83.59</td><td>38.38</td><td>54.73</td></tr><tr><td>Shortcut * No Shortcut</td><td>57.7M 51.9M</td><td>64.80</td><td>83.59</td><td>38.38</td><td>54.73</td></tr><tr><td>MLB</td><td>51.9M</td><td>65.08</td><td>84.14</td><td>38.21</td><td>54.87</td></tr><tr><td>MLB+VG</td><td>51.9M</td><td>65.08 65.84</td><td>84.14 83.87</td><td>38.21 37.87</td><td>54.87</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>56.76</td></tr><tr><td>MCB+Att (Fukui et al., 2016)</td><td>69.2M</td><td>64.2</td><td>82.2</td><td>37.7</td><td>54.8</td></tr><tr><td>MCB+Att+GloVe (Fukui et al., 2016) MCB+Att+Glove+VG (Fukui et al., 2016)</td><td>70.5M 70.5M</td><td>64.7 65.4</td><td>82.5 82.3</td><td>37.6 37.2</td><td>55.6 57.4</td></tr></table>",
+        "bbox": [
+            202,
+            255,
+            794,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Non-Linearity We assess three options applying non-linearity on low-rank bilinear pooling, vanilla, before Hadamard product as in Equation 5, and after Hadamard product as in Equation 6. ",
+        "bbox": [
+            176,
+            619,
+            823,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Answer Sampling VQA (Antol et al., 2015) dataset has ten answers from unique persons for each question, while Visual Genome (Krishna et al., 2016) dataset has a single answer for each question. Since difficult or ambiguous questions may have divided answers, the probabilistic sampling from the distribution of answers can be utilized to optimize for the multiple answers. An instance 2 can be found in Fukui et al. (2016). We simplify the procedure as follows: ",
+        "bbox": [
+            174,
+            664,
+            825,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dd21cccd5851abb531ae44700a090ca67b2e43b2fe64672d31f9202eab4a46e4.jpg",
+        "text": "$$\n\\begin{array} { r } { p ( a _ { 1 } ) = \\left\\{ \\begin{array} { l l } { | a _ { 1 } | / { \\Sigma _ { i } } | a _ { i } | , } & { \\mathrm { i f ~ } | a _ { 1 } | \\geq 3 } \\\\ { 0 , } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. } \\\\ { p ( a _ { 0 } ) = 1 - p ( a _ { 1 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            742,
+            617,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\left| a _ { i } \\right|$ denotes the number of unique answer $a _ { i }$ in a set of multiple answers, $a _ { 0 }$ denotes a mode, which is the most frequent answer, and $a _ { 1 }$ denotes the secondly most frequent answer. We define the divided answers as having at least three answers which are the secondly frequent one, for the evaluation metric of VQA (Antol et al., 2015), ",
+        "bbox": [
+            174,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/39d45e9d5b0382544583df7290403d063e0cc2ec58f9b04bbf20f320934bcf8e.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { a c c u r a c y } ( a _ { k } ) = \\operatorname* { m i n } \\left( | a _ { k } | / 3 , 1 \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            867,
+            609,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/36714d8f077dcf1d2aa170e2d71687dbd6937ad78779549d3a476e7c5fdf4c8b.jpg",
+        "table_caption": [
+            "Table 2: The VQA test-standard results to compare with state-of-the-art. Notice that these results are trained by provided VQA train and validation splits, without any data augmentation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">MODEL</td><td colspan=\"3\">Open-Ended</td><td colspan=\"2\">MC</td></tr><tr><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td><td>ALL</td></tr><tr><td>iBOWIMG (Zhou et al., 2015)</td><td>55.89</td><td></td><td>34.98</td><td>42.62</td><td></td></tr><tr><td>DPPnet (Noh et al., 2016)</td><td>57.36</td><td>76.76 80.28</td><td>36.92</td><td>42.24</td><td>61.97 62.69</td></tr><tr><td>Deeper LSTM+Normalized CNN (Antol et al., 2015)</td><td>58.16</td><td>80.56</td><td>36.53</td><td>43.73</td><td>63.09</td></tr><tr><td>SMem (Xu&amp; Saenko,2016)</td><td>58.24</td><td>80.80</td><td>37.53</td><td>43.48</td><td>1</td></tr><tr><td>Ask Your Neurons (Malinowski et al., 2016)</td><td>58.43</td><td>78.24</td><td>36.27</td><td>46.32</td><td></td></tr><tr><td>SAN (Yang et al., 2016)</td><td>58.85</td><td>79.11</td><td>36.41</td><td>46.42</td><td>=</td></tr><tr><td>D-NMN (Andreas et al., 2016)</td><td>59.44</td><td>80.98</td><td>37.48</td><td>45.81</td><td>=</td></tr><tr><td>ACK (Wu et al., 2016b)</td><td>59.44</td><td>81.07</td><td>37.12</td><td>45.83</td><td>=</td></tr><tr><td>FDA (Ilievski et al., 2016)</td><td>59.54</td><td>81.34</td><td></td><td></td><td>=</td></tr><tr><td>HYBRID (Kafle &amp; Kanan,2016b)</td><td>60.06</td><td>80.34</td><td>35.67 37.82</td><td>46.10</td><td>64.18</td></tr><tr><td>DMN+ (Xiong et al., 2016)</td><td>60.36</td><td></td><td></td><td>47.56</td><td>1</td></tr><tr><td></td><td></td><td>80.43</td><td>36.82</td><td>48.33</td><td>1</td></tr><tr><td>MRN (Kim et al., 2016b)</td><td>61.84</td><td>82.39</td><td>38.23</td><td>49.41</td><td>66.33</td></tr><tr><td>HieCoAtt (Lu et al., 2016)</td><td>62.06</td><td>79.95</td><td>38.22</td><td>51.95</td><td>66.07</td></tr><tr><td>RAU (Noh &amp; Han,2016)</td><td>63.2</td><td>81.7</td><td>38.2</td><td>52.8</td><td>67.3</td></tr><tr><td>MLB (ours)</td><td>65.07</td><td>84.02</td><td>37.90</td><td>54.77</td><td>68.89</td></tr></table>",
+        "bbox": [
+            174,
+            145,
+            823,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The rate of the divided answers is approximately $1 6 . 4 0 \\%$ , and only $0 . 2 3 \\%$ of questions have more than two divided answers in VQA dataset. We assume that it eases the difficulty of convergence without severe degradation of performance. ",
+        "bbox": [
+            176,
+            441,
+            823,
+            484
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Shortcut Connection The contribution of shortcut connections for residual learning is explored based on the observation of the competitive performance of single-block layered model. Since the usefulness of shortcut connections is linked to the network depth (He et al., 2016). ",
+        "bbox": [
+            174,
+            501,
+            825,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Data Augmentation The data augmentation with Visual Genome (Krishna et al., 2016) question answer annotations is explored. Visual Genome (Krishna et al., 2016) originally provides 1.7 Million visual question answer annotations. After aligning to VQA, the valid number of question-answering pairs for training is 837,298, which is for distinct 99,280 images. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            614
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            635,
+            282,
+            650
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The six experiments are conducted sequentially. Each experiment determines experimental variables one by one. Refer to Table 1, which has six sectors divided by mid-rules. ",
+        "bbox": [
+            173,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 SIX EXPERIMENT RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            403,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Number of Learning Blocks Though, MRN (Kim et al., 2016b) has the three-block layered architecture, MARN shows the best performance with two-block layered models $( 6 3 . 9 2 \\% )$ . For the multiple glimpse models in the next experiment, we choose one-block layered model for its simplicity to extend, and competitive performance $( 6 3 . 7 9 \\% )$ ). ",
+        "bbox": [
+            174,
+            738,
+            823,
+            794
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Number of Glimpses Compared with the results of Fukui et al. (2016), four-glimpse MARN $( 6 4 . 6 1 \\% )$ is better than other comparative models. However, for a parsimonious choice, two-glimpse MARN $( 6 4 . 5 3 \\% )$ is chosen for later experiments. We speculate that multiple glimpses are one of key factors for the competitive performance of MCB (Fukui et al., 2016), based on a large margin in accuracy, compared with one-glimpse MARN $( 6 3 . 7 9 \\%$ ). ",
+        "bbox": [
+            174,
+            809,
+            823,
+            880
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Non-Linearity The results confirm that activation functions are useful to improve performances. Surprisingly, there is no empirical difference between two options, before-Hadamard product and after-Hadamard product. This result may build a bridge to relate with studies on multiplicative integration with recurrent neural networks (Wu et al., 2016c). ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Answer Sampling Sampled answers $( 6 4 . 8 0 \\% )$ result better performance than mode answers $( 6 4 . 5 3 \\% )$ . It confirms that the distribution of answers from annotators can be used to improve the performance. However, the number of multiple answers is usually limited due to the cost of data collection. ",
+        "bbox": [
+            174,
+            148,
+            825,
+            205
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Shortcut Connection Though, MRN (Kim et al., 2016b) effectively uses shortcut connections to improve model performance, one-block layered MARN shows better performance without the shortcut connection. In other words, the residual learning is not used in our proposed model, MLB. It seems that there is a trade-off between introducing attention mechanism and residual learning. We leave a careful study on this trade-off for future work. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Data Augmentation Data augmentation using Visual Genome (Krishna et al., 2016) question answer annotations significantly improves the performance by $0 . 7 6 \\%$ in accuracy for VQA test-dev split. Especially, the accuracy of others (ETC)-type answers is notably improved from the data augmentation. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            366
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 COMPARISON WITH STATE-OF-THE-ART ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            383,
+            493,
+            398
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The comparison with other single models on VQA test-standard is shown in Table 2. The overall accuracy of our model is approximately $1 . 9 \\%$ above the next best model (Noh & Han, 2016) on the Open-Ended task of VQA. The major improvements are from yes-or-no (Y/N) and others (ETC)- type answers. In Table 3, we also report the accuracy of our ensemble model to compare with other ensemble models on VQA test-standard, which won 1st to 5th places in VQA Challenge $2 0 1 6 ^ { 3 }$ . We beat the previous state-of-the-art with a margin of $0 . 4 2 \\%$ . ",
+        "bbox": [
+            174,
+            411,
+            825,
+            494
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/331d7a2015f6e22609f4775336e707d1b56d3d5493a8e37608415c67b974c586.jpg",
+        "table_caption": [
+            "Table 3: The VQA test-standard results for ensemble models to compare with state-of-the-art. For unpublished entries, their team names are used instead of their model names. Some of their figures are updated after the challenge. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">MODEL</td><td colspan=\"4\">Open-Ended</td><td>MC</td></tr><tr><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td><td>ALL</td></tr><tr><td>RAU (Noh &amp; Han,2016)</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>64.12</td><td>83.33</td><td>38.02</td><td>53.37</td><td>67.34</td></tr><tr><td>MRN (Kim et al., 2016b)</td><td>63.18</td><td>83.16</td><td>39.14</td><td>51.33</td><td>67.54</td></tr><tr><td>DLAIT (not published)</td><td>64.83</td><td>83.23</td><td>40.80</td><td>54.32</td><td>68.30</td></tr><tr><td>Naver Labs (not published)</td><td>64.79</td><td>83.31</td><td>38.70</td><td>54.79</td><td>69.26</td></tr><tr><td>MCB (Fukui et al., 2016)</td><td>66.47</td><td>83.24</td><td>39.47</td><td>58.00</td><td>70.10</td></tr><tr><td>MLB (ours)</td><td>66.89</td><td>84.61</td><td>39.07</td><td>57.79</td><td>70.29</td></tr><tr><td>Human (Antol et al., 2015)</td><td>83.30</td><td>95.77</td><td>83.39</td><td>72.67</td><td>91.54</td></tr></table>",
+        "bbox": [
+            259,
+            568,
+            738,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            354,
+            782
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MRN (Kim et al., 2016b) proposes multimodal residual learning with Hadamard product of low-rank bilinear pooling. However, their utilization of low-rank bilinear pooling is limited to joint residual mapping function for multimodal residual learning. Higher-order Boltzmann Machines (Memisevic & Hinton, 2007; 2010) use Hadamard product to capture the interactions of input, output, and hidden representations for energy function. Wu et al. (2016c) propose the recurrent neural networks using Hadamard product to integrate multiplicative interactions among hidden representations in the model. For details of these related works, please refer to Appendix D. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            897
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Yet, compact bilinear pooling or multimodal compact bilinear pooling (Gao et al., 2016; Fukui et al., 2016) is worth to discuss and carefully compare with our method. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7.1 COMPACT BILINEAR POOLING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            147,
+            426,
+            162
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Compact bilinear pooling (Gao et al., 2016) approximates full bilinear pooling using a samplingbased computation, Tensor Sketch Projection (Charikar et al., 2002; Pham & Pagh, 2013): ",
+        "bbox": [
+            176,
+            174,
+            823,
+            203
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc422de782a23638ed0cca09ad7c6f7f2cf6eb71f7a96066a62990e5f546f874.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\Psi ( x \\otimes y , h , s ) = \\Psi ( x , h , s ) * \\Psi ( y , h , s ) } \\\\ & { \\qquad = \\mathrm { F F T } ^ { - 1 } ( \\mathrm { F F T } ( \\Psi ( x , h , s ) \\circ \\mathrm { F F T } ( \\Psi ( y , h , s ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            204,
+            697,
+            244
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\otimes$ denotes outer product, $^ *$ denotes convolution, $\\begin{array} { r } { \\Psi ( v , h , s ) _ { i } : = \\sum _ { j : h _ { j } = i } s _ { j } \\cdot v _ { j } } \\end{array}$ , FFT denotes Fast Fourier Transform, $d$ denotes an output dimension, $x , y , h , s \\in \\mathbb { R } ^ { n }$ , $x$ and $y$ are inputs, and $h$ and $s$ are random variables. $h _ { i }$ is sampled from $\\{ 1 , . . . , d \\}$ , and $s _ { i }$ is sampled from $\\{ - 1 , 1 \\}$ , then, both random variables are fixed for further usage. Even if the dimensions of $x$ and $y$ are different from each other, it can be used for multimodal learning (Fukui et al., 2016). ",
+        "bbox": [
+            174,
+            244,
+            825,
+            318
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Similarly to Equation 1, compact bilinear pooling can be described as follows: ",
+        "bbox": [
+            176,
+            324,
+            687,
+            339
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/454c8c92ce8e695867f3597dbe5dbc3a6d3717c2211cf520ca35625976b0df13.jpg",
+        "text": "$$\nf _ { i } = \\mathbf { x } ^ { T } \\mathcal { W } _ { i } \\mathbf { y }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            454,
+            342,
+            545,
+            359
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { W } _ { i j k } = s _ { i j k } w _ { i j k }$ if $s _ { i j k }$ is sampled from $\\{ - 1 , 1 \\}$ , $w _ { i j k }$ is sampled from $\\{ \\mathbf { P } _ { i 1 } , \\mathbf { P } _ { i 2 } , \\dots , \\mathbf { P } _ { i d } \\}$ , and the compact bilinear pooling is followed by a fully connected layer $\\mathbf { P } \\in \\mathbb { R } ^ { | \\Omega | \\times d }$ . Then, this method can be formulated as a hashing trick (Weinberger et al., 2009; Chen et al., 2015) to share randomly chosen bilinear weights using $d$ parameters for a output value, in a way that a single parameter is shared by $N M / d$ bilinear terms in expectation, with the variance of $\\dot { N } M ( d - 1 ) \\big / { d ^ { 2 } }$ (See Appendix B). ",
+        "bbox": [
+            174,
+            362,
+            825,
+            449
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In comparison with our method, their method approximates a three-dimensional weight tensor in bilinear pooling with a two-dimensional matrix $\\mathbf { P }$ , which is larger than the concatenation of three two-dimensional matrices for low-rank bilinear pooling. The ratio of the number of parameters for a single output to the total number of parameters for $| \\Omega |$ outputs is $d / d | \\Omega | = 1 / | \\Omega |$ (Fukui et al., 2016), vs. $d ( N + M + 1 ) / d ( N + M + | \\Omega | ) = ( N + M + 1 ) / ( N + M + | \\Omega | ) \\approx 2 / 3$ (ours), since our method uses a three-way factorization. Hence, more parameters are allocated to each bilinear approximation than compact bilinear pooling does, effectively managing overall parameters guided by back-propagation algorithm. ",
+        "bbox": [
+            173,
+            455,
+            825,
+            566
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "MCB (Fukui et al., 2016), which uses compact bilinear pooling for multimodal tasks, needs to set the dimension of output $d$ to 16K, to reduce the bias induced by the fixed random variables $h$ and $s$ . As a result, the majority of model parameters $( 1 6 \\mathsf { K } \\times 3 \\mathsf { K } = 4 8 \\mathsf { M } )$ are concentrated on the last fully connected layer, which makes a fan-out structure. So, the total number of parameters of MCB is highly sensitive to the number of classes, which is approximately $6 9 . 2 \\mathbf { M }$ for $M C B + a t t$ , and $7 0 . 5 \\mathbf { M }$ for $M C B + a t t + G l o V e$ . Yet, the total number of parameters of our proposed model (MLB) is 51.9M, which is more robust to the number of classes having $d = 1 . 2 \\mathrm { K }$ , which has a similar role in model architecture. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            684
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            704,
+            328,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We suggest a low-rank bilinear pooling method to replace compact bilinear pooling, which has a fan-out structure, and needs complex computations. Low-rank bilinear pooling has a flexible structure using linear mapping and Hadamard product, and a better parsimonious property, compared with compact bilinear pooling. We achieve new state-of-the-art results on the VQA dataset using a similar architecture of Fukui et al. (2016), replacing compact bilinear pooling with low-rank bilinear pooling. We believe our method could be applicable to other bilinear learning tasks. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            834,
+            326,
+            848
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank Patrick Emaase for helpful comments and editing. Also, we are thankful to anonymous reviewers who provided comments to improve this paper. This work was supported by NAVER LABS Corp. & NAVER Corp. and partly by the Korea government (IITP-R0126-16-1072-SW.StarLab, KEIT10044009-HRI.MESSI, KEIT-10060086-RISF, ADD-UD130070ID-BMRR). The part of computing resources used in this study was generously shared by Standigm Inc. ",
+        "bbox": [
+            174,
+            857,
+            823,
+            921
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Learning to Compose Neural Networks for Question Answering. arXiv preprint arXiv:1601.01705, 2016. ",
+        "bbox": [
+            173,
+            125,
+            823,
+            151
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence Zitnick, and Devi Parikh. VQA: Visual Question Answering. IEEE International Conference on Computer Vision, 2015. ",
+        "bbox": [
+            176,
+            159,
+            821,
+            186
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Moses Charikar, Kevin Chen, and Martin Farach-Colton. Finding frequent items in data streams. In International Colloquium on Automata, Languages, and Programming, pp. 693–703. Springer, 2002. ",
+        "bbox": [
+            173,
+            194,
+            821,
+            220
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wenlin Chen, James T. Wilson, Stephen Tyree, Kilian Q. Weinberger, and Yixin Chen. Compressing Neural Networks with the Hashing Trick. In 32nd International Conference on Machine Learning, pp. 2285–2294, 2015. ",
+        "bbox": [
+            174,
+            228,
+            821,
+            267
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger ¨ Schwenk, and Yoshua Bengio. Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation. In 2014 Conference on Empirical Methods in Natural Language Processing, pp. 1724–1734, 2014. ",
+        "bbox": [
+            173,
+            276,
+            825,
+            328
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Akira Fukui, Dong Huk Park, Daylen Yang, Anna Rohrbach, Trevor Darrell, and Marcus Rohrbach. Multimodal Compact Bilinear Pooling for Visual Question Answering and Visual Grounding. arXiv preprint arXiv:1606.01847, 2016. ",
+        "bbox": [
+            173,
+            337,
+            823,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal. A Theoretically Grounded Application of Dropout in Recurrent Neural Networks. arXiv preprint arXiv:1512.05287, 2015. ",
+        "bbox": [
+            173,
+            383,
+            821,
+            410
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yang Gao, Oscar Beijbom, Ning Zhang, and Trevor Darrell. Compact Bilinear Pooling. In IEEE Conference on Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            173,
+            417,
+            823,
+            445
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In IEEE Conference on Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            174,
+            454,
+            823,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural computation, 9(8):1735–1780, 1997. ",
+        "bbox": [
+            174,
+            488,
+            823,
+            515
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ilija Ilievski, Shuicheng Yan, and Jiashi Feng. A Focused Dynamic Attention Model for Visual Question Answering. arXiv preprint arXiv:1604.01485, 2016. ",
+        "bbox": [
+            173,
+            522,
+            821,
+            550
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, and Koray Kavukcuoglu. Spatial Transformer Networks. In Advances in Neural Information Processing Systems 28, pp. 2008–2016, 2015. ",
+        "bbox": [
+            174,
+            558,
+            821,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kushal Kafle and Christopher Kanan. Visual Question Answering: Datasets, Algorithms, and Future Challenges. arXiv preprint arXiv:1610.01465, 2016a. ",
+        "bbox": [
+            173,
+            593,
+            823,
+            619
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kushal Kafle and Christopher Kanan. Answer-Type Prediction for Visual Question Answering. IEEE Conference on Computer Vision and Pattern Recognition, pp. 4976–4984, 2016b. ",
+        "bbox": [
+            173,
+            627,
+            821,
+            655
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jin-Hwa Kim, Jeonghee Kim, Jung-Woo Ha, and Byoung-Tak Zhang. TrimZero: A Torch Recurrent Module for Efficient Natural Language Processing. In KIIS Spring Conference, volume 26, pp. 165–166, 2016a. ",
+        "bbox": [
+            173,
+            662,
+            823,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jin-Hwa Kim, Sang-Woo Lee, Dong-Hyun Kwak, Min-Oh Heo, Jeonghee Kim, Jung-Woo Ha, and Byoung-Tak Zhang. Multimodal Residual Learning for Visual QA. arXiv preprint arXiv:1606.01455, 2016b. ",
+        "bbox": [
+            174,
+            696,
+            823,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ryan Kiros, Yukun Zhu, Ruslan Salakhutdinov, Richard S. Zemel, Antonio Torralba, Raquel Urtasun, and Sanja Fidler. Skip-Thought Vectors. In Advances in Neural Information Processing Systems 28, pp. 3294–3302, 2015. ",
+        "bbox": [
+            173,
+            732,
+            825,
+            772
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A Shamma, Michael Bernstein, and Li Fei-Fei. Visual genome: Connecting language and vision using crowdsourced dense image annotations. arXiv preprint arXiv:1602.07332, 2016. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Leonard, Sagar Waghmare, Yang Wang, and Jin-Hwa Kim. rnn´ $:$ Recurrent Library for Torch. arXiv preprint arXiv:1511.07889, 2015. ",
+        "bbox": [
+            171,
+            827,
+            823,
+            854
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yu Lin, Aruni RoyChowdhury, and Subhransu Maji. Bilinear CNN Models for Fine-grained Visual Recognition. In IEEE International Conference on Computer Vision, pp. 1449–1457, 2015. ",
+        "bbox": [
+            174,
+            862,
+            823,
+            890
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical Question-Image Co-Attention for Visual Question Answering. arXiv preprint arXiv:1606.00061, 2016. ",
+        "bbox": [
+            173,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mateusz Malinowski, Marcus Rohrbach, and Mario Fritz. Ask Your Neurons: A Deep Learning Approach to Visual Question Answering. arXiv preprint arXiv:1605.02697, 2016.   \nRoland Memisevic and Geoffrey E Hinton. Unsupervised learning of image transformations. In IEEE Conference on Computer Vision and Pattern Recognition, 2007.   \nRoland Memisevic and Geoffrey E Hinton. Learning to represent spatial transformations with factored higherorder Boltzmann machines. Neural computation, 22(6):1473–1492, 2010.   \nHyeonwoo Noh and Bohyung Han. Training Recurrent Answering Units with Joint Loss Minimization for VQA. arXiv preprint arXiv:1606.03647, 2016.   \nHyeonwoo Noh, Paul Hongsuck Seo, and Bohyung Han. Image Question Answering using Convolutional Neural Network with Dynamic Parameter Prediction. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.   \nNinh Pham and Rasmus Pagh. Fast and scalable polynomial kernels via explicit feature maps. In 19th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 239–247. ACM, 2013.   \nHamed Pirsiavash, Deva Ramanan, and Charless C. Fowlkes. Bilinear classifiers for visual recognition. In Advances in Neural Information Processing Systems 22, pp. 1482–1490, 2009.   \nJoshua B Tenenbaum and William T Freeman. Separating style and content with bilinear models. Neural computation, 12(6):1247–1283, 2000.   \nTijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 4, 2012.   \nKilian Weinberger, Anirban Dasgupta, John Langford, Alex Smola, and Josh Attenberg. Feature hashing for large scale multitask learning. In 26th International Conference on Machine Learning, pp. 1113–1120, 2009.   \nQi Wu, Damien Teney, Peng Wang, Chunhua Shen, Anthony Dick, and Anton van den Hengel. Visual Question Answering: A Survey of Methods and Datasets. arXiv preprint arXiv:1607.05910, 2016a.   \nQi Wu, Peng Wang, Chunhua Shen, Anthony Dick, and Anton van den Hengel. Ask Me Anything: Free-form Visual Question Answering Based on Knowledge from External Sources. In IEEE Conference on Computer Vision and Pattern Recognition, 2016b.   \nYuhuai Wu, Saizheng Zhang, Ying Zhang, Yoshua Bengio, and Ruslan Salakhutdinov. On Multiplicative Integration with Recurrent Neural Networks. arXiv preprint arXiv:1606.06630, 2016c.   \nCaiming Xiong, Stephen Merity, and Richard Socher. Dynamic Memory Networks for Visual and Textual Question Answering. In 33rd International Conference on Machine Learning, 2016.   \nHuijuan Xu and Kate Saenko. Ask, Attend and Answer: Exploring Question-Guided Spatial Attention for Visual Question Answering. In European Conference on Computer Vision, 2016.   \nZichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alex Smola. Stacked Attention Networks for Image Question Answering. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.   \nBolei Zhou, Yuandong Tian, Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Simple Baseline for Visual Question Answering. arXiv preprint arXiv:1512.02167, 2015. ",
+        "bbox": [
+            171,
+            88,
+            828,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Appendix ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            272,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENT DETAILS ",
+        "bbox": [
+            176,
+            137,
+            400,
+            154
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 PREPROCESSING ",
+        "bbox": [
+            176,
+            167,
+            334,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We follow the preprocessing procedure of Kim et al. (2016b). Here, we remark some details of it, and changes. ",
+        "bbox": [
+            176,
+            194,
+            821,
+            207
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1.1 QUESTION EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            222,
+            398,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The $9 0 . 4 5 \\%$ of questions for the 2K-most frequent answers are used. The vocabulary size of questions is 15,031. GRU (Cho et al., 2014) is used for question embedding. Based on earlier studies (Noh et al., 2016; Kim et al., 2016b), a word embedding matrix and a GRU are initialized with Skip-thought Vector pre-trained model (Kiros et al., 2015). As a result, question vectors have 2,400 dimensions. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            296
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For efficient computation of variable-length questions, Kim et al. (2016a) is used for the GRU. Moreover, for regularization, Bayesian Dropout (Gal, 2015) which is implemented in Leonard et al. (2015) is applied while ´ training. ",
+        "bbox": [
+            174,
+            303,
+            823,
+            342
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 VISION EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            358,
+            361,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ResNet-152 networks (He et al., 2016) are used for feature extraction. The dimensionality of an input image is $3 \\times 4 4 8 \\times 4 4 8$ . The outputs of the last convolution layer is used, which have $2 , 0 4 8 \\times 1 4 \\times 1 4$ dimensions. ",
+        "bbox": [
+            173,
+            383,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.3 HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            426,
+            361,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The hyperparameters used in MLB of Table 2 are described in Table 4. The batch size is 100, and the number of iterations is fixed to 250K. For data augmented models, a simplified early stopping is used, starting from 250K to 350K-iteration for every 25K iterations (250K, 275K, 300K, 325K, and 350K; at most five points) to avoid exhaustive submissions to VQA test-dev evaluation server. RMSProp (Tieleman & Hinton, 2012) is used for optimization. ",
+        "bbox": [
+            173,
+            452,
+            825,
+            515
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Though, the size of joint embedding size $d$ is borrowed from Kim et al. (2016b), a grid search on $d$ confirms this choice in our model as shown in Table 5. ",
+        "bbox": [
+            174,
+            522,
+            823,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/d46fa5d178a9e387878de5f386c3f643d9ef9d1c32e9047196113e24691a5984.jpg",
+        "table_caption": [
+            "Table 4: Hyperparameters used in MLB (single model in Table 2). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SYMBOL</td><td>VALUE</td><td>DESCRIPTION</td></tr><tr><td>S</td><td>14</td><td></td></tr><tr><td>N</td><td>2,400</td><td>attention lattice size</td></tr><tr><td>M</td><td>2.048</td><td>question embedding size channel size of extracted visual features</td></tr><tr><td>d</td><td>1,200</td><td>joint embedding size</td></tr><tr><td>G</td><td>2</td><td>number of glimpses</td></tr><tr><td>||</td><td>2,000</td><td>number of candidate answers</td></tr><tr><td>n</td><td>3e-4</td><td>learning rate</td></tr><tr><td>入</td><td>0.99997592083</td><td>learning rate decay factor at every iteration</td></tr><tr><td>p</td><td>0.5</td><td>dropout rate</td></tr><tr><td>0</td><td>±10</td><td>gradient clipping threshold</td></tr></table>",
+        "bbox": [
+            243,
+            588,
+            754,
+            761
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.4 MODEL SCHEMA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            336,
+            806
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows a schematic diagram of MLB, where ◦ denotes Hadamard product, and $\\Sigma$ denotes a linear combination of visual feature vectors using coefficients, which is the output of softmax function. If $G > 1$ , the softmax function is applied to each row vectors of an output matrix (Equation 8), and we concatenate the resulting vectors of the $G$ linear combinations (Equation 9). ",
+        "bbox": [
+            173,
+            818,
+            825,
+            868
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.5 ENSEMBLE OF SEVEN MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            885,
+            434,
+            898
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The test-dev results for individual models consisting of our ensemble model is presented in Table 6. ",
+        "bbox": [
+            169,
+            910,
+            759,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/eb986d5b7bf606642a8131d239994b8e4f237ef2b14992ff1d57cf5c547d4b89.jpg",
+        "table_caption": [
+            "Table 5: The effect of joint embedding size $d$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"6\">Open-Ended</td></tr><tr><td>d</td><td>SIZE</td><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td></tr><tr><td>800</td><td>45.0M</td><td>64.89</td><td>84.08</td><td>38.15</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>54.55</td></tr><tr><td>1000</td><td>48.4M</td><td>65.06</td><td>84.18</td><td>38.01</td><td>54.85</td></tr><tr><td>1200</td><td>51.9M</td><td>65.08</td><td>84.14</td><td>38.21</td><td>54.87</td></tr><tr><td>1400</td><td>55.4M</td><td>64.94</td><td>84.13</td><td>38.00</td><td>54.64</td></tr><tr><td>1600</td><td>58.8M</td><td>65.02</td><td>84.15</td><td>37.79</td><td>54.85</td></tr></table>",
+        "bbox": [
+            328,
+            132,
+            671,
+            252
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/02dfd00cc4bb19b3dfb924b4f29abc92eecf2d16eabbc678aa69dd6173ad0cbb.jpg",
+        "image_caption": [
+            "Figure 1: A schematic diagram of MLB. Replicate module copies an question embedding vector to match with $S ^ { 2 }$ visual feature vectors. Conv modules indicate $1 \\times 1$ convolution to transform a given channel space, which is computationally equivalent to linear projection for channels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            382,
+            273,
+            612,
+            477
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/59c7b27d09854952ad8caf32f6d6123b9439ad5ea699b65669684bfb617ffad8.jpg",
+        "table_caption": [
+            "Table 6: The individual models used in our ensemble model in Table 3. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td colspan=\"4\">Open-Ended</td></tr><tr><td>MODEL</td><td>GLIMPSE</td><td>ALL</td><td>Y/N</td><td>NUM</td><td>ETC</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>MLB MLB</td><td>２2</td><td>64.89 65.08</td><td>84.13 84.14</td><td>37.85 38.21</td><td>54.57 54.87</td></tr><tr><td>MLB</td><td>4</td><td>65.01</td><td>84.09</td><td>37.66</td><td>54.88</td></tr><tr><td>MLB-VG</td><td>2</td><td>65.76</td><td>83.64</td><td>37.57</td><td>56.86</td></tr><tr><td>MLB-VG</td><td>2</td><td>65.84</td><td>83.87</td><td>37.87</td><td>56.76</td></tr><tr><td>MLB-VG</td><td>3</td><td>66.05</td><td>83.88</td><td>38.13</td><td>57.13</td></tr><tr><td>MLB-VG</td><td>4</td><td>66.09</td><td>83.59</td><td>38.32</td><td>57.42</td></tr><tr><td>Ensemble</td><td></td><td>66.77</td><td>84.54</td><td>39.21</td><td>57.81</td></tr></table>",
+        "bbox": [
+            294,
+            587,
+            705,
+            752
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B UNDERSTANDING OF MULTIMODAL COMPACT BILINEAR POOLING ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            102,
+            766,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, the algorithm of multimodal compact bilinear pooling (MCB) (Gao et al., 2016; Fukui et al., 2016) is described as a kind of hashing tick (Chen et al., 2015). ",
+        "bbox": [
+            168,
+            131,
+            823,
+            159
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { x } \\in \\mathbb { R } ^ { n _ { x } }$ and $\\mathbf { y } \\in \\mathbb { R } ^ { n _ { y } }$ are the given inputs, $\\Phi ( \\mathbf { x } , \\mathbf { y } ) \\in \\mathbb { R } ^ { d }$ is the output. Random variables $\\mathbf { h } _ { x } \\in \\mathbb { N } ^ { n _ { x } }$ and $\\mathbf { h } _ { y } \\in \\mathbb { N } ^ { n _ { y } }$ are uniformly sampled from $\\{ 1 , \\ldots , d \\}$ , and $\\mathbf { s } _ { x } \\in \\mathbb { Z } ^ { n _ { x } }$ and $\\mathbf { s } _ { y } \\in \\mathbb { Z } ^ { n _ { y } }$ are uniformly sampled from $\\{ - 1 , 1 \\}$ . Then, Count Sketch projection function $\\Psi$ (Charikar et al., 2002) projects $\\mathbf { x }$ and $\\mathbf { y }$ to intermediate representations $\\Psi ( \\mathbf { x } , \\mathbf { h } _ { \\boldsymbol { x } } , \\mathbf { s } _ { \\boldsymbol { x } } ) \\in \\mathbb { R } ^ { d }$ and $\\boldsymbol { \\Psi } ( \\mathbf { y } , \\mathbf { h } _ { y } , \\mathbf { s } _ { y } ) \\in \\mathbb { R } ^ { d }$ , which is defined as: ",
+        "bbox": [
+            173,
+            164,
+            825,
+            218
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fbe8230846887712b465fd3f9f98365e10eb1ce344236a1643fffe4797cbae29.jpg",
+        "text": "$$\n\\Psi ( \\mathbf { v } , \\mathbf { h } , \\mathbf { s } ) _ { i } : = \\sum _ { j : h _ { j } = i } s _ { j } \\cdot v _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            224,
+            584,
+            257
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Notice that both $\\mathbf { h }$ and s remain as constants after initialization (Fukui et al., 2016). ",
+        "bbox": [
+            174,
+            263,
+            666,
+            279
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The probability of $h _ { x j } = i$ and $h _ { y j } = i$ for the given $j$ is $1 / d ^ { 2 }$ . Hence, the expected number of bilinear terms in $\\Psi ( \\mathbf { x } , \\mathbf { h } _ { x } , \\mathbf { s } _ { x } ) _ { i } \\Psi ( \\mathbf { y } , \\mathbf { h } _ { y } , \\mathbf { s } _ { y } ) _ { i }$ is $\\dot { ( } n _ { x } n _ { y } ) / d ^ { 2 }$ . Since, the output $\\Phi ( \\mathbf { x } , \\mathbf { y } )$ is a result of circular convolution of $\\Psi ( \\mathbf { x } , \\mathbf { h } _ { x } , \\mathbf { s } _ { x } )$ and $\\Psi ( \\mathbf { y } , \\mathbf { h } _ { y } , \\mathbf { s } _ { y } )$ , the expected number of bilinear terms in $\\Phi ( \\mathbf { x } , \\mathbf { y } ) _ { i }$ is $( n _ { x } n _ { y } ) / d$ . Likewise, the probability of that a bilinear term is allocated in $\\Phi ( \\mathbf { x } , \\mathbf { y } ) _ { i }$ is $1 / d$ . The probability distribution of the number of bilinear terms in $\\Phi ( \\mathbf { x } , \\mathbf { y } ) _ { i }$ follows a multinomial distribution, whose mean is $( n _ { x } n _ { y } ) / d$ and variance is $( n _ { x } n _ { y } ) ( d - 1 ) / d ^ { 2 }$ . ",
+        "bbox": [
+            174,
+            284,
+            825,
+            362
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Linear projection after the multimodal compact bilinear pooling provides weights on the bilinear terms, in a way that a shared weight is assigned to $\\Phi ( \\bar { \\mathbf { x } } , \\mathbf { y } ) _ { i }$ , which has $( n _ { x } n _ { y } ) / d$ bilinear terms in expectation, though each bilinear term can have a different sign induced by both ${ \\bf s } _ { x }$ and $\\mathbf { s } _ { y }$ . ",
+        "bbox": [
+            174,
+            367,
+            823,
+            406
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "HashedNets (Chen et al., 2015) propose a method to compress neural networks using a low-cost hashing function (Weinberger et al., 2009), which is the same function of $\\Psi ( \\mathbf { v } , \\mathbf { h } , \\mathbf { s } )$ . They randomly group a portion of connections in neural networks to share a single weight. We speculate that multimodal compact bilinear pooling uses the hashing tick to reduce the number of full bilinear weights with the rate of $d / ( n _ { x } n _ { y } )$ . However, this approximation is limited to two-way interaction, compared with three-way factorization in our method. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            477
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C REPLACEMENT OF LOW-RANK BILINEAR POOLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            633,
+            512
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the explicit comparison with compact bilinear pooling, we explicitly substitute compact bilinear pooling for low-rank bilinear pooling to control everything else, which means that the rest of the model architecture is exactly the same. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            564
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "According to Fukui et al. (2016), we use MCB followed by Signed Square Root, L2-Normalization, Dropout $( p { = } 0 . 1 )$ , and linear projection from 16,000-dimension to the target dimension. Also, Dropout $\\scriptstyle ( p = 0 . 3 )$ for a question embedding vector. Note that an overall architecture for multimodal learning of both is the same. Experimental details are referenced from the implementation 4 of Fukui et al. (2016). ",
+        "bbox": [
+            174,
+            571,
+            825,
+            623
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For test-dev split, our version of MCB gets $6 1 . 4 8 \\%$ for overall accuracy (yes/no: $8 2 . 4 8 \\%$ , number: $3 7 . 0 6 \\%$ , and other: $4 9 . 0 7 \\%$ ) vs. $6 5 . 0 8 \\%$ (ours, MLB in Table 1). Additionally, if the nonlinearity in getting attention distributions is increased as the original MCB does using ReLU, we get $6 2 . 1 1 \\%$ for overall accuracy (yes/no: $8 2 . 5 5 \\%$ , number: $3 7 . 1 8 \\%$ , and other: $5 0 . 3 0 \\%$ ), which is still the below of our performance 5. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            680
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We do not see it as a decisive evidence of the better performance of MLB, but as a reference (the comparison of test-dev results may be also unfair.), since an optimal architecture and hyperparameters may be required for each method. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            726
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            359,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D.1 MULTIMODAL RESIDUAL NETWORKS ",
+        "bbox": [
+            174,
+            132,
+            478,
+            147
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "MRN (Kim et al., 2016b) is an implicit attentional model using multimodal residual learning with Hadamard product which does not have any explicit attention mechanism. ",
+        "bbox": [
+            171,
+            157,
+            823,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c50150fab6ef77c2422cb6b008a4cbc1207405e61c2ef15be8a6d1e7dc07d82.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { F } ^ { ( k ) } ( \\mathbf { q } , \\mathbf { v } ) = \\sigma ( \\mathbf { W } _ { \\mathbf { q } } ^ { ( k ) } \\mathbf { q } ) \\circ \\sigma ( \\mathbf { W } _ { 2 } ^ { ( k ) } \\sigma ( \\mathbf { W } _ { 1 } ^ { ( k ) } \\mathbf { v } ) ) } \\\\ & { \\quad H _ { L } ( \\mathbf { q } , \\mathbf { v } ) = \\mathbf { W } _ { \\mathbf { q } ^ { \\prime } } \\mathbf { q } + \\displaystyle \\sum _ { l = 1 } ^ { L } \\mathbf { W } _ { \\mathcal { F } ^ { ( l ) } } \\mathcal { F } ^ { ( l ) } ( H _ { l - 1 } , \\mathbf { v } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            189,
+            650,
+            251
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W } _ { * }$ are parameter matrices, $L$ is the number of learning blocks, $H _ { 0 } = \\mathbf { q }$ , $\\mathbf { W _ { q ^ { \\prime } } } = \\Pi _ { l = 1 } ^ { L } \\mathbf { W } _ { \\mathbf { q ^ { \\prime } } } ^ { ( l ) }$ , an d $\\mathbf { W } _ { \\mathcal { F } ^ { ( l ) } } = \\Pi _ { m = l + 1 } ^ { L } \\mathbf { W } _ { \\mathbf { q } ^ { \\prime } } ^ { ( m ) }$ . Notice that these equations can be generalized by Equation 7. ",
+        "bbox": [
+            173,
+            258,
+            823,
+            292
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "However, an explicit attention mechanism allows the use of lower-level visual features than fully-connected layers, and, more importantly, spatially selective learning. Recent state-of-the-art methods use a variant of an explicit attention mechanism in their models (Lu et al., 2016; Noh & Han, 2016; Fukui et al., 2016). Note that shortcut connections of MRN are not used in the proposed Multimodal Low-rank Bilinear (MLB) model. Since, it does not have any performance gain due to not stacking multiple layers in MLB. We leave the study of residual learning for MLB for future work, which may leverage the excellency of bilinear models as suggested in Wu et al. (2016a). ",
+        "bbox": [
+            173,
+            299,
+            825,
+            388
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D.2 HIGHER-ORDER BOLTZMANN MACHINES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            404,
+            506,
+            419
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A similar model can be found in a study of Higher-Order Boltzmann Machines (Memisevic & Hinton, 2007; 2010). They suggest a factoring method for the three-way energy function to capture correlations among input, output, and hidden representations. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            468
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b351028567dbba996a1e46bd088b0ea51a306779526258d1e48ca33a3c82ad8b.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle - E ( { \\bf y } , { \\bf h } ; { \\bf x } ) = \\sum _ { f } \\big ( \\sum _ { i } x _ { i } w _ { i f } ^ { x } \\big ) \\big ( \\sum _ { j } y _ { j } w _ { j f } ^ { y } \\big ) \\big ( \\sum _ { k } h _ { k } w _ { k f } ^ { h } \\big ) + \\sum _ { k } w _ { k } ^ { h } h _ { k } + \\sum _ { j } w _ { j } ^ { y } y _ { j } } \\ ~ } \\\\ { { \\displaystyle = \\big ( { \\bf x } ^ { T } { \\bf W } ^ { x } \\circ { \\bf y } ^ { T } { \\bf W } ^ { y } \\circ { \\bf h } ^ { T } { \\bf W } ^ { h } \\big ) \\mathbb { 1 } + { \\bf h } ^ { T } { \\bf w } ^ { h } + { \\bf y } ^ { T } { \\bf w } ^ { y } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            473,
+            758,
+            529
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Setting aside of bias terms, the $I \\times J \\times K$ parameter tensor of unfactored Higher-Order Boltzmann Machines is replaced with three matrices, $\\mathbf { W } ^ { x } \\in \\mathbb { R } ^ { I \\times F }$ , $\\mathbf { W } ^ { y } \\in \\mathbb { R } ^ { J \\times F }$ , and $\\mathbf { W } ^ { h } \\in \\mathbb { R } ^ { K \\times F }$ . ",
+        "bbox": [
+            173,
+            531,
+            825,
+            559
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D.3 MULTIPLICATIVE INTEGRATION WITH RECURRENT NEURAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            722,
+            589
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Most of recurrent neural networks, including vanilla RNNs, Long Short Term Memory networks (Hochreiter & Schmidhuber, 1997) and Gated Recurrent Units (Cho et al., 2014), share a common expression as follows: ",
+        "bbox": [
+            174,
+            598,
+            826,
+            626
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/87149d3b06e1e8b424ec651d7e6b8705287b995cc7916b8520a6e9dca5464111.jpg",
+        "text": "$$\n\\phi ( \\mathbf { W _ { X } } + \\mathbf { U _ { h } } + \\mathbf { b } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            632,
+            560,
+            648
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $\\phi$ is a non-linear function, $\\mathbf { W } \\in \\mathbb { R } ^ { d \\times n }$ , $\\mathbf { x } \\in \\mathbb { R } ^ { n }$ , $\\mathbf { U } \\in \\mathbb { R } ^ { d \\times m }$ , $\\mathbf { h } \\in \\mathbb { R } ^ { m }$ , and $\\mathbf { b } \\in \\mathbb { R } ^ { d }$ is a bias vector.   \nNote that, usually, $\\mathbf { x }$ is an input state vector and $\\mathbf { h }$ is an hidden state vector in recurrent neural networks. ",
+        "bbox": [
+            171,
+            656,
+            823,
+            684
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Wu et al. (2016c) propose a new design to replace the additive expression with a multiplicative expression using Hadamard product as ",
+        "bbox": [
+            173,
+            689,
+            823,
+            717
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c3fd875faadbff8d6e6c5c89760f5548657003e5fff0040e525705721c7772b6.jpg",
+        "text": "$$\n\\phi ( \\mathbf { W } \\mathbf { x } \\circ \\mathbf { U } \\mathbf { h } + \\mathbf { b } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            723,
+            560,
+            739
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Moreover, a general formulation of this multiplicative integration can be described as ",
+        "bbox": [
+            173,
+            752,
+            678,
+            767
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/23f992f0a4704518394b815cb748c423b0a3e918dfc7ae7529a248fc764350bd.jpg",
+        "text": "$$\n\\phi ( \\pmb { \\alpha } \\circ \\mathbf { W } \\mathbf { x } \\circ \\mathbf { U } \\mathbf { h } + \\mathbf { W } \\mathbf { x } \\circ \\pmb { \\beta } _ { 1 } + \\mathbf { U } \\mathbf { h } \\circ \\pmb { \\beta } _ { 2 } + \\mathbf { b } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            773,
+            643,
+            789
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "which is reminiscent of full model in Section 3.1. ",
+        "bbox": [
+            174,
+            795,
+            464,
+            810
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rJg4YGWRb/rJg4YGWRb.md

@@ -0,0 +1,344 @@
+# ATTENTION-BASED GRAPH NEURAL NETWORK FORSEMI-SUPERVISED LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recently popularized graph neural networks achieve the state-of-the-art accuracy on a number of standard benchmark datasets for graph-based semi-supervised learning, improving significantly over existing approaches. These architectures alternate between a propagation layer that aggregates the hidden states of the local neighborhood and a fully-connected layer. Perhaps surprisingly, we show that a linear model, that removes all the intermediate fully-connected layers, is still able to achieve a performance comparable to the state-of-the-art models. This significantly reduces the number of parameters, which is critical for semi-supervised learning where number of labeled examples are small. This in turn allows a room for designing more innovative propagation layers. Based on this insight, we propose a novel graph neural network that removes all the intermediate fullyconnected layers, and replaces the propagation layers with attention mechanisms that respect the structure of the graph. The attention mechanism allows us to learn a dynamic and adaptive local summary of the neighborhood to achieve more accurate predictions. In a number of experiments on benchmark citation networks datasets, we demonstrate that our approach outperforms competing methods. By examining the attention weights among neighbors, we show that our model provides some interesting insights on how neighbors influence each other.
+
+# 1 INTRODUCTION
+
+One of the major bottlenecks in applying machine learning in practice is collecting sizable and reliable labeled data, essential for accurate predictions. One way to overcome the problem of limited labeled data is semi-supervised learning, using additional unlabeled data that might be freely available. In this paper, we are interested in a scenario when this additional unlabeled data is available in a form of a graph. The graph provides underlying pairwise relations among the data points, both labeled and unlabeled.
+
+Of particular interest are those applications where the presence or absence of an edge between two data points is determined by nature, for instance as a result of human activities or natural relations. As a concrete example, consider a citation network. Each node in the graph is a published research paper, associated with a bag-of-words feature vector. An (directed) edge indicates a citation link. Presence of an edge indicates that the authors of a paper have consciously determined to refer to the other paper, and hence captures some underlying relation that might not be inferred from the bag-of-words feature vectors alone. Such external graph data are available in several applications of interest, such as classifying users connected via a social network, items and customers connected by purchase history, users and movies connected by viewing history, and entities in a knowledge graph connected by relationships. In this paper, we are interested in the setting where the graph is explicitly given and represents additional information not present in the feature vectors.
+
+The goal of such graph-based semi-supervised learning problems is to classify the nodes in a graph using a small subset of labeled nodes and all the node features. There is a long line of literature on this topic since Blum & Chawla (2001) which seeks graph cuts that preserve the known labels and Zhu et al. (2003) which uses graph Laplacian to regularize the nearby nodes to have similar labels. However, Kipf & Welling (2016) recently demonstrated that the existing approaches can be significantly improved upon on a number of standard benchmark datasets, using an innovative neural network architecture on graph-based data known collectively as graph neural networks.
+
+Inspired by this success, we seek to understand the reason behind the power of graph neural networks, to guide our design of a novel architecture for semi-supervised learning on graphs. To this end, we first found that a linear classifier of multinomial logistic regression achieves the accuracy comparable to the best known graph neural network. This linear classifier removes all intermediate non-linear activation layers, and only keeps the linear propagation function from neighbors in graph neural networks. This suggests the importance of aggregation information form the neighbors in the graph. This further motivates us to design a new way of aggregating neighborhood information through attention mechanism since, intuitively, neighbors might not be equally important. This proposed attention-based graph neural network captures this intuition and $( a )$ greatly reduces the model complexity, with only a single scalar parameter at each intermediate layer; $( b )$ discovers dynamically and adaptively which nodes are relevant to the target node for classification; and $( c )$ improves upon state-of-the-art methods in terms of accuracy on standard benchmark datasets. Further, the learned attention strengths provide some form of interpretability. They provide insights on why a particular prediction is made on a target node and which neighbors are more relevant in making that decision.
+
+# 2 RELATED WORK
+
+Given a graph $G ( V , E )$ with a set of $n$ nodes $V$ and a set of edges $E$ , we let $X _ { i } \in \mathbb { R } ^ { d _ { x } }$ denote the feature vector at node $i$ and let $Y _ { i }$ denote the true label. We use $Y _ { L }$ to denote the labels that are revealed to us for a subset $L \subset V$ . We let $X = [ X _ { 1 } , \ldots , X _ { n } ]$ denote all features, labeled and unlabeled.
+
+Traditionally, semi-supervised learning using both labeled and un-labled data has been solved using two different approaches - Graph Laplacian based algorithms solving for locally consistent solutions (Zhou et al., 2004b) and Expectation Maximization based algorithms (Nigam et al., 2006) where true-labels of the unlabeled data points are considered as the latent variables of a generative model.
+
+Graph Laplacian regularization. Based on the assumption that nearby nodes in a graph are more likely to have the same labels, the graph information has been used as explicit regularization:
+
+$$
+\begin{array} { r c l } { { \mathcal L } ( X , Y _ { L } ) } & { { = } } & { { { \mathcal L } _ { \mathrm { l a b e l } } ( X _ { L } , Y _ { L } ) + \lambda { \mathcal L } _ { G } ( X ) ~ , } } \end{array}
+$$
+
+where $\begin{array} { r } { \mathcal { L } _ { \mathrm { l a b e l } } = \sum _ { i \in L } l ( Y _ { i } , f ( X _ { i } ) ) } \end{array}$ is the standard supervised loss for some loss functions $l$ and $\mathcal { L } _ { G }$ is the graph-based regularization, for example $\begin{array} { r } { \mathcal { L } _ { G } = \sum _ { ( i , j ) \in E } \| f ( X _ { i } ) - f ( X _ { j } ) \| ^ { 2 } } \end{array}$ , which is called the graph Laplacian regularization. Earlier approaches are non-parametric and searches over all $f$ considering it as a look-up table. Most popular one is the Label Propagation (Zhu & Ghahramani, 2002) that forces the estimated labels to agree in the labeled instances and uses weighted graph Laplacian. This innovative formulation admits a closed form solution which makes it practically attractive with very low computationally cost. ManiReg (Belkin et al., 2006) replaces supervised loss with that of a support vector machine. ICA (Lu & Getoor, 2003) generalizes LP by allowing more general local updates. A more thorough survey on using non-neural network methods for semi-supervised learning can be found in (Chapelle et al., 2009).
+
+More recent approaches are parametric, using deep neural networks. SemiEmb (Weston et al., 2012) was the first to use a deep neural network to model $f ( x )$ and minimize the above loss. Planetoid (Yang et al., 2016) significantly improves upon the existing graph regularization approaches by replacing the regularization by another loss based on skip-grams (defined below). In a slightly different context, Buchnik & Cohen (2017) show that the accuracy of these approaches can be further improved by bootstrapping these models sequentially.
+
+Unsupervised node embedding for semi-supervised learning. Several approaches have been proposed to embed the nodes in some latent Euclidean space using only the connectivity in graph $G$ . Once the embedding is learned, standard supervised learning is applied on those embedded features to train a model. Inspired by the success of word2vec (Le & Mikolov, 2014), several approaches define “skip-grams” on graphs as the neighborhood (context) of a node on the graph and tries to maximize the posterior probability of observing those skip-grams. DeepWalk (Perozzi et al., 2014) and node2vec (Grover & Leskovec, 2016) use random walks as skip-grams, LINE (Tang et al., 2015) uses local proximities, LASAGNE (Faerman et al., 2017) uses the Personalized PageRank random walk. Graph2Gauss (A. Bojchevski, 2017) represents a node as a Gaussian distribution, and minimizes the divergence between connected pairs. Yang et al. (2017) provide a post-processing scheme that takes any node embedding and attempts to improve it by by taking the weighted sum of the given embeddings with Personalized PageRank weights. The strength of these approaches is universality, as the node embedding does not depend on the particular task at hand (and in particular the features or the labels). However, as they do not use the node features and the training only happens after embedding, they cannot meet the performance of the state-of-the-art approaches (see DeepWalk in Table 2).
+
+Graph Neural Network (GNN). Graph neural networks are extensions of neural networks to structured data encoded as a graph. Originally introduced as extensions of recurrent neural networks, GNNs apply recurrent layers to each node with additional local averaging layer (Gori et al., 2005; Scarselli et al., 2009). However, as the weights are shared across all nodes, GNNs can also be interpreted as extensions of convolutional neural networks on a 2D grid to general graphs. Typically, a message aggregation step followed by some neural network architecture is iteratively applied. The model parameters are trained on (semi-)supervised examples with labels. We give a typical example of a GNN in Section 3, but several diverse variations have been proposed in (Bruna et al., 2013; Duvenaud et al., 2015; Li et al., 2015; Henaff et al., 2015; Sukhbaatar et al., 2016; Bronstein et al., 2016; Defferrard et al., 2016; Dai et al., 2016; Atwood & Towsley, 2016; Niepert et al., 2016; Such et al., 2017; Hamilton et al., 2017; Schlichtkrull et al., 2017; Such et al., 2017). GNNs have been successfully applied in diverse applications such as molecular activation prediction (Gilmer et al., 2017), community detection (Bruna & Li, 2017), matrix completion (Berg et al., 2017), combinatorial optimization (Dai et al., 2017; Nowak et al., 2017), and detecting similar binary codes (Xu et al., 2017).
+
+In particular, for the benchmark datasets that we consider in this paper, Kipf & Welling (2016) proposed a simple but powerful architecture called Graph Convolutional Network (GCN) that achieves the state-of-the-art accuracy. In the following section, $( a )$ we show that the performance of GCN can be met by a linear classifier; and $( b )$ use this insight to introduce novel graph neural networks that compare favourably against the state-of-the-art approaches on benchmark datasets.
+
+# 3 DISSECTION OF GRAPH NEURAL NETWORK
+
+In this section, we propose a novel Graph Neural Network (GNN) model which we call Attentionbased Graph Neural Network (AGNN), and compare its performance to state-of-the-art models on benchmark citation networks in Section 5. We seek a model $Z = f ( X , A ) \in \mathbb { R } ^ { n \times d _ { y } }$ that predicts at each node one of the $d _ { y }$ classes. $Z _ { i c }$ is the estimated probability that the label at node $i \in [ n ]$ is $c \in [ d _ { y } ]$ given the features $X$ and the graph $A$ . The data features $X \in \mathbb { R } ^ { n \times d _ { x } }$ has at each row $d _ { x }$ features for each node, and $A \in \{ 0 , 1 \} ^ { \bar { n } \times \bar { n } }$ is the adjacency matrix of $G$ .
+
+The forward pass in a typical GNN alternates between a propagation layer and a single layer perceptron. Let $t$ be the layer index. We use $H ^ { ( t ) } \in \mathbb { R } ^ { n \times d _ { h } }$ to denote the current (hidden) states, with the $i$ -th row $H _ { i } ^ { ( t ) }$ as the $d _ { h }$ dimensional hidden state of node $i$ . A propagation layer with respect to a propagation matrix $P \in \mathbb { R } ^ { n \times n }$ is defined as
+
+$$
+\tilde { H } ^ { ( t ) } = P H ^ { ( t ) } .
+$$
+
+For example, the natural random walk1 $P = D ^ { - 1 } A$ gives $\begin{array} { r } { \tilde { H } _ { i } ^ { ( t ) } = ( 1 / | N ( i ) | ) \sum _ { j \in N ( i ) } H _ { j } ^ { ( t ) } } \end{array}$ . The neighborhood of node $i$ is denoted by $N ( i )$ , and $D = \mathrm { d i a g ( A { \bf 1 } ) }$ . This is a simple local averaging common in consensus or random walk based approaches. Typical propagation layer respects the adjacency pattern in $A$ , performing a variation of such local averaging. GNNs encode the graph structure of $A$ into the model via this propagation layer, which can be also interpreted as performing a graph convolution operation as discussed in Kipf & Welling (2016). Next, a single layer perceptron is applied on each node separately and the weights $W ^ { ( t ) }$ are shared across all the nodes:
+
+$$
+{ \cal H } ^ { ( t + 1 ) } = \sigma ( \tilde { H } ^ { ( t ) } W ^ { ( t ) } ) \ ,
+$$
+
+where $W ^ { ( t ) } \in \mathbb { R } ^ { d _ { h _ { t + 1 } } \times d _ { h _ { t } } }$ is the weight matrix and $\sigma ( \cdot )$ is an entry-wise activation function. This weight sharing reduces significantly the number of parameters to be trained, and encodes the invariance property of graph data, i.e. two nodes that are far apart but have the similar neighboring features and structures should be classified similarly. There are several extensions to this model as discussed in the previous section, but this standard graph neural network has proved powerful in several problems over graphs, e.g. (Bruna & Li, 2017; Berg et al., 2017; Dai et al., 2017).
+
+Graph Convolutional Network (GCN). Kipf & Welling (2016) introduced a simple but powerful architecture, and achieved the state-of-the-art performance in benchmark citation networks (see Table 2). GCN is a special case of GNN which stacks two layers of specific propagation and perceptron:
+
+$$
+\begin{array} { r c l } { { { \cal H } ^ { ( 1 ) } } } & { { = } } & { { \mathrm { R e L U } \big ( ( P X ) { \cal W } ^ { ( 0 ) } \big ) ~ , } } \\ { { Z ~ = } } & { { f ( X , { \cal A } ) } } & { { = } } & { { \mathrm { s o f t m a x } \big ( ( P { \cal H } ^ { ( 1 ) } ) { \cal W } ^ { ( 1 ) } \big ) ~ , } } \end{array}
+$$
+
+with a choice of $P = \tilde { D } ^ { - 1 / 2 } \tilde { A } \tilde { D } ^ { - 1 / 2 }$ , where ${ \tilde { A } } = A + \mathbb { I }$ , I is the identity matrix, $\tilde { D } = \mathrm { d i a g } ( \tilde { A } \mathbf { 1 } )$ and $\mathbb { 1 }$ is the all-ones vector. $\mathrm { R e L U } ( a ) = \operatorname* { m a x } \{ 0 , a \}$ is an entry-wise rectified linear activation function, and softmax $\cdot ( [ a _ { 1 } , \dots , a _ { k } ] ) = ( 1 / Z ) [ \exp ( a _ { 1 } ) , \dots , \exp ( a _ { k } ) ]$ with $\begin{array} { r } { Z = \sum _ { i } \exp ( a _ { i } ) } \end{array}$ is applied rowwise. Hence, the output is the predicted likelihoods on the $d _ { y }$ dimensional probability simplex. The weights $W ^ { ( 0 ) }$ and $W ^ { ( 1 ) }$ are trained to minimize the cross-entropy loss over all labeled examples $L$ :
+
+$$
+\begin{array} { r c l } { \mathcal { L } } & { = } & { \displaystyle - \sum _ { i \in L } \sum _ { c = 1 } ^ { d _ { y } } Y _ { i c } \ln Z _ { i c } . } \end{array}
+$$
+
+Graph Linear Network (GLN). To better understand GCN, we remove the intermediate nonlinear activation units from GCN, which gives Graph Linear Network defined as
+
+$$
+\begin{array} { r c l } { { Z } } & { { = } } & { { f ( X , A ) } } & { { = } } & { { \mathrm { s o f t m a x } \big ( ( \mathrm { P ^ { 2 } X } ) { \mathrm { W } } ^ { ( 0 ) } { \mathrm { W } } ^ { ( 1 ) } \big ) \ , } } \end{array}
+$$
+
+with the same choice of $P = \tilde { D } ^ { - 1 / 2 } \tilde { A } \tilde { D } ^ { - 1 / 2 }$ as in GCN. The weights $W ^ { ( 0 ) }$ and $W ^ { ( 1 ) }$ have the same dimensions as GCN and are trained on a cross entropy loss in (2). The two propagation layers simply take (linear) local average of the raw features weighted by their degrees, and at the output layer a simple linear classifier (multinomial logistic regression) is applied. This allows us to separate the gain in the linear propagation layer and the non-linear perceptron layer.
+
+Comparing the differences in performances in Table 2, we show that, perhaps surprisingly, GLN achieves an accuracy comparable to the that of the best GNN, and sometimes better. This suggests that, for citation networks, the strength of the general GNN architectures is in the propagation layer and not in the perceptron layer. On the other hand, the propagation layers are critical in achieving the desired performance, as is suggested in Table 2. There are significant gaps in accuracy for those approaches not using the graph, i.e. T-SVM, and also those that use the graph differently, such as Label Propagation (LP) and Planetoid. Based on this observation, we propose replacing the propagation layer of GLN with an attention mechanism and test it on the benchmark datasets.
+
+# 4 ATTENTION-BASED GRAPH NEURAL NETWORK (AGNN).
+
+The original propagation layer in GCN and several other graph neural networks such as (Defferrard et al., 2016; Atwood & Towsley, 2016; Monti et al., 2016; Such et al., 2017) use a static (does not change over the layers) and non-adaptive (does not take into account the states of the nodes) propagation, e.g. $P _ { i j } = 1 / \sqrt { | N ( i ) | | N ( j ) | }$ . Such propagations are not able to capture which neighbor is more relevant to classifying a target node, which is critical in real data where not all edges imply the same types or strengths of relations.
+
+We need novel dynamic and adaptive propagation layers, capable of capturing the relevance of different edges, which leads to more complex graph neural networks with more parameters. However, training such complex models is challenging in the semi-supervised setting, as the typical number of samples we have for each class is small; it is 20 in the standard benchmark dataset. This is evidenced in Table 2 where more complex graph neural network models by Verma et al. (2017), Monti et al. (2016), and Such et al. (2017) do not improve upon the simple GCN.
+
+On the other hand, our experiments with GLN suggests that we can remove all the perceptron layers and focus only on improving the propagation layers. To this end, we introduce a novel Attentionbased Graph Neural Network (AGNN). AGNN is simple; it only has a single scalar parameter $\beta ^ { ( t ) }$ at each intermediate layer. AGNN captures relevance; the proposed attention mechanism over neighbors in (5) learns which neighbors are more relevant and weighs their contributions accordingly. This builds on the long line of successes of attention mechanisms in summarizing long sentences or large images, by capturing which word or part-of-image is most relevant ( $\mathrm { { X u } }$ et al., 2015; Graves et al., 2014; Bahdanau et al., 2014). Particularly, we use the attention formulation similar to the one used in Graves et al. (2014).2 It only has one parameter and we found this is important for successfully training the model when the number of labels is small as in our semi-supervised learning setting.
+
+# 4.1 AGNN MODEL
+
+We start with a word-embedding layer that maps a bag-of-words representation of a document into an averaged word embedding, and the word embedding $W ^ { ( 0 ) } \in \mathbb { R } ^ { d _ { x } \times d _ { h } }$ is to be trained as a part of the model:
+
+$$
+\begin{array} { r c l } { { H ^ { ( 1 ) } } } & { { = } } & { { \mathrm { R e L U } ( X W ^ { ( 0 ) } ) . } } \end{array}
+$$
+
+This is followed by layers of attention-guided propagation layers parameterized by $\beta ^ { ( t ) } \in \mathbb { R }$ at each layer,
+
+$$
+\begin{array} { r c l } { { H ^ { ( t + 1 ) } } } & { { = } } & { { P ^ { ( t ) } H ^ { ( t ) } , } } \end{array}
+$$
+
+where the propagation matrix $P ^ { ( t ) } \in \mathbb { R } ^ { n \times n }$ is also a function of the input states $H ^ { ( t ) }$ and is zero for absent edges such that the output row-vector of node $i$ is
+
+$$
+H _ { i } ^ { ( t + 1 ) } = \sum _ { j \in N ( i ) \cup \{ i \} } P _ { i j } ^ { ( t ) } H _ { j } ^ { ( t ) } ,
+$$
+
+with $P _ { i } ^ { ( t ) } = \mathrm { s o f t m a x } \Big ( [ \beta ^ { ( t ) } \cos ( H _ { i } ^ { ( t ) } , H _ { j } ^ { ( t ) } ) ] _ { j \in N ( i ) \cup \{ i \} } \Big )$ and $\cos ( x , y ) = x ^ { T } y / \| x \| \| y \|$ with the $L _ { 2 }$ norm $\lVert x \rVert$ , for $t \in \{ 1 , \ldots , \ell \}$ and an integer $\ell$ . Here $\ell$ is the number of propagation layers. Note that the new propagation above is dynamic; propagation changes over the layers with differing $\beta ^ { ( t ) }$ and also the hidden states. It is also adaptive; it learns to weight more relevant neighbors higher. We add the self-loop in the propagation to ensure that the features and the hidden states of the node itself are not lost in the propagation process. The output layer has a weight $W ^ { ( 1 ) } \in \mathbb { R } ^ { d _ { h } \times d _ { y } }$ :
+
+$$
+Z ~ = ~ f ( X , A ) ~ = ~ \mathrm { s o f t m a x } \big ( H ^ { ( \ell + 1 ) } W ^ { ( 1 ) } \big ) \ .
+$$
+
+The weights $W ^ { ( 0 ) } , W ^ { ( 1 ) }$ , and $\beta ^ { ( t ) }$ ’s are trained on a cross entropy loss in (2). To ease the notations, we have assumed that the input feature vectors to the first and last layers are augmented with a scalar constant of one, so that the standard bias term can be included in the parameters $W ^ { ( 0 ) }$ and $W ^ { ( 1 ) }$ .
+
+The softmax function at attention ensures that the propagation layer $P ^ { ( t ) }$ row-sums to one. The attention from node $j$ to node $i$ is
+
+$$
+\begin{array} { r c l } { P _ { i j } ^ { ( t ) } } & { = } & { ( 1 / C ) e ^ { \beta ^ { ( t ) } \cos ( H _ { i } ^ { ( t ) } , H _ { j } ^ { ( t ) } ) } , } \end{array}
+$$
+
+$\begin{array} { r } { C = \sum _ { j \in N ( i ) \cup \{ i \} } e ^ { \beta ^ { ( t ) } \cos ( H _ { i } ^ { ( t ) } , H _ { j } ^ { ( t ) } ) } } \end{array}$ eβ(t) cos(H(t)i ,H(t)j ) which captures how relevant j is to i, as measured by the cosine of the angle between the corresponding hidden states. We show how we can interpret the attentions in Section 5.2 and show that the attention selects neighbors with the same class to be more relevant. On the standard benchmark datasets on citation networks, we show in Section 5 that this architecture achieves the best performance in Table 2.
+
+Here we note that independently from this work attention over sets has been proposed as “neighborhood attention” (Duan et al., 2017; Hoshen, 2017) for a different application. The main difference of AGNN with respect to these work is the fact that in AGNN attention is computed over a neighborhood of a node on a graph, whereas in these work attention over set of all entities is used to construct a “soft neighborhood”.
+
+# 5 EXPERIMENTS ON BENCHMARK CITATION NETWORKS
+
+On standard benchmark datasets of three citation networks, we test our proposed AGNN model on semi-supervised learning tasks. We test on a fixed split of labeled/validation/test sets from Yang et al. (2016) and compare against baseline methods in Table 2. We also test it on random splits of the same sizes in Table 3, and random splits with larger number of labeled nodes in Table 4.
+
+Benchmark Datasets. A citation network dataset consists of documents as nodes and citation links as directed edges. Each node has a human annotated topic from a finite set of classes and a feature vector. We consider three datasets3. For CiteSeer and Cora datasets, the feature vector has binary entries indicating the presence/absence of the corresponding word from a dictionary. For PubMed dataset, the feature vector has real-values entries indicating Term Frequency-Inverse Document Frequency (TF-IDF) of the corresponding word from a dictionary. Although the networks are directed, we use undirected versions of the graphs for all experiments, as is common in all baseline approaches.
+
+Labeled nodes   
+Table 1: Citation Network Dataset   
+
+<table><tr><td>Dataset</td><td>Nodes</td><td>Edges</td><td>Classes</td><td>Features</td><td>Table 2</td><td>Table 3</td><td>Table 4</td><td></td></tr><tr><td>CiteSeer</td><td>3,327</td><td>4,732</td><td>6</td><td>3,703</td><td>120</td><td>120</td><td>2,218</td><td>2,994</td></tr><tr><td>Cora</td><td>2,708</td><td>5,429</td><td>7</td><td>1,433</td><td>140</td><td>140</td><td>1,805</td><td>2,437</td></tr><tr><td>PubMed</td><td>19,717</td><td>44,328</td><td>3</td><td>500</td><td>60</td><td>60</td><td>13,145</td><td>17,745</td></tr></table>
+
+Experimental setup. The accuracy of the baseline methods are all taken from existing literature. If a baseline result is not reported in the existing literature, we intentionally left those cells empty in the table for fairness, as opposed to running those experiments ourselves on untuned hyperparameters. We train and test only the two models we propose: GLN for comparisons and our proposed AGNN model. We do not use the validation set labels in training, but use them for optimizing hyperparameters like dropout rate, learning rate, and $L _ { 2 }$ -regularization factor. For AGNN, we use a fixed number of $d _ { h } = 1 6$ units in the hidden layers and use 4 propagation layers $\ell = 4$ ) for CiteSeer and Pubmed and 3 propagation layers $\ell = 3$ ) for Cora as defined in (7). For GLN, we use 2 propagation layers as defined in (1). We row-normalize the input feature vectors, as is standard in the literature. The tables below show the average accuracy with the standard error over 100 training instances with random weight initializations. We implement our model on TensorFlow (Abadi et al., 2016), and the computational complexity of evaluating AGNN is $O ( \ell d _ { h } | E | + d _ { x } d _ { h } n )$ . Detailed desription of the experiments is provided in Appendix B.
+
+# 5.1 PREDICTION ACCURACY
+
+Fixed data splits. In this first experiment, we use the fixed data splits from Yang et al. (2016) as they are the standard benchmark data splits in literature. All experiments are run on the same fixed split of 20 labeled nodes for each class, 500 nodes for validation, 1,000 nodes for test, and the rest of nodes as unlabeled data. Perhaps surprisingly, the linear classifier GLN we proposed in (3) achieves performance comparable to or exceeding the state-of-the-art performance of GCN. This leads to our novel attention-based model AGNN defined in (6), which achieves the best accuracy on all datasets with a gap larger than the standard error. The classification accuracy of all the baseline methods are collected from (Yang et al., 2016; Kipf & Welling, 2016; Such et al., 2017; Monti et al., 2016; Buchnik & Cohen, 2017; Verma et al., 2017).
+
+In semi-supervised learning on graphs, it is critical to utilize both the structure of the graph and the node features. Methods not using all the given data achieve performance far from the stateof-the-art. Supervised methods–Single and Multi-layer Perceptrons–only use the labeled examples $( Y _ { L } , X _ { L } )$ . Semi-supervised methods, e.g. T-SVM, only use the labeled and unlabeled examples $Y _ { L }$ , and $X$ . Skip-gram based approaches, such as DeepWalk, ignores the node features $X$ and only use the labels $Y _ { L }$ and the graph $G$ .
+
+Table 2: Classification accuracy with a fixed split of data from (Yang et al., 2016).   
+
+<table><tr><td>Input</td><td>Method</td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td rowspan="2">YL,XL</td><td>Singlelayer Perceptron</td><td>57.2</td><td>57.4</td><td>69.8</td></tr><tr><td>Multilayer Perceptron</td><td>64.0</td><td>57.5</td><td>71.4</td></tr><tr><td>YL，X</td><td>T-SVM (Joachims, 1999)</td><td>64.0</td><td>57.5</td><td>62.2</td></tr><tr><td>YL,G</td><td>DeepWalk (Perozzi et al., 2014) node2vec (Grover &amp; Leskovec,2016)</td><td>43.2 54.7</td><td>67.2 74.9</td><td>65.3 75.3</td></tr><tr><td rowspan="14">YL,X,G</td><td>LP (Zhu et al., 2003)</td><td>45.3</td><td>68.0</td><td>63.0</td></tr><tr><td>ICA (Lu &amp; Getoor,2003)</td><td>69.1</td><td>75.1</td><td>73.9</td></tr><tr><td>ManiReg (Belkin et al.,2006)</td><td>60.1</td><td>59.5</td><td>70.7</td></tr><tr><td>SemiEmb (Weston et al., 2012)</td><td>59.6</td><td>59.0</td><td>71.1</td></tr><tr><td>DCNN (Atwood &amp; Towsley,2016)</td><td></td><td>76.8</td><td>73.0</td></tr><tr><td>Planetoid (Yang et al., 2016)</td><td>64.7</td><td>75.7</td><td>77.2</td></tr><tr><td>MoNet (Monti et al., 2016)</td><td></td><td>81.7</td><td>78.8</td></tr><tr><td>Graph-CNN (Such et al., 2017)</td><td></td><td>76.3</td><td></td></tr><tr><td>DynamicFilter (Verma et al., 2017)</td><td></td><td>81.6</td><td>79.0</td></tr><tr><td>Bootstrap (Buchnik &amp; Cohen,2017)</td><td>53.6</td><td>78.4</td><td>78.8</td></tr><tr><td>GCN (Kipf &amp; Welling,2016)</td><td>70.3</td><td>81.5</td><td>79.0</td></tr><tr><td>GLN</td><td>70.9±.05</td><td>81.2±.05</td><td>78.9±.05</td></tr><tr><td>AGNN (this paper)</td><td>71.7±.08</td><td>82.6±.09</td><td>79.9±.07</td></tr></table>
+
+A breakthrough result of Planetoid by Yang et al. (2016) significantly improved upon the existing skip-gram based method of DeepWalk and node2vec and the Laplacian regularized methods of ManiReg and SemiEmb. Kipf & Welling (2016) was the first to apply a graph neural network to citation datasets, and achieved the state-of-the-art performance with GCN. Other variations of graph neural networks immediately followed, achieving comparable performance with MoNet, GraphCNN, and DynamicFilter. Bootstrap uses a Laplacian regularized approach of (Zhou et al., 2004a) as a sub-routine with bootstrapping to feed high-margin predictions as seeds.
+
+Random splits. Next, following the setting of Buchnik & Cohen (2017), we run experiments keeping the same size in labeled, validation, and test sets as in Table 2, but now selecting those nodes uniformly at random. This, along with the fact that different topics have different number of nodes in it, means that the labels might not be spread evenly across the topics. For 20 such randomly drawn dataset splits, average accuracy is shown in Table 3 with the standard error. As we do not force equal number of labeled data for each class, we observe that the performance degrades for all methods compared to Table 2, except for DeepWalk. AGNN achieves the best performance consistently. Here, we note that Kipf & Welling (2016) does a similar but different experiment using GCN, where random labeled nodes are evenly spread across topics so that each topic has exactly 20 labeled examples. As this difference in sampling might affect the accuracy, we do not report those results in this table.
+
+Table 3: Classification accuracy with random splits of the data.   
+
+<table><tr><td>Method</td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td>DeepWalk (Perozzi et al., 2014)</td><td>47.2</td><td>70.2</td><td>72.0</td></tr><tr><td>node2vec (Grover&amp;Leskovec,2016)</td><td>47.3</td><td>72.9</td><td>72.4</td></tr><tr><td>Bootstrap (Buchnik &amp; Cohen,2017)</td><td>50.3</td><td>78.2</td><td>75.6</td></tr><tr><td>GLN</td><td>68.4±0.45</td><td>80.0±0.43</td><td>77.7±0.63</td></tr><tr><td>AGNN (this paper)</td><td>69.8±0.35</td><td>81.0±0.34</td><td>78.0±0.46</td></tr></table>
+
+Larger training set. Following the setting of Such et al. (2017), we run experiments with larger number of labeled data on Cora dataset. We perform $k$ -fold cross validation experiments for $k =$ 3 and 10, by uniformly and randomly dividing the nodes into $k$ equal sized partitions and then performing $k$ runs of training by masking the labels of each of the $k$ partitions followed by validation on the masked nodes. Finally the average validation accuracy across $k$ runs is reported. We run 10 trials of this experiment and reports the mean and standard error of the average $k$ -fold validation accuracy. Compared to Table 2, the performance increases with the size of the training set, and AGNN consistently outperforms the current state-of-the-art architecture for this experiment.
+
+Table 4: Classification accuracy with larger sets of labelled nodes.   
+
+<table><tr><td>Method</td><td>3-fold Split</td><td>10-fold split</td></tr><tr><td>Graph-CNN (Such et al., 2017)</td><td>87.55±1.38</td><td>89.18±1.96</td></tr><tr><td>GLN</td><td>87.98±0.08</td><td>88.24±0.07</td></tr><tr><td>AGNN (this paper)</td><td>89.07±0.08</td><td>89.60±0.09</td></tr></table>
+
+# 5.2 QUALITATIVE ANALYSIS
+
+One useful aspect of incorporating attention into a model is that it provides some form of interpretation capability (Bahdanau et al., 2014). The learned $P _ { i j } ^ { ( t ) }$ ’s in Eq. (7) represent the attention from node $j$ to node $i$ , and provide insights on how relevant node $j$ is in classifying node $i$ . In Figure 1, we provide statistics of this attention over all adjacent pairs of nodes for Cora and CiteSeer datasets. We refer to Figure 3 for similar statistics on PubMed. In Figure 1, we show average attention from a node in topic $c _ { 2 }$ (column) to a node in topic $c _ { 1 }$ (row), which we call the relevance from $c _ { 2 }$ to $c _ { 1 }$ and is defined as
+
+$$
+\mathrm { R e l e v a n c e } ( c _ { 2 } \to c _ { 1 } ) = \frac { 1 } { | S _ { c _ { 1 } , c _ { 2 } } | } \sum _ { ( i , j ) \in S _ { c _ { 1 } , c _ { 2 } } } R ( j \to i ) ,
+$$
+
+for edge-wise relevance score defined as
+
+$$
+R ( j \to i ) = \left( P _ { i j } ^ { ( t ) } - \frac { 1 } { | N ( i ) | + 1 } \right) \Biggl / \frac { 1 } { | N ( i ) | + 1 } ,
+$$
+
+where $| N ( i ) |$ is the degree of node $i$ , and $S _ { c _ { 1 } , c _ { 2 } } = \{ ( i , j ) \in E ^ { s }$ and $Y _ { i } = c _ { 1 } , Y _ { j } = c _ { 2 } \}$ where $E ^ { s } =$ $E \cup \{ ( i , i )$ for $i \in V \}$ is the edge set augmented with self-loops to include all the attentions learned. If we are not using any attention, then the typical propagation will be uniform $P _ { i j } = 1 / ( | N ( i ) | + 1 )$ , in which case the above normalized attention is zero. We are measuring for each edge the variation of attention $P _ { i j }$ from uniform $1 / ( | N ( i ) | + 1 )$ as a multiplicative error, normalized by $1 / ( | N ( i ) | + 1 )$ . We believe this is the right normalization, as attention should be measure in relative strength to others in the same neighborhood, and not in absolute additive differences. We are measuring this multiplicative variation of the attention, averaged over the ordered pairs of classes.
+
+Figure 1 shows the relevance score for CiteSeer and Cora datasets. (PubMed is shown in Appendix A.) For both datasets, the diagonal entries are dominant indicating that the attention is learning to put more weight to those in the same class. A higher value of Relevance $' c _ { 2 }  c _ { 1 } ,$ ) indicates that, on average, a node in topic $c _ { 1 }$ pays more attention to a neighbor in topic $c _ { 2 }$ than neighbors from other topics. For CiteSeer dataset (Figure 1 left), we are showing the average attention at the first propagation layer, $P ^ { ( t = 1 ) }$ , for illustration. In the off-diagonals, the most influential relations are $\mathrm { H C I } {  } .$ Agents, Agents ${ \bf \Gamma } \to { \bf M L }$ , Agents $\mathrm { \Gamma \to H C I }$ , and ML Agents, and the least influential relations are $\mathrm { A I } {  } \mathrm { I R }$ and DB $\bf \Pi _ { \Pi } {  } \bf M \cal L$ . Note that these are papers in computer science from late 90s to early 2000s. For Cora dataset (Figure 1 right), we are showing the relevance score of the second propagation layer, $P ^ { ( t = 2 ) }$ , for illustration. In the off-diagonals, the most influential relations are $\mathrm { C B } {  } \mathrm { P M }$ , $\mathrm { P M } \to \mathrm { C B }$ , Rule $\mathrm { \Gamma } \to \mathrm { P M }$ , and $\mathrm { P M } \to$ Rule, and the least influential relations are $\mathbf { G A } {  } \mathbf { P M }$ and $\mathrm { P M } \to \mathrm { R L }$ . This dataset has papers in computer science from the 90s. We note that these relations are estimated solely based on the available datasets for that period of time and might not accurately reflect the relations for the entire academic fields. We also consider these relations as a static property in this analysis. If we have a larger corpus over longer period of time, it is possible to learn the influence conditioned on the period and visualize how these relations change.
+
+Next, we analyze the edges with high and low relevance scores. We remove the self-loops and then sort the edges according to the relevance score defined in Eq. (9). We take the top 100 and bottom 100 edges and with respect to their relevance scores, and report the fraction of the edges which are connecting nodes from the same class. Table 5 shows the result on the benchmark datasets for the relevance scores calculated using the last propagation layer. This suggests that our architecture learns to put higher attention between nodes of the same class.
+
+![](images/ba9d7104cc0e9d79b46371f0bebb1fac0ad6022efdbbfa7063a3fd2563ba6190.jpg)  
+Figure 1: Relevance score in Eq. (8) from a neighbor node with column-class to a center node in row-class. For example the average normalized attention to Agents from HCI is $= - 0 . 1 4 1$ , largest off-diagonal entry in CiteSeer. The average attention to Probabilistic Methods (PM) from Case Based (CB) is 0.017, largest off-diagonal entry in Cora.
+
+<table><tr><td></td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td>Top 100</td><td>0.69</td><td>0.64</td><td>0.69</td></tr><tr><td>Bottom 100</td><td>0.34</td><td>0.09</td><td>0.13</td></tr></table>
+
+Table 5: Fraction of edges from top 100 most relevant edges and bottom 100 least relevant edges which are connecting two distinct nodes from the same class.
+
+Finally, we analyze those nodes in the test sets that were mistaken by GCN but correctly classified by AGNN, and show how our attention mechanism weighted the contribution of its local neighborhood, and show three illustrative examples in Figure 2. More examples of this local attention network (including the legends for the color coding of the topics) are provided in Appendix A. We show a entire 2-hop neighborhood of a target node (marked by a thick outline) from the test set of the fixed data splits of Citeseer, Cora, or Pubmed. The colors denote the true classes of the nodes (including the target) in the target’s neighborhood, some of which are unknown to the models at the training time. The radius of a node $j$ is proportional to the attention to the target node $i$ aggregated over all the layers, i.e. $( P ^ { ( t = 4 ) } P ^ { ( t = 3 ) } P ^ { ( t = 2 ) } P ^ { ( t = 1 ) } ) _ { i j }$ for CiteSeer. The size of the target node reflects its self-attention defined in a similar way. The first example on the left is node 8434 from PubMed. AGNN correctly classifies the target node as light blue, whereas GCN mistakes it for yellow, possibly because it is connected to more yellow nodes. Not only has the attention mechanism learned to put more weight to its light blue 1-hop neighbor, but put equally heavy weights to a path of light blue neighbors some of which are not immediately connected to the target node. The second example in the middle is node 1580 from PubMed. AGNN correctly classifies it as yellow, whereas GCN mistakes it for a red, possibly because it only has two neighbors. Not only has the attention mechanism learned to put more weight to the yellow neighbor, but it has weighted the yellow neighbor (who is connected to many yellow nodes and perhaps has more reliable hidden states representing the true yellow class) even more than itself.
+
+The last example on the right is node 1512 from CiteSeer. AGNN correctly classifies it as light blue, whereas GCN mistakes it for a white. This is a special example as those two nodes are completely isolated. Due to the static and non-adaptive propagation of GCN, it ends up giving the same prediction for such isolated pairs. If the pair has two different true classes, then it always fails on at least on one of them (in this case the light blue node). However, AGNN is more flexible in adapting to such graph topology and puts more weight to the target node itself, correctly classifying both.
+
+# 6 CONCLUSIONS
+
+In this paper, we present an attention-based graph neural network model for semi-supervised classification on a graph. We demonstrate that our method consistently outperforms competing methods on the standard benchmark citation network datasets. We also show that the learned attention also provides interesting insights on how neighbors influence each other. In training, we have tried more complex attention models. However, due to the increased model complexity the training was not stable and does not give higher accuracy. We believe that for semi-supervised setting with such a limited number of labeled examples, reducing model complexity is important. Note that we are able to train deeper (4-layers) models compared to a shallower (2-layers) model of GCN, in part due to the fact that we remove the non-linear layers and reduce the model complexity significantly. In comparison, deeper GCN models are known to be unstable and do not give the performance of shallower GCNs (Kipf & Welling, 2016).
+
+![](images/746099e24bddd012b7ea228587a2be040c6b393b554acb382dc318aad4054062.jpg)  
+Figure 2: We show three selected target nodes in the test set that are mistaken by GCN but correctly classified by AGNN. We denote this target node by the node with a thick outline (node 8434 from PubMed on the left, node 1580 from PubMed in the middle, and node 1512 from CiteSeer on the right). We show the strength of attention from a node in the 2-hop neighborhood to the target node by the size of the corresponding node. Colors represent the hidden true classes (nodes with the same color belong to the same topic). None of the nodes in the figure was in the training set, hence none of the colors were revealed. Still, we observe that AGNN has managed to put more attention to those nodes in the same (hidden) classes, allowing the trained model to find the correct labels.
+
+# REFERENCES
+
+S. Gunnemann A. Bojchevski. Deep gaussian embedding of attributed graphs: Unsupervised inductive learning via ranking. arXiv preprint arXiv:1707.03815, 2017.   
+Martin Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.   
+J. Atwood and D. Towsley. Diffusion-convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 1993–2001, 2016.   
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.   
+Mikhail Belkin, Partha Niyogi, and Vikas Sindhwani. Manifold regularization: A geometric framework for learning from labeled and unlabeled examples. Journal of machine learning research, 7 (Nov):2399–2434, 2006.   
+R. van den Berg, T. N. Kipf, and M. Welling. Graph convolutional matrix completion. arXiv preprint arXiv:1706.02263, 2017.   
+Avrim Blum and Shuchi Chawla. Learning from labeled and unlabeled data using graph mincuts. In ICML ’01 Proceedings of the Eighteenth International Conference on Machine Learning, 2001.   
+Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. arXiv preprint arXiv:1611.08097, 2016.   
+J. Bruna and X. Li. Community detection with graph neural networks. arXiv preprint arXiv:1705.08415, 2017.   
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013.
+
+Eliav Buchnik and Edith Cohen. Bootstrapped graph diffusions: Exposing the power of nonlinearity. arXiv preprint arXiv:1703.02618, 2017.
+
+Olivier Chapelle, Bernhard Scholkopf, and Alexander Zien. Semi-supervised learning (chapelle, o. et al., eds.; 2006)[book reviews]. IEEE Transactions on Neural Networks, 20(3):542–542, 2009.
+
+H. Dai, B. Dai, and L. Song. Discriminative embeddings of latent variable models for structured data. In International Conference on Machine Learning, pp. 2702–2711, 2016.
+
+Hanjun Dai, Elias B Khalil, Yuyu Zhang, Bistra Dilkina, and Le Song. Learning combinatorial optimization algorithms over graphs. arXiv preprint arXiv:1704.01665, 2017.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks ¨ on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3837–3845, 2016.
+
+Yan Duan, Marcin Andrychowicz, Bradly Stadie, Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. arXiv preprint arXiv:1703.07326, 2017.
+
+David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan´ Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015.
+
+Evgeniy Faerman, Felix Borutta, Kimon Fountoulakis, and Michael W Mahoney. Lasagne: Locality and structure aware graph node embedding. arXiv preprint arXiv:1710.06520, 2017.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. arXiv preprint arXiv:1704.01212, 2017.
+
+Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In Neural Networks, 2005. IJCNN’05. Proceedings. 2005 IEEE International Joint Conference on, volume 2, pp. 729–734. IEEE, 2005.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+A. Grover and J. Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 855–864. ACM, 2016.
+
+W. L. Hamilton, R. Ying, and J. Leskovec. Inductive representation learning on large graphs. arXiv preprint arXiv:1706.02216, 2017.
+
+Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015.
+
+Yedid Hoshen. Vain: Attentional multi-agent predictive modeling. In Advances in Neural Information Processing Systems, pp. 2698–2708, 2017.
+
+Thorsten Joachims. Transductive inference for text classification using support vector machines. In ICML, volume 99, pp. 200–209, 1999.
+
+T. N. Kipf and M. Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Q. Le and T. Mikolov. Distributed representations of sentences and documents. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1188–1196, 2014.
+
+Y. Li, D. Tarlow, M. Brockschmidt, and R. Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.
+
+Qing Lu and Lise Getoor. Link-based classification. In Proceedings of the 20th International Conference on Machine Learning (ICML-03), pp. 496–503, 2003.
+
+Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M\` Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. arXiv preprint arXiv:1611.08402, 2016.
+
+M. Niepert, M. Ahmed, and K. Kutzkov. Learning convolutional neural networks for graphs. In Proceedings of the 33rd annual international conference on machine learning. ACM, 2016.
+
+Kamal Nigam, Andrew McCallum, and Tom Mitchell. Semi-supervised text classification using em. Semi-Supervised Learning, pp. 33–56, 2006.
+
+A. Nowak, S. Villar, A. S. Bandeira, and J. Bruna. A note on learning algorithms for quadratic assignment with graph neural networks. arXiv preprint arXiv:1706.07450, 2017.
+
+B. Perozzi, R. Al-Rfou, and S. Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2009.
+
+M. Schlichtkrull, T. N. Kipf, P. Bloem, R. van den Berg, I. Titov, and M. Welling. Modeling relational data with graph convolutional networks. arXiv preprint arXiv:1703.06103, 2017.
+
+Felipe Petroski Such, Shagan Sah, Miguel Dominguez, Suhas Pillai, Chao Zhang, Andrew Michael, Nathan Cahill, and Raymond Ptucha. Robust spatial filtering with graph convolutional neural networks. arXiv preprint arXiv:1703.00792, 2017.
+
+Sainbayar Sukhbaatar, arthur szlam, and Rob Fergus. Learning multiagent communication with backpropagation. In Advances in Neural Information Processing Systems 29, pp. 2244–2252. 2016.
+
+Jian Tang, Meng Qu, Mingzhe Wang, Ming Zhang, Jun Yan, and Qiaozhu Mei. Line: Large-scale information network embedding. In Proceedings of the 24th International Conference on World Wide Web, pp. 1067–1077. ACM, 2015.
+
+Nitika Verma, Edmond Boyer, and Jakob Verbeek. Dynamic filters in graph convolutional networks. arXiv preprint arXiv:1706.05206, 2017.
+
+Jason Weston, Fred´ eric Ratle, Hossein Mobahi, and Ronan Collobert. Deep learning via semi- ´ supervised embedding. In Neural Networks: Tricks of the Trade, pp. 639–655. Springer, 2012.
+
+Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In International Conference on Machine Learning, pp. 2048–2057, 2015.
+
+Xiaojun Xu, Chang Liu, Qian Feng, Heng Yin, Le Song, and Dawn Song. Neural networkbased graph embedding for cross-platform binary code similarity detection. arXiv preprint arXiv:1708.06525, 2017.
+
+Cheng Yang, Maosong Sun, Zhiyuan Liu, and Cunchao Tu. Fast network embedding enhancement via high order proximity approximation. In Proceedings of the Twenty-Sixth International Joint Conference on Artificial Intelligence, IJCAI, pp. 19–25, 2017.
+
+Z. Yang, W. W. Cohen, and R. Salakhutdinov. Revisiting semi-supervised learning with graph embeddings. arXiv preprint arXiv:1603.08861, 2016.
+
+Denny Zhou, Olivier Bousquet, Thomas N Lal, Jason Weston, and Bernhard Scholkopf. Learning ¨ with local and global consistency. In Advances in neural information processing systems, pp. 321–328, 2004a.
+
+Denny Zhou, Olivier Bousquet, Thomas N Lal, Jason Weston, and Bernhard Scholkopf. Learning ¨ with local and global consistency. In Advances in neural information processing systems, pp. 321–328, 2004b.
+
+Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label propagation. 2002.
+
+Xiaojin Zhu, Zoubin Ghahramani, and John D Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the 20th International conference on Machine learning (ICML-03), pp. 912–919, 2003.
+
+# APPENDIX
+
+# A ADDITIONAL EXPERIMENTS ON INTERPRETABILITY OF ATTENTION
+
+PubMed dataset has only 3 classes, and the relevance score is shown in the figure below.
+
+![](images/218614320c5e8af70e050b686490d68b16ad4a69af18a7e847312779b9e4dd46.jpg)  
+Figure 3: Average attention in Eq. (8) from a column class to a row class
+
+We show examples of 2-hop local neighborhood of nodes that are mistaken by GCN but correctly classified by AGNN.
+
+![](images/e4934394b1d8b00da6d1f5ba19edaf716754392d6b2bea3861bb5150deafc241.jpg)  
+Figure 4: Examples from CiteSeer dataset of attention strength in the local neighborhood of a target node (in thick outline) from the test set that is mistaken by GCN but correctly classified by AGNN. Colors are true classes and node sizes are proportional to the attention strength from a neighbor to the target node. Labeled nodes from training set are marked with ‘\*’.
+
+# B EXPERIMENT AND ARCHITECT DETAILS
+
+In this section we will list all the choices made in training and tuning of hyper-parameters. The parameters are chosen as to maximize the validation. All the models use Adam optimization algorithm with full-batchs, as standard in other works on GNNs (Kipf & Welling, 2016; Such et al., 2017). We also a weight decay term to the objective function for all the learnable weights. We add dropout to the first and last layers of all models.
+
+In Table 6. we show the hyper-parameters used in training the AGNN models for various settings and datasets. For Cora dataset the architecture consist of $\ell = 3$ propagation layers, but the first propagation layer $P ^ { ( t = 1 ) }$ is non-trainable and the variable $\beta ^ { ( t = 1 ) }$ value is fixed at zero. While training these AGNN models we maintain the validation accuracy for each iteration and finally choose the trained model parameters from the iteration where average validation accuracy of previous 4 epochs is maximized. For the $k$ -fold cross validation setting we take the epoch with maximum validation accuracy.
+
+![](images/154ecc254c87ebbf4f9d53d65bc0dd13354298aaa3517792e26baa5b82a4dcbc.jpg)  
+Figure 5: Examples from Cora dataset of attention strength in the local neighborhood of a target node (in thick outline) from the test set that is mistaken by GCN but correctly classified by AGNN. Colors are true classes and node sizes are proportional to the attention strength from a neighbor to the target node. Labeled nodes from training set are marked with ‘\*’.
+
+![](images/fb7c08d490ed620cf75a6bc19d8ae206e115d8cc8bcf9e5410bde7b6e9065d14.jpg)  
+Figure 6: Examples from Pubmed dataset of attention strength in the local neighborhood of a target node (in thick outline) from the test set that is mistaken by GCN but correctly classified by AGNN. Colors are true classes and node sizes are proportional to the attention strength from a neighbor to the target node. Labeled nodes from training set are marked with ‘\*’.
+
+Table 6: Hyper-parameters for AGNN model   
+
+<table><tr><td rowspan="2"> Setting</td><td rowspan="2">Dataset</td><td rowspan="2">Propagation layers (l)</td><td rowspan="2">Hidden state dimension (dh)</td><td rowspan="2">Learning Rate</td><td rowspan="2">Weight Decay</td><td rowspan="2">Dropout</td><td rowspan="2">Epochs</td></tr><tr><td></td></tr><tr><td>Fixed Split</td><td>CiteSeer</td><td>4</td><td>16</td><td>0.005</td><td>0.0005</td><td>0.5</td><td>1000</td></tr><tr><td>Fixed Split</td><td>Cora</td><td>3</td><td>16</td><td>0.01</td><td>0.0005</td><td>0.5</td><td>1000</td></tr><tr><td>Fixed Split</td><td>PubMed</td><td>4</td><td>16</td><td>0.008</td><td>0.001</td><td>0.5</td><td>400</td></tr><tr><td>Rand. Split</td><td>CiteSeer</td><td>4</td><td>16</td><td>0.01</td><td>0.0005</td><td>0.5</td><td>1000</td></tr><tr><td>Rand. Split</td><td>Cora</td><td>3</td><td>16</td><td>0.01</td><td>0.0005</td><td>0.5</td><td>1000</td></tr><tr><td>Rand. Split</td><td>PubMed</td><td>4</td><td>16</td><td>0.008</td><td>0.001</td><td>0.5</td><td>1000</td></tr><tr><td>Cross Val.</td><td>Cora</td><td>3</td><td>16</td><td>0.04</td><td>0.0005</td><td>0.25</td><td>500</td></tr></table>
+
+For the Graph Linear Network (GLN) as define in (3), we use the same hyper-parameters as GCN (Kipf & Welling, 2016) for all the experimental settings: hidden dimension of 16, learning rate of 0.01, weight decay of $5 \times 1 0 ^ { - 4 }$ , dropout of 0.5, 200 epochs and early stopping criteria with a window size of 10.
+
+# C PERFORMANCE VERSUS NUMBER OF PROPAGATION LAYERS
+
+In this section we provide experimental results justifying the choice of number of propagation layers for each dataset. We use the same data split and hyper-parameters (except number of propagation layer) as in the fixed data splits setting in Section 5.1. Similar to other settings the first propagation layer for Cora dataset is non-trainable with $\beta ^ { ( t = 1 ) } = 0$ . Tables 7 gives the average (over 10 trials) testing accuracy respectively for various choices of number of propagation layers. We note that different datasets require different number of propagation layers for best performance.
+
+Table 7: Average testing error of AGNN for different number of Propagation Layers.   
+
+<table><tr><td>Propagation Layers ()</td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td>1</td><td>69.08</td><td>80.52</td><td>78.31</td></tr><tr><td>2</td><td>70.83</td><td>83.07</td><td>79.66</td></tr><tr><td>3</td><td>71.06</td><td>82.62</td><td>79.56</td></tr><tr><td>4</td><td>71.70</td><td>82.24</td><td>80.10</td></tr><tr><td>5</td><td>71.37</td><td>82.07</td><td>80.13</td></tr></table>
+
+D PERFORMANCE OF GCN ON OTHER DATASET SPLITS.   
+Table 8: Classification accuracy with random splits of the data.   
+
+<table><tr><td>Method</td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td>DeepWalk (Perozzi et al., 2014)</td><td>47.2</td><td>70.2</td><td>72.0</td></tr><tr><td>node2vec (Grover &amp; Leskovec,2016)</td><td>47.3</td><td>72.9</td><td>72.4</td></tr><tr><td>Bootstrap (Buchnik &amp; Cohen,2017)</td><td>50.3</td><td>78.2</td><td>75.6</td></tr><tr><td>GCN</td><td>66.9±0.50</td><td>79.2±0.46</td><td>77.5±0.61</td></tr><tr><td>GLN</td><td>68.4±0.45</td><td>80.0±0.43</td><td>77.7±0.63</td></tr><tr><td>AGNN (this paper)</td><td>69.8±0.35</td><td>81.0±0.34</td><td>78.0±0.46</td></tr></table>
+
+Here we provide the performance of GCN on random splits and larger training set dataset splits from Section 5.1. We relegate these tables to the appendix since they were not present in Kipf & Welling (2016). We conducted the experiments with the same hyper-parameters as chosen by Kipf & Welling (2016) for the fixed split. In Tables 8 and 9 we provide average testing accuracy and standard error over 20 and 10 runs on random splits and larger training set respectively.
+
+Table 9: Classification accuracy with larger sets of labelled nodes.   
+
+<table><tr><td>Method</td><td>3-fold Split</td><td>10-fold split</td></tr><tr><td>Graph-CNN (Such et al., 2017)</td><td>87.55±1.38</td><td>89.18±1.96</td></tr><tr><td>GCN</td><td>87.23±0.21</td><td>87.78±0.04</td></tr><tr><td>GLN</td><td>87.98±0.08</td><td>88.24±0.07</td></tr><tr><td>AGNN (this paper)</td><td>89.07±0.08</td><td>89.60±0.09</td></tr></table>

parse/train/rJg4YGWRb/rJg4YGWRb_content_list.json

@@ -0,0 +1,1752 @@
+[
+    {
+        "type": "text",
+        "text": "ATTENTION-BASED GRAPH NEURAL NETWORK FORSEMI-SUPERVISED LEARNING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "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,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently popularized graph neural networks achieve the state-of-the-art accuracy on a number of standard benchmark datasets for graph-based semi-supervised learning, improving significantly over existing approaches. These architectures alternate between a propagation layer that aggregates the hidden states of the local neighborhood and a fully-connected layer. Perhaps surprisingly, we show that a linear model, that removes all the intermediate fully-connected layers, is still able to achieve a performance comparable to the state-of-the-art models. This significantly reduces the number of parameters, which is critical for semi-supervised learning where number of labeled examples are small. This in turn allows a room for designing more innovative propagation layers. Based on this insight, we propose a novel graph neural network that removes all the intermediate fullyconnected layers, and replaces the propagation layers with attention mechanisms that respect the structure of the graph. The attention mechanism allows us to learn a dynamic and adaptive local summary of the neighborhood to achieve more accurate predictions. In a number of experiments on benchmark citation networks datasets, we demonstrate that our approach outperforms competing methods. By examining the attention weights among neighbors, we show that our model provides some interesting insights on how neighbors influence each other. ",
+        "bbox": [
+            233,
+            266,
+            764,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            336,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the major bottlenecks in applying machine learning in practice is collecting sizable and reliable labeled data, essential for accurate predictions. One way to overcome the problem of limited labeled data is semi-supervised learning, using additional unlabeled data that might be freely available. In this paper, we are interested in a scenario when this additional unlabeled data is available in a form of a graph. The graph provides underlying pairwise relations among the data points, both labeled and unlabeled. ",
+        "bbox": [
+            174,
+            575,
+            823,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Of particular interest are those applications where the presence or absence of an edge between two data points is determined by nature, for instance as a result of human activities or natural relations. As a concrete example, consider a citation network. Each node in the graph is a published research paper, associated with a bag-of-words feature vector. An (directed) edge indicates a citation link. Presence of an edge indicates that the authors of a paper have consciously determined to refer to the other paper, and hence captures some underlying relation that might not be inferred from the bag-of-words feature vectors alone. Such external graph data are available in several applications of interest, such as classifying users connected via a social network, items and customers connected by purchase history, users and movies connected by viewing history, and entities in a knowledge graph connected by relationships. In this paper, we are interested in the setting where the graph is explicitly given and represents additional information not present in the feature vectors. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The goal of such graph-based semi-supervised learning problems is to classify the nodes in a graph using a small subset of labeled nodes and all the node features. There is a long line of literature on this topic since Blum & Chawla (2001) which seeks graph cuts that preserve the known labels and Zhu et al. (2003) which uses graph Laplacian to regularize the nearby nodes to have similar labels. However, Kipf & Welling (2016) recently demonstrated that the existing approaches can be significantly improved upon on a number of standard benchmark datasets, using an innovative neural network architecture on graph-based data known collectively as graph neural networks. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inspired by this success, we seek to understand the reason behind the power of graph neural networks, to guide our design of a novel architecture for semi-supervised learning on graphs. To this end, we first found that a linear classifier of multinomial logistic regression achieves the accuracy comparable to the best known graph neural network. This linear classifier removes all intermediate non-linear activation layers, and only keeps the linear propagation function from neighbors in graph neural networks. This suggests the importance of aggregation information form the neighbors in the graph. This further motivates us to design a new way of aggregating neighborhood information through attention mechanism since, intuitively, neighbors might not be equally important. This proposed attention-based graph neural network captures this intuition and $( a )$ greatly reduces the model complexity, with only a single scalar parameter at each intermediate layer; $( b )$ discovers dynamically and adaptively which nodes are relevant to the target node for classification; and $( c )$ improves upon state-of-the-art methods in terms of accuracy on standard benchmark datasets. Further, the learned attention strengths provide some form of interpretability. They provide insights on why a particular prediction is made on a target node and which neighbors are more relevant in making that decision. ",
+        "bbox": [
+            173,
+            104,
+            825,
+            311
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            332,
+            344,
+            348
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a graph $G ( V , E )$ with a set of $n$ nodes $V$ and a set of edges $E$ , we let $X _ { i } \\in \\mathbb { R } ^ { d _ { x } }$ denote the feature vector at node $i$ and let $Y _ { i }$ denote the true label. We use $Y _ { L }$ to denote the labels that are revealed to us for a subset $L \\subset V$ . We let $X = [ X _ { 1 } , \\ldots , X _ { n } ]$ denote all features, labeled and unlabeled. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            419
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Traditionally, semi-supervised learning using both labeled and un-labled data has been solved using two different approaches - Graph Laplacian based algorithms solving for locally consistent solutions (Zhou et al., 2004b) and Expectation Maximization based algorithms (Nigam et al., 2006) where true-labels of the unlabeled data points are considered as the latent variables of a generative model. ",
+        "bbox": [
+            174,
+            425,
+            825,
+            482
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph Laplacian regularization. Based on the assumption that nearby nodes in a graph are more likely to have the same labels, the graph information has been used as explicit regularization: ",
+        "bbox": [
+            173,
+            488,
+            821,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/affffdaff9841d7efb9425e2b33f0c0dacdac1957c3bde49eafa2b2870574d8f.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { \\mathcal L } ( X , Y _ { L } ) } & { { = } } & { { { \\mathcal L } _ { \\mathrm { l a b e l } } ( X _ { L } , Y _ { L } ) + \\lambda { \\mathcal L } _ { G } ( X ) ~ , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            521,
+            650,
+            540
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { l a b e l } } = \\sum _ { i \\in L } l ( Y _ { i } , f ( X _ { i } ) ) } \\end{array}$ is the standard supervised loss for some loss functions $l$ and $\\mathcal { L } _ { G }$ is the graph-based regularization, for example $\\begin{array} { r } { \\mathcal { L } _ { G } = \\sum _ { ( i , j ) \\in E } \\| f ( X _ { i } ) - f ( X _ { j } ) \\| ^ { 2 } } \\end{array}$ , which is called the graph Laplacian regularization. Earlier approaches are non-parametric and searches over all $f$ considering it as a look-up table. Most popular one is the Label Propagation (Zhu & Ghahramani, 2002) that forces the estimated labels to agree in the labeled instances and uses weighted graph Laplacian. This innovative formulation admits a closed form solution which makes it practically attractive with very low computationally cost. ManiReg (Belkin et al., 2006) replaces supervised loss with that of a support vector machine. ICA (Lu & Getoor, 2003) generalizes LP by allowing more general local updates. A more thorough survey on using non-neural network methods for semi-supervised learning can be found in (Chapelle et al., 2009). ",
+        "bbox": [
+            174,
+            542,
+            825,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More recent approaches are parametric, using deep neural networks. SemiEmb (Weston et al., 2012) was the first to use a deep neural network to model $f ( x )$ and minimize the above loss. Planetoid (Yang et al., 2016) significantly improves upon the existing graph regularization approaches by replacing the regularization by another loss based on skip-grams (defined below). In a slightly different context, Buchnik & Cohen (2017) show that the accuracy of these approaches can be further improved by bootstrapping these models sequentially. ",
+        "bbox": [
+            174,
+            694,
+            823,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised node embedding for semi-supervised learning. Several approaches have been proposed to embed the nodes in some latent Euclidean space using only the connectivity in graph $G$ . Once the embedding is learned, standard supervised learning is applied on those embedded features to train a model. Inspired by the success of word2vec (Le & Mikolov, 2014), several approaches define “skip-grams” on graphs as the neighborhood (context) of a node on the graph and tries to maximize the posterior probability of observing those skip-grams. DeepWalk (Perozzi et al., 2014) and node2vec (Grover & Leskovec, 2016) use random walks as skip-grams, LINE (Tang et al., 2015) uses local proximities, LASAGNE (Faerman et al., 2017) uses the Personalized PageRank random walk. Graph2Gauss (A. Bojchevski, 2017) represents a node as a Gaussian distribution, and minimizes the divergence between connected pairs. Yang et al. (2017) provide a post-processing scheme that takes any node embedding and attempts to improve it by by taking the weighted sum of the given embeddings with Personalized PageRank weights. The strength of these approaches is universality, as the node embedding does not depend on the particular task at hand (and in particular the features or the labels). However, as they do not use the node features and the training only happens after embedding, they cannot meet the performance of the state-of-the-art approaches (see DeepWalk in Table 2). ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Network (GNN). Graph neural networks are extensions of neural networks to structured data encoded as a graph. Originally introduced as extensions of recurrent neural networks, GNNs apply recurrent layers to each node with additional local averaging layer (Gori et al., 2005; Scarselli et al., 2009). However, as the weights are shared across all nodes, GNNs can also be interpreted as extensions of convolutional neural networks on a 2D grid to general graphs. Typically, a message aggregation step followed by some neural network architecture is iteratively applied. The model parameters are trained on (semi-)supervised examples with labels. We give a typical example of a GNN in Section 3, but several diverse variations have been proposed in (Bruna et al., 2013; Duvenaud et al., 2015; Li et al., 2015; Henaff et al., 2015; Sukhbaatar et al., 2016; Bronstein et al., 2016; Defferrard et al., 2016; Dai et al., 2016; Atwood & Towsley, 2016; Niepert et al., 2016; Such et al., 2017; Hamilton et al., 2017; Schlichtkrull et al., 2017; Such et al., 2017). GNNs have been successfully applied in diverse applications such as molecular activation prediction (Gilmer et al., 2017), community detection (Bruna & Li, 2017), matrix completion (Berg et al., 2017), combinatorial optimization (Dai et al., 2017; Nowak et al., 2017), and detecting similar binary codes (Xu et al., 2017). ",
+        "bbox": [
+            174,
+            194,
+            825,
+            401
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In particular, for the benchmark datasets that we consider in this paper, Kipf & Welling (2016) proposed a simple but powerful architecture called Graph Convolutional Network (GCN) that achieves the state-of-the-art accuracy. In the following section, $( a )$ we show that the performance of GCN can be met by a linear classifier; and $( b )$ use this insight to introduce novel graph neural networks that compare favourably against the state-of-the-art approaches on benchmark datasets. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DISSECTION OF GRAPH NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            500,
+            571,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose a novel Graph Neural Network (GNN) model which we call Attentionbased Graph Neural Network (AGNN), and compare its performance to state-of-the-art models on benchmark citation networks in Section 5. We seek a model $Z = f ( X , A ) \\in \\mathbb { R } ^ { n \\times d _ { y } }$ that predicts at each node one of the $d _ { y }$ classes. $Z _ { i c }$ is the estimated probability that the label at node $i \\in [ n ]$ is $c \\in [ d _ { y } ]$ given the features $X$ and the graph $A$ . The data features $X \\in \\mathbb { R } ^ { n \\times d _ { x } }$ has at each row $d _ { x }$ features for each node, and $A \\in \\{ 0 , 1 \\} ^ { \\bar { n } \\times \\bar { n } }$ is the adjacency matrix of $G$ . ",
+        "bbox": [
+            174,
+            531,
+            825,
+            618
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The forward pass in a typical GNN alternates between a propagation layer and a single layer perceptron. Let $t$ be the layer index. We use $H ^ { ( t ) } \\in \\mathbb { R } ^ { n \\times d _ { h } }$ to denote the current (hidden) states, with the $i$ -th row $H _ { i } ^ { ( t ) }$ as the $d _ { h }$ dimensional hidden state of node $i$ . A propagation layer with respect to a propagation matrix $P \\in \\mathbb { R } ^ { n \\times n }$ is defined as ",
+        "bbox": [
+            173,
+            623,
+            825,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a230ec0f1d7ea8e7b0b4d2f31ca27a32eb0ec63e823df24e99323ee9ec8a0c18.jpg",
+        "text": "$$\n\\tilde { H } ^ { ( t ) } = P H ^ { ( t ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            691,
+            553,
+            709
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For example, the natural random walk1 $P = D ^ { - 1 } A$ gives $\\begin{array} { r } { \\tilde { H } _ { i } ^ { ( t ) } = ( 1 / | N ( i ) | ) \\sum _ { j \\in N ( i ) } H _ { j } ^ { ( t ) } } \\end{array}$ . The neighborhood of node $i$ is denoted by $N ( i )$ , and $D = \\mathrm { d i a g ( A { \\bf 1 } ) }$ . This is a simple local averaging common in consensus or random walk based approaches. Typical propagation layer respects the adjacency pattern in $A$ , performing a variation of such local averaging. GNNs encode the graph structure of $A$ into the model via this propagation layer, which can be also interpreted as performing a graph convolution operation as discussed in Kipf & Welling (2016). Next, a single layer perceptron is applied on each node separately and the weights $W ^ { ( t ) }$ are shared across all the nodes: ",
+        "bbox": [
+            173,
+            715,
+            825,
+            820
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb71bc7de6f4b3476354e81cef9bb693e98c60df26e3c53dd3aa6b9987fe8ec5.jpg",
+        "text": "$$\n{ \\cal H } ^ { ( t + 1 ) } = \\sigma ( \\tilde { H } ^ { ( t ) } W ^ { ( t ) } ) \\ ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            827,
+            581,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $W ^ { ( t ) } \\in \\mathbb { R } ^ { d _ { h _ { t + 1 } } \\times d _ { h _ { t } } }$ is the weight matrix and $\\sigma ( \\cdot )$ is an entry-wise activation function. This weight sharing reduces significantly the number of parameters to be trained, and encodes the invariance property of graph data, i.e. two nodes that are far apart but have the similar neighboring features and structures should be classified similarly. There are several extensions to this model as discussed in the previous section, but this standard graph neural network has proved powerful in several problems over graphs, e.g. (Bruna & Li, 2017; Berg et al., 2017; Dai et al., 2017). ",
+        "bbox": [
+            176,
+            854,
+            825,
+            900
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Graph Convolutional Network (GCN). Kipf & Welling (2016) introduced a simple but powerful architecture, and achieved the state-of-the-art performance in benchmark citation networks (see Table 2). GCN is a special case of GNN which stacks two layers of specific propagation and perceptron: ",
+        "bbox": [
+            174,
+            151,
+            825,
+            209
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc98604a838365defc46dfd1586f58f2fd7b30efbd2940e1e22a5a5272f5d749.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { { \\cal H } ^ { ( 1 ) } } } & { { = } } & { { \\mathrm { R e L U } \\big ( ( P X ) { \\cal W } ^ { ( 0 ) } \\big ) ~ , } } \\\\ { { Z ~ = } } & { { f ( X , { \\cal A } ) } } & { { = } } & { { \\mathrm { s o f t m a x } \\big ( ( P { \\cal H } ^ { ( 1 ) } ) { \\cal W } ^ { ( 1 ) } \\big ) ~ , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            213,
+            668,
+            257
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with a choice of $P = \\tilde { D } ^ { - 1 / 2 } \\tilde { A } \\tilde { D } ^ { - 1 / 2 }$ , where ${ \\tilde { A } } = A + \\mathbb { I }$ , I is the identity matrix, $\\tilde { D } = \\mathrm { d i a g } ( \\tilde { A } \\mathbf { 1 } )$ and $\\mathbb { 1 }$ is the all-ones vector. $\\mathrm { R e L U } ( a ) = \\operatorname* { m a x } \\{ 0 , a \\}$ is an entry-wise rectified linear activation function, and softmax $\\cdot ( [ a _ { 1 } , \\dots , a _ { k } ] ) = ( 1 / Z ) [ \\exp ( a _ { 1 } ) , \\dots , \\exp ( a _ { k } ) ]$ with $\\begin{array} { r } { Z = \\sum _ { i } \\exp ( a _ { i } ) } \\end{array}$ is applied rowwise. Hence, the output is the predicted likelihoods on the $d _ { y }$ dimensional probability simplex. The weights $W ^ { ( 0 ) }$ and $W ^ { ( 1 ) }$ are trained to minimize the cross-entropy loss over all labeled examples $L$ : ",
+        "bbox": [
+            174,
+            260,
+            825,
+            335
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e079d780c7c148aac9f031184b2c107efaca797cb2cb7b0f245ac791765c6dfe.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\mathcal { L } } & { = } & { \\displaystyle - \\sum _ { i \\in L } \\sum _ { c = 1 } ^ { d _ { y } } Y _ { i c } \\ln Z _ { i c } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            339,
+            599,
+            386
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Graph Linear Network (GLN). To better understand GCN, we remove the intermediate nonlinear activation units from GCN, which gives Graph Linear Network defined as ",
+        "bbox": [
+            173,
+            396,
+            825,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/965d3f5330dd7d025876ac2221671e3578e4dc9e4ff89de670c024edd4a61181.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { Z } } & { { = } } & { { f ( X , A ) } } & { { = } } & { { \\mathrm { s o f t m a x } \\big ( ( \\mathrm { P ^ { 2 } X } ) { \\mathrm { W } } ^ { ( 0 ) } { \\mathrm { W } } ^ { ( 1 ) } \\big ) \\ , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            430,
+            676,
+            450
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with the same choice of $P = \\tilde { D } ^ { - 1 / 2 } \\tilde { A } \\tilde { D } ^ { - 1 / 2 }$ as in GCN. The weights $W ^ { ( 0 ) }$ and $W ^ { ( 1 ) }$ have the same dimensions as GCN and are trained on a cross entropy loss in (2). The two propagation layers simply take (linear) local average of the raw features weighted by their degrees, and at the output layer a simple linear classifier (multinomial logistic regression) is applied. This allows us to separate the gain in the linear propagation layer and the non-linear perceptron layer. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Comparing the differences in performances in Table 2, we show that, perhaps surprisingly, GLN achieves an accuracy comparable to the that of the best GNN, and sometimes better. This suggests that, for citation networks, the strength of the general GNN architectures is in the propagation layer and not in the perceptron layer. On the other hand, the propagation layers are critical in achieving the desired performance, as is suggested in Table 2. There are significant gaps in accuracy for those approaches not using the graph, i.e. T-SVM, and also those that use the graph differently, such as Label Propagation (LP) and Planetoid. Based on this observation, we propose replacing the propagation layer of GLN with an attention mechanism and test it on the benchmark datasets. ",
+        "bbox": [
+            173,
+            534,
+            825,
+            646
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 ATTENTION-BASED GRAPH NEURAL NETWORK (AGNN). ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            686,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The original propagation layer in GCN and several other graph neural networks such as (Defferrard et al., 2016; Atwood & Towsley, 2016; Monti et al., 2016; Such et al., 2017) use a static (does not change over the layers) and non-adaptive (does not take into account the states of the nodes) propagation, e.g. $P _ { i j } = 1 / \\sqrt { | N ( i ) | | N ( j ) | }$ . Such propagations are not able to capture which neighbor is more relevant to classifying a target node, which is critical in real data where not all edges imply the same types or strengths of relations. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            784
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We need novel dynamic and adaptive propagation layers, capable of capturing the relevance of different edges, which leads to more complex graph neural networks with more parameters. However, training such complex models is challenging in the semi-supervised setting, as the typical number of samples we have for each class is small; it is 20 in the standard benchmark dataset. This is evidenced in Table 2 where more complex graph neural network models by Verma et al. (2017), Monti et al. (2016), and Such et al. (2017) do not improve upon the simple GCN. ",
+        "bbox": [
+            174,
+            789,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, our experiments with GLN suggests that we can remove all the perceptron layers and focus only on improving the propagation layers. To this end, we introduce a novel Attentionbased Graph Neural Network (AGNN). AGNN is simple; it only has a single scalar parameter $\\beta ^ { ( t ) }$ at each intermediate layer. AGNN captures relevance; the proposed attention mechanism over neighbors in (5) learns which neighbors are more relevant and weighs their contributions accordingly. This builds on the long line of successes of attention mechanisms in summarizing long sentences or large images, by capturing which word or part-of-image is most relevant ( $\\mathrm { { X u } }$ et al., 2015; Graves et al., 2014; Bahdanau et al., 2014). Particularly, we use the attention formulation similar to the one used in Graves et al. (2014).2 It only has one parameter and we found this is important for successfully training the model when the number of labels is small as in our semi-supervised learning setting. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 AGNN MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            232,
+            318,
+            247
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start with a word-embedding layer that maps a bag-of-words representation of a document into an averaged word embedding, and the word embedding $W ^ { ( 0 ) } \\in \\mathbb { R } ^ { d _ { x } \\times d _ { h } }$ is to be trained as a part of the model: ",
+        "bbox": [
+            173,
+            258,
+            825,
+            303
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4c337f5ce2970915b5f7a7e0eaaeaf0d4c98840b55f3711b6513956bb21fffe2.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { H ^ { ( 1 ) } } } & { { = } } & { { \\mathrm { R e L U } ( X W ^ { ( 0 ) } ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            308,
+            598,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This is followed by layers of attention-guided propagation layers parameterized by $\\beta ^ { ( t ) } \\in \\mathbb { R }$ at each layer, ",
+        "bbox": [
+            173,
+            335,
+            826,
+            366
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66c97d0799b96c3fdd006b7b233096d6fcb4ddcf4ece5b2f47a8ba7fb53f5146.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { H ^ { ( t + 1 ) } } } & { { = } } & { { P ^ { ( t ) } H ^ { ( t ) } , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            371,
+            583,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the propagation matrix $P ^ { ( t ) } \\in \\mathbb { R } ^ { n \\times n }$ is also a function of the input states $H ^ { ( t ) }$ and is zero for absent edges such that the output row-vector of node $i$ is ",
+        "bbox": [
+            174,
+            397,
+            825,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7002745995f98afe054c8d766a9a2cb98b59f0597762d7710f5e33419e9d7221.jpg",
+        "text": "$$\nH _ { i } ^ { ( t + 1 ) } = \\sum _ { j \\in N ( i ) \\cup \\{ i \\} } P _ { i j } ^ { ( t ) } H _ { j } ^ { ( t ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            433,
+            616,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with $P _ { i } ^ { ( t ) } = \\mathrm { s o f t m a x } \\Big ( [ \\beta ^ { ( t ) } \\cos ( H _ { i } ^ { ( t ) } , H _ { j } ^ { ( t ) } ) ] _ { j \\in N ( i ) \\cup \\{ i \\} } \\Big )$ and $\\cos ( x , y ) = x ^ { T } y / \\| x \\| \\| y \\|$ with the $L _ { 2 }$ norm $\\lVert x \\rVert$ , for $t \\in \\{ 1 , \\ldots , \\ell \\}$ and an integer $\\ell$ . Here $\\ell$ is the number of propagation layers. Note that the new propagation above is dynamic; propagation changes over the layers with differing $\\beta ^ { ( t ) }$ and also the hidden states. It is also adaptive; it learns to weight more relevant neighbors higher. We add the self-loop in the propagation to ensure that the features and the hidden states of the node itself are not lost in the propagation process. The output layer has a weight $W ^ { ( 1 ) } \\in \\mathbb { R } ^ { d _ { h } \\times d _ { y } }$ : ",
+        "bbox": [
+            173,
+            478,
+            825,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5df74ef8b1788b5c2d2d19065aeb49b21cbc75e2dd4619f6054e9b29072fd4ce.jpg",
+        "text": "$$\nZ ~ = ~ f ( X , A ) ~ = ~ \\mathrm { s o f t m a x } \\big ( H ^ { ( \\ell + 1 ) } W ^ { ( 1 ) } \\big ) \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            583,
+            663,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The weights $W ^ { ( 0 ) } , W ^ { ( 1 ) }$ , and $\\beta ^ { ( t ) }$ ’s are trained on a cross entropy loss in (2). To ease the notations, we have assumed that the input feature vectors to the first and last layers are augmented with a scalar constant of one, so that the standard bias term can be included in the parameters $W ^ { ( 0 ) }$ and $W ^ { ( 1 ) }$ . ",
+        "bbox": [
+            174,
+            611,
+            825,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The softmax function at attention ensures that the propagation layer $P ^ { ( t ) }$ row-sums to one. The attention from node $j$ to node $i$ is ",
+        "bbox": [
+            173,
+            664,
+            823,
+            693
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b80cd0ba89f637856b9544fbd0c9ace13e8795d58f2b5d1ada31aee81b3514e0.jpg",
+        "text": "$$\n\\begin{array} { r c l } { P _ { i j } ^ { ( t ) } } & { = } & { ( 1 / C ) e ^ { \\beta ^ { ( t ) } \\cos ( H _ { i } ^ { ( t ) } , H _ { j } ^ { ( t ) } ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            700,
+            620,
+            726
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { C = \\sum _ { j \\in N ( i ) \\cup \\{ i \\} } e ^ { \\beta ^ { ( t ) } \\cos ( H _ { i } ^ { ( t ) } , H _ { j } ^ { ( t ) } ) } } \\end{array}$ eβ(t) cos(H(t)i ,H(t)j ) which captures how relevant j is to i, as measured by the cosine of the angle between the corresponding hidden states. We show how we can interpret the attentions in Section 5.2 and show that the attention selects neighbors with the same class to be more relevant. On the standard benchmark datasets on citation networks, we show in Section 5 that this architecture achieves the best performance in Table 2. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            809
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here we note that independently from this work attention over sets has been proposed as “neighborhood attention” (Duan et al., 2017; Hoshen, 2017) for a different application. The main difference of AGNN with respect to these work is the fact that in AGNN attention is computed over a neighborhood of a node on a graph, whereas in these work attention over set of all entities is used to construct a “soft neighborhood”. ",
+        "bbox": [
+            173,
+            815,
+            825,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ON BENCHMARK CITATION NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            660,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On standard benchmark datasets of three citation networks, we test our proposed AGNN model on semi-supervised learning tasks. We test on a fixed split of labeled/validation/test sets from Yang et al. (2016) and compare against baseline methods in Table 2. We also test it on random splits of the same sizes in Table 3, and random splits with larger number of labeled nodes in Table 4. ",
+        "bbox": [
+            174,
+            135,
+            825,
+            191
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Benchmark Datasets. A citation network dataset consists of documents as nodes and citation links as directed edges. Each node has a human annotated topic from a finite set of classes and a feature vector. We consider three datasets3. For CiteSeer and Cora datasets, the feature vector has binary entries indicating the presence/absence of the corresponding word from a dictionary. For PubMed dataset, the feature vector has real-values entries indicating Term Frequency-Inverse Document Frequency (TF-IDF) of the corresponding word from a dictionary. Although the networks are directed, we use undirected versions of the graphs for all experiments, as is common in all baseline approaches. ",
+        "bbox": [
+            174,
+            198,
+            825,
+            310
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/32e48a75cc19cbd0830eb52a479c3da4ee6d4d9fff8ad25891d44ab36dce0a58.jpg",
+        "table_caption": [
+            "Labeled nodes ",
+            "Table 1: Citation Network Dataset "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Nodes</td><td>Edges</td><td>Classes</td><td>Features</td><td>Table 2</td><td>Table 3</td><td>Table 4</td><td></td></tr><tr><td>CiteSeer</td><td>3,327</td><td>4,732</td><td>6</td><td>3,703</td><td>120</td><td>120</td><td>2,218</td><td>2,994</td></tr><tr><td>Cora</td><td>2,708</td><td>5,429</td><td>7</td><td>1,433</td><td>140</td><td>140</td><td>1,805</td><td>2,437</td></tr><tr><td>PubMed</td><td>19,717</td><td>44,328</td><td>3</td><td>500</td><td>60</td><td>60</td><td>13,145</td><td>17,745</td></tr></table>",
+        "bbox": [
+            189,
+            343,
+            805,
+            405
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experimental setup. The accuracy of the baseline methods are all taken from existing literature. If a baseline result is not reported in the existing literature, we intentionally left those cells empty in the table for fairness, as opposed to running those experiments ourselves on untuned hyperparameters. We train and test only the two models we propose: GLN for comparisons and our proposed AGNN model. We do not use the validation set labels in training, but use them for optimizing hyperparameters like dropout rate, learning rate, and $L _ { 2 }$ -regularization factor. For AGNN, we use a fixed number of $d _ { h } = 1 6$ units in the hidden layers and use 4 propagation layers $\\ell = 4$ ) for CiteSeer and Pubmed and 3 propagation layers $\\ell = 3$ ) for Cora as defined in (7). For GLN, we use 2 propagation layers as defined in (1). We row-normalize the input feature vectors, as is standard in the literature. The tables below show the average accuracy with the standard error over 100 training instances with random weight initializations. We implement our model on TensorFlow (Abadi et al., 2016), and the computational complexity of evaluating AGNN is $O ( \\ell d _ { h } | E | + d _ { x } d _ { h } n )$ . Detailed desription of the experiments is provided in Appendix B. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            630
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 PREDICTION ACCURACY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            651,
+            383,
+            665
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fixed data splits. In this first experiment, we use the fixed data splits from Yang et al. (2016) as they are the standard benchmark data splits in literature. All experiments are run on the same fixed split of 20 labeled nodes for each class, 500 nodes for validation, 1,000 nodes for test, and the rest of nodes as unlabeled data. Perhaps surprisingly, the linear classifier GLN we proposed in (3) achieves performance comparable to or exceeding the state-of-the-art performance of GCN. This leads to our novel attention-based model AGNN defined in (6), which achieves the best accuracy on all datasets with a gap larger than the standard error. The classification accuracy of all the baseline methods are collected from (Yang et al., 2016; Kipf & Welling, 2016; Such et al., 2017; Monti et al., 2016; Buchnik & Cohen, 2017; Verma et al., 2017). ",
+        "bbox": [
+            174,
+            678,
+            825,
+            803
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In semi-supervised learning on graphs, it is critical to utilize both the structure of the graph and the node features. Methods not using all the given data achieve performance far from the stateof-the-art. Supervised methods–Single and Multi-layer Perceptrons–only use the labeled examples $( Y _ { L } , X _ { L } )$ . Semi-supervised methods, e.g. T-SVM, only use the labeled and unlabeled examples $Y _ { L }$ , and $X$ . Skip-gram based approaches, such as DeepWalk, ignores the node features $X$ and only use the labels $Y _ { L }$ and the graph $G$ . ",
+        "bbox": [
+            174,
+            810,
+            825,
+            893
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3609b9d90058dc99d5f9c65ba4a566b60b977165f4875e2477e3526a326b3803.jpg",
+        "table_caption": [
+            "Table 2: Classification accuracy with a fixed split of data from (Yang et al., 2016). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input</td><td>Method</td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td rowspan=\"2\">YL,XL</td><td>Singlelayer Perceptron</td><td>57.2</td><td>57.4</td><td>69.8</td></tr><tr><td>Multilayer Perceptron</td><td>64.0</td><td>57.5</td><td>71.4</td></tr><tr><td>YL，X</td><td>T-SVM (Joachims, 1999)</td><td>64.0</td><td>57.5</td><td>62.2</td></tr><tr><td>YL,G</td><td>DeepWalk (Perozzi et al., 2014) node2vec (Grover &amp; Leskovec,2016)</td><td>43.2 54.7</td><td>67.2 74.9</td><td>65.3 75.3</td></tr><tr><td rowspan=\"14\">YL,X,G</td><td>LP (Zhu et al., 2003)</td><td>45.3</td><td>68.0</td><td>63.0</td></tr><tr><td>ICA (Lu &amp; Getoor,2003)</td><td>69.1</td><td>75.1</td><td>73.9</td></tr><tr><td>ManiReg (Belkin et al.,2006)</td><td>60.1</td><td>59.5</td><td>70.7</td></tr><tr><td>SemiEmb (Weston et al., 2012)</td><td>59.6</td><td>59.0</td><td>71.1</td></tr><tr><td>DCNN (Atwood &amp; Towsley,2016)</td><td></td><td>76.8</td><td>73.0</td></tr><tr><td>Planetoid (Yang et al., 2016)</td><td>64.7</td><td>75.7</td><td>77.2</td></tr><tr><td>MoNet (Monti et al., 2016)</td><td></td><td>81.7</td><td>78.8</td></tr><tr><td>Graph-CNN (Such et al., 2017)</td><td></td><td>76.3</td><td></td></tr><tr><td>DynamicFilter (Verma et al., 2017)</td><td></td><td>81.6</td><td>79.0</td></tr><tr><td>Bootstrap (Buchnik &amp; Cohen,2017)</td><td>53.6</td><td>78.4</td><td>78.8</td></tr><tr><td>GCN (Kipf &amp; Welling,2016)</td><td>70.3</td><td>81.5</td><td>79.0</td></tr><tr><td>GLN</td><td>70.9±.05</td><td>81.2±.05</td><td>78.9±.05</td></tr><tr><td>AGNN (this paper)</td><td>71.7±.08</td><td>82.6±.09</td><td>79.9±.07</td></tr></table>",
+        "bbox": [
+            199,
+            99,
+            794,
+            369
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A breakthrough result of Planetoid by Yang et al. (2016) significantly improved upon the existing skip-gram based method of DeepWalk and node2vec and the Laplacian regularized methods of ManiReg and SemiEmb. Kipf & Welling (2016) was the first to apply a graph neural network to citation datasets, and achieved the state-of-the-art performance with GCN. Other variations of graph neural networks immediately followed, achieving comparable performance with MoNet, GraphCNN, and DynamicFilter. Bootstrap uses a Laplacian regularized approach of (Zhou et al., 2004a) as a sub-routine with bootstrapping to feed high-margin predictions as seeds. ",
+        "bbox": [
+            173,
+            429,
+            825,
+            527
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Random splits. Next, following the setting of Buchnik & Cohen (2017), we run experiments keeping the same size in labeled, validation, and test sets as in Table 2, but now selecting those nodes uniformly at random. This, along with the fact that different topics have different number of nodes in it, means that the labels might not be spread evenly across the topics. For 20 such randomly drawn dataset splits, average accuracy is shown in Table 3 with the standard error. As we do not force equal number of labeled data for each class, we observe that the performance degrades for all methods compared to Table 2, except for DeepWalk. AGNN achieves the best performance consistently. Here, we note that Kipf & Welling (2016) does a similar but different experiment using GCN, where random labeled nodes are evenly spread across topics so that each topic has exactly 20 labeled examples. As this difference in sampling might affect the accuracy, we do not report those results in this table. ",
+        "bbox": [
+            173,
+            534,
+            825,
+            686
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6b31d2cfb7235c17aa69af13e82d8cea08cf6ad6862f6b30eb0a078d0dc9e755.jpg",
+        "table_caption": [
+            "Table 3: Classification accuracy with random splits of the data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td>DeepWalk (Perozzi et al., 2014)</td><td>47.2</td><td>70.2</td><td>72.0</td></tr><tr><td>node2vec (Grover&amp;Leskovec,2016)</td><td>47.3</td><td>72.9</td><td>72.4</td></tr><tr><td>Bootstrap (Buchnik &amp; Cohen,2017)</td><td>50.3</td><td>78.2</td><td>75.6</td></tr><tr><td>GLN</td><td>68.4±0.45</td><td>80.0±0.43</td><td>77.7±0.63</td></tr><tr><td>AGNN (this paper)</td><td>69.8±0.35</td><td>81.0±0.34</td><td>78.0±0.46</td></tr></table>",
+        "bbox": [
+            228,
+            700,
+            764,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Larger training set. Following the setting of Such et al. (2017), we run experiments with larger number of labeled data on Cora dataset. We perform $k$ -fold cross validation experiments for $k =$ 3 and 10, by uniformly and randomly dividing the nodes into $k$ equal sized partitions and then performing $k$ runs of training by masking the labels of each of the $k$ partitions followed by validation on the masked nodes. Finally the average validation accuracy across $k$ runs is reported. We run 10 trials of this experiment and reports the mean and standard error of the average $k$ -fold validation accuracy. Compared to Table 2, the performance increases with the size of the training set, and AGNN consistently outperforms the current state-of-the-art architecture for this experiment. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/368a158e793add5cac669abe0fbeae208e8e62e32e0cd5c70217b6ffce0f70fa.jpg",
+        "table_caption": [
+            "Table 4: Classification accuracy with larger sets of labelled nodes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>3-fold Split</td><td>10-fold split</td></tr><tr><td>Graph-CNN (Such et al., 2017)</td><td>87.55±1.38</td><td>89.18±1.96</td></tr><tr><td>GLN</td><td>87.98±0.08</td><td>88.24±0.07</td></tr><tr><td>AGNN (this paper)</td><td>89.07±0.08</td><td>89.60±0.09</td></tr></table>",
+        "bbox": [
+            281,
+            142,
+            707,
+            204
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 QUALITATIVE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            256,
+            383,
+            270
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One useful aspect of incorporating attention into a model is that it provides some form of interpretation capability (Bahdanau et al., 2014). The learned $P _ { i j } ^ { ( t ) }$ ’s in Eq. (7) represent the attention from node $j$ to node $i$ , and provide insights on how relevant node $j$ is in classifying node $i$ . In Figure 1, we provide statistics of this attention over all adjacent pairs of nodes for Cora and CiteSeer datasets. We refer to Figure 3 for similar statistics on PubMed. In Figure 1, we show average attention from a node in topic $c _ { 2 }$ (column) to a node in topic $c _ { 1 }$ (row), which we call the relevance from $c _ { 2 }$ to $c _ { 1 }$ and is defined as ",
+        "bbox": [
+            173,
+            281,
+            825,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7a80ad2964a72f132b0273ae09aa3b93a377df58eccecbfb6dc5d70874226ee.jpg",
+        "text": "$$\n\\mathrm { R e l e v a n c e } ( c _ { 2 } \\to c _ { 1 } ) = \\frac { 1 } { | S _ { c _ { 1 } , c _ { 2 } } | } \\sum _ { ( i , j ) \\in S _ { c _ { 1 } , c _ { 2 } } } R ( j \\to i ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            382,
+            671,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "for edge-wise relevance score defined as ",
+        "bbox": [
+            174,
+            426,
+            439,
+            441
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7705d01a741dcf4321d3ee87f8c08347249663613d299fb2e57d1955cb301b6d.jpg",
+        "text": "$$\nR ( j \\to i ) = \\left( P _ { i j } ^ { ( t ) } - \\frac { 1 } { | N ( i ) | + 1 } \\right) \\Biggl / \\frac { 1 } { | N ( i ) | + 1 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            444,
+            661,
+            487
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $| N ( i ) |$ is the degree of node $i$ , and $S _ { c _ { 1 } , c _ { 2 } } = \\{ ( i , j ) \\in E ^ { s }$ and $Y _ { i } = c _ { 1 } , Y _ { j } = c _ { 2 } \\}$ where $E ^ { s } =$ $E \\cup \\{ ( i , i )$ for $i \\in V \\}$ is the edge set augmented with self-loops to include all the attentions learned. If we are not using any attention, then the typical propagation will be uniform $P _ { i j } = 1 / ( | N ( i ) | + 1 )$ , in which case the above normalized attention is zero. We are measuring for each edge the variation of attention $P _ { i j }$ from uniform $1 / ( | N ( i ) | + 1 )$ as a multiplicative error, normalized by $1 / ( | N ( i ) | + 1 )$ . We believe this is the right normalization, as attention should be measure in relative strength to others in the same neighborhood, and not in absolute additive differences. We are measuring this multiplicative variation of the attention, averaged over the ordered pairs of classes. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows the relevance score for CiteSeer and Cora datasets. (PubMed is shown in Appendix A.) For both datasets, the diagonal entries are dominant indicating that the attention is learning to put more weight to those in the same class. A higher value of Relevance $' c _ { 2 }  c _ { 1 } ,$ ) indicates that, on average, a node in topic $c _ { 1 }$ pays more attention to a neighbor in topic $c _ { 2 }$ than neighbors from other topics. For CiteSeer dataset (Figure 1 left), we are showing the average attention at the first propagation layer, $P ^ { ( t = 1 ) }$ , for illustration. In the off-diagonals, the most influential relations are $\\mathrm { H C I } {  } .$ Agents, Agents ${ \\bf \\Gamma } \\to { \\bf M L }$ , Agents $\\mathrm { \\Gamma \\to H C I }$ , and ML Agents, and the least influential relations are $\\mathrm { A I } {  } \\mathrm { I R }$ and DB $\\bf \\Pi _ { \\Pi } {  } \\bf M \\cal L$ . Note that these are papers in computer science from late 90s to early 2000s. For Cora dataset (Figure 1 right), we are showing the relevance score of the second propagation layer, $P ^ { ( t = 2 ) }$ , for illustration. In the off-diagonals, the most influential relations are $\\mathrm { C B } {  } \\mathrm { P M }$ , $\\mathrm { P M } \\to \\mathrm { C B }$ , Rule $\\mathrm { \\Gamma } \\to \\mathrm { P M }$ , and $\\mathrm { P M } \\to$ Rule, and the least influential relations are $\\mathbf { G A } {  } \\mathbf { P M }$ and $\\mathrm { P M } \\to \\mathrm { R L }$ . This dataset has papers in computer science from the 90s. We note that these relations are estimated solely based on the available datasets for that period of time and might not accurately reflect the relations for the entire academic fields. We also consider these relations as a static property in this analysis. If we have a larger corpus over longer period of time, it is possible to learn the influence conditioned on the period and visualize how these relations change. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next, we analyze the edges with high and low relevance scores. We remove the self-loops and then sort the edges according to the relevance score defined in Eq. (9). We take the top 100 and bottom 100 edges and with respect to their relevance scores, and report the fraction of the edges which are connecting nodes from the same class. Table 5 shows the result on the benchmark datasets for the relevance scores calculated using the last propagation layer. This suggests that our architecture learns to put higher attention between nodes of the same class. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/ba9d7104cc0e9d79b46371f0bebb1fac0ad6022efdbbfa7063a3fd2563ba6190.jpg",
+        "image_caption": [
+            "Figure 1: Relevance score in Eq. (8) from a neighbor node with column-class to a center node in row-class. For example the average normalized attention to Agents from HCI is $= - 0 . 1 4 1$ , largest off-diagonal entry in CiteSeer. The average attention to Probabilistic Methods (PM) from Case Based (CB) is 0.017, largest off-diagonal entry in Cora. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            98,
+            797,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/04cc357c7523ae4db245c22085f8635232144c3d4c00d69083dae1dbacadd0f1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td>Top 100</td><td>0.69</td><td>0.64</td><td>0.69</td></tr><tr><td>Bottom 100</td><td>0.34</td><td>0.09</td><td>0.13</td></tr></table>",
+        "bbox": [
+            346,
+            348,
+            647,
+            395
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Fraction of edges from top 100 most relevant edges and bottom 100 least relevant edges which are connecting two distinct nodes from the same class. ",
+        "bbox": [
+            171,
+            404,
+            823,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we analyze those nodes in the test sets that were mistaken by GCN but correctly classified by AGNN, and show how our attention mechanism weighted the contribution of its local neighborhood, and show three illustrative examples in Figure 2. More examples of this local attention network (including the legends for the color coding of the topics) are provided in Appendix A. We show a entire 2-hop neighborhood of a target node (marked by a thick outline) from the test set of the fixed data splits of Citeseer, Cora, or Pubmed. The colors denote the true classes of the nodes (including the target) in the target’s neighborhood, some of which are unknown to the models at the training time. The radius of a node $j$ is proportional to the attention to the target node $i$ aggregated over all the layers, i.e. $( P ^ { ( t = 4 ) } P ^ { ( t = 3 ) } P ^ { ( t = 2 ) } P ^ { ( t = 1 ) } ) _ { i j }$ for CiteSeer. The size of the target node reflects its self-attention defined in a similar way. The first example on the left is node 8434 from PubMed. AGNN correctly classifies the target node as light blue, whereas GCN mistakes it for yellow, possibly because it is connected to more yellow nodes. Not only has the attention mechanism learned to put more weight to its light blue 1-hop neighbor, but put equally heavy weights to a path of light blue neighbors some of which are not immediately connected to the target node. The second example in the middle is node 1580 from PubMed. AGNN correctly classifies it as yellow, whereas GCN mistakes it for a red, possibly because it only has two neighbors. Not only has the attention mechanism learned to put more weight to the yellow neighbor, but it has weighted the yellow neighbor (who is connected to many yellow nodes and perhaps has more reliable hidden states representing the true yellow class) even more than itself. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The last example on the right is node 1512 from CiteSeer. AGNN correctly classifies it as light blue, whereas GCN mistakes it for a white. This is a special example as those two nodes are completely isolated. Due to the static and non-adaptive propagation of GCN, it ends up giving the same prediction for such isolated pairs. If the pair has two different true classes, then it always fails on at least on one of them (in this case the light blue node). However, AGNN is more flexible in adapting to such graph topology and puts more weight to the target node itself, correctly classifying both. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            815
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            328,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present an attention-based graph neural network model for semi-supervised classification on a graph. We demonstrate that our method consistently outperforms competing methods on the standard benchmark citation network datasets. We also show that the learned attention also provides interesting insights on how neighbors influence each other. In training, we have tried more complex attention models. However, due to the increased model complexity the training was not stable and does not give higher accuracy. We believe that for semi-supervised setting with such a limited number of labeled examples, reducing model complexity is important. Note that we are able to train deeper (4-layers) models compared to a shallower (2-layers) model of GCN, in part due to the fact that we remove the non-linear layers and reduce the model complexity significantly. In comparison, deeper GCN models are known to be unstable and do not give the performance of shallower GCNs (Kipf & Welling, 2016). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/746099e24bddd012b7ea228587a2be040c6b393b554acb382dc318aad4054062.jpg",
+        "image_caption": [
+            "Figure 2: We show three selected target nodes in the test set that are mistaken by GCN but correctly classified by AGNN. We denote this target node by the node with a thick outline (node 8434 from PubMed on the left, node 1580 from PubMed in the middle, and node 1512 from CiteSeer on the right). We show the strength of attention from a node in the 2-hop neighborhood to the target node by the size of the corresponding node. Colors represent the hidden true classes (nodes with the same color belong to the same topic). None of the nodes in the figure was in the training set, hence none of the colors were revealed. Still, we observe that AGNN has managed to put more attention to those nodes in the same (hidden) classes, allowing the trained model to find the correct labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            106,
+            821,
+            232
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            390,
+            825,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            285,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Gunnemann A. Bojchevski. Deep gaussian embedding of attributed graphs: Unsupervised inductive learning via ranking. arXiv preprint arXiv:1707.03815, 2017.   \nMartin Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.   \nJ. Atwood and D. Towsley. Diffusion-convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 1993–2001, 2016.   \nDzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.   \nMikhail Belkin, Partha Niyogi, and Vikas Sindhwani. Manifold regularization: A geometric framework for learning from labeled and unlabeled examples. Journal of machine learning research, 7 (Nov):2399–2434, 2006.   \nR. van den Berg, T. N. Kipf, and M. Welling. Graph convolutional matrix completion. arXiv preprint arXiv:1706.02263, 2017.   \nAvrim Blum and Shuchi Chawla. Learning from labeled and unlabeled data using graph mincuts. In ICML ’01 Proceedings of the Eighteenth International Conference on Machine Learning, 2001.   \nMichael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. arXiv preprint arXiv:1611.08097, 2016.   \nJ. Bruna and X. Li. Community detection with graph neural networks. arXiv preprint arXiv:1705.08415, 2017.   \nJoan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013. ",
+        "bbox": [
+            171,
+            531,
+            826,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eliav Buchnik and Edith Cohen. Bootstrapped graph diffusions: Exposing the power of nonlinearity. arXiv preprint arXiv:1703.02618, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olivier Chapelle, Bernhard Scholkopf, and Alexander Zien. Semi-supervised learning (chapelle, o. et al., eds.; 2006)[book reviews]. IEEE Transactions on Neural Networks, 20(3):542–542, 2009. ",
+        "bbox": [
+            173,
+            141,
+            821,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "H. Dai, B. Dai, and L. Song. Discriminative embeddings of latent variable models for structured data. In International Conference on Machine Learning, pp. 2702–2711, 2016. ",
+        "bbox": [
+            174,
+            179,
+            823,
+            209
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hanjun Dai, Elias B Khalil, Yuyu Zhang, Bistra Dilkina, and Le Song. Learning combinatorial optimization algorithms over graphs. arXiv preprint arXiv:1704.01665, 2017. ",
+        "bbox": [
+            171,
+            217,
+            823,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks ¨ on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3837–3845, 2016. ",
+        "bbox": [
+            174,
+            255,
+            823,
+            299
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Marcin Andrychowicz, Bradly Stadie, Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. arXiv preprint arXiv:1703.07326, 2017. ",
+        "bbox": [
+            176,
+            308,
+            823,
+            351
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan´ Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015. ",
+        "bbox": [
+            176,
+            359,
+            821,
+            402
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Evgeniy Faerman, Felix Borutta, Kimon Fountoulakis, and Michael W Mahoney. Lasagne: Locality and structure aware graph node embedding. arXiv preprint arXiv:1710.06520, 2017. ",
+        "bbox": [
+            174,
+            410,
+            821,
+            440
+        ],
+        "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. arXiv preprint arXiv:1704.01212, 2017. ",
+        "bbox": [
+            171,
+            448,
+            821,
+            478
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In Neural Networks, 2005. IJCNN’05. Proceedings. 2005 IEEE International Joint Conference on, volume 2, pp. 729–734. IEEE, 2005. ",
+        "bbox": [
+            173,
+            486,
+            823,
+            530
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014. ",
+        "bbox": [
+            171,
+            539,
+            826,
+            569
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A. Grover and J. Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 855–864. ACM, 2016. ",
+        "bbox": [
+            173,
+            577,
+            823,
+            619
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "W. L. Hamilton, R. Ying, and J. Leskovec. Inductive representation learning on large graphs. arXiv preprint arXiv:1706.02216, 2017. ",
+        "bbox": [
+            169,
+            628,
+            825,
+            659
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015. ",
+        "bbox": [
+            166,
+            666,
+            825,
+            696
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yedid Hoshen. Vain: Attentional multi-agent predictive modeling. In Advances in Neural Information Processing Systems, pp. 2698–2708, 2017. ",
+        "bbox": [
+            168,
+            705,
+            823,
+            734
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thorsten Joachims. Transductive inference for text classification using support vector machines. In ICML, volume 99, pp. 200–209, 1999. ",
+        "bbox": [
+            169,
+            742,
+            825,
+            772
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "T. N. Kipf and M. Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016. ",
+        "bbox": [
+            169,
+            781,
+            825,
+            810
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Q. Le and T. Mikolov. Distributed representations of sentences and documents. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1188–1196, 2014. ",
+        "bbox": [
+            173,
+            819,
+            825,
+            848
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Y. Li, D. Tarlow, M. Brockschmidt, and R. Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qing Lu and Lise Getoor. Link-based classification. In Proceedings of the 20th International Conference on Machine Learning (ICML-03), pp. 496–503, 2003. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M\\` Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. arXiv preprint arXiv:1611.08402, 2016. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M. Niepert, M. Ahmed, and K. Kutzkov. Learning convolutional neural networks for graphs. In Proceedings of the 33rd annual international conference on machine learning. ACM, 2016. ",
+        "bbox": [
+            169,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kamal Nigam, Andrew McCallum, and Tom Mitchell. Semi-supervised text classification using em. Semi-Supervised Learning, pp. 33–56, 2006. ",
+        "bbox": [
+            173,
+            194,
+            820,
+            223
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A. Nowak, S. Villar, A. S. Bandeira, and J. Bruna. A note on learning algorithms for quadratic assignment with graph neural networks. arXiv preprint arXiv:1706.07450, 2017. ",
+        "bbox": [
+            171,
+            232,
+            820,
+            262
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B. Perozzi, R. Al-Rfou, and S. Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014. ",
+        "bbox": [
+            174,
+            270,
+            823,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2009. ",
+        "bbox": [
+            173,
+            323,
+            821,
+            352
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M. Schlichtkrull, T. N. Kipf, P. Bloem, R. van den Berg, I. Titov, and M. Welling. Modeling relational data with graph convolutional networks. arXiv preprint arXiv:1703.06103, 2017. ",
+        "bbox": [
+            171,
+            361,
+            823,
+            391
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Felipe Petroski Such, Shagan Sah, Miguel Dominguez, Suhas Pillai, Chao Zhang, Andrew Michael, Nathan Cahill, and Raymond Ptucha. Robust spatial filtering with graph convolutional neural networks. arXiv preprint arXiv:1703.00792, 2017. ",
+        "bbox": [
+            174,
+            400,
+            823,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, arthur szlam, and Rob Fergus. Learning multiagent communication with backpropagation. In Advances in Neural Information Processing Systems 29, pp. 2244–2252. 2016. ",
+        "bbox": [
+            174,
+            452,
+            823,
+            494
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jian Tang, Meng Qu, Mingzhe Wang, Ming Zhang, Jun Yan, and Qiaozhu Mei. Line: Large-scale information network embedding. In Proceedings of the 24th International Conference on World Wide Web, pp. 1067–1077. ACM, 2015. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitika Verma, Edmond Boyer, and Jakob Verbeek. Dynamic filters in graph convolutional networks. arXiv preprint arXiv:1706.05206, 2017. ",
+        "bbox": [
+            173,
+            556,
+            821,
+            585
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Fred´ eric Ratle, Hossein Mobahi, and Ronan Collobert. Deep learning via semi- ´ supervised embedding. In Neural Networks: Tricks of the Trade, pp. 639–655. Springer, 2012. ",
+        "bbox": [
+            173,
+            594,
+            821,
+            625
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In International Conference on Machine Learning, pp. 2048–2057, 2015. ",
+        "bbox": [
+            176,
+            633,
+            823,
+            676
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaojun Xu, Chang Liu, Qian Feng, Heng Yin, Le Song, and Dawn Song. Neural networkbased graph embedding for cross-platform binary code similarity detection. arXiv preprint arXiv:1708.06525, 2017. ",
+        "bbox": [
+            173,
+            685,
+            823,
+            728
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Cheng Yang, Maosong Sun, Zhiyuan Liu, and Cunchao Tu. Fast network embedding enhancement via high order proximity approximation. In Proceedings of the Twenty-Sixth International Joint Conference on Artificial Intelligence, IJCAI, pp. 19–25, 2017. ",
+        "bbox": [
+            173,
+            738,
+            823,
+            781
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Z. Yang, W. W. Cohen, and R. Salakhutdinov. Revisiting semi-supervised learning with graph embeddings. arXiv preprint arXiv:1603.08861, 2016. ",
+        "bbox": [
+            169,
+            790,
+            823,
+            819
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Denny Zhou, Olivier Bousquet, Thomas N Lal, Jason Weston, and Bernhard Scholkopf. Learning ¨ with local and global consistency. In Advances in neural information processing systems, pp. 321–328, 2004a. ",
+        "bbox": [
+            173,
+            829,
+            823,
+            871
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Denny Zhou, Olivier Bousquet, Thomas N Lal, Jason Weston, and Bernhard Scholkopf. Learning ¨ with local and global consistency. In Advances in neural information processing systems, pp. 321–328, 2004b. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label propagation. 2002. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xiaojin Zhu, Zoubin Ghahramani, and John D Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the 20th International conference on Machine learning (ICML-03), pp. 912–919, 2003. ",
+        "bbox": [
+            176,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            264,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A ADDITIONAL EXPERIMENTS ON INTERPRETABILITY OF ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            136,
+            766,
+            151
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "PubMed dataset has only 3 classes, and the relevance score is shown in the figure below. ",
+        "bbox": [
+            173,
+            165,
+            751,
+            181
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/218614320c5e8af70e050b686490d68b16ad4a69af18a7e847312779b9e4dd46.jpg",
+        "image_caption": [
+            "Figure 3: Average attention in Eq. (8) from a column class to a row class "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            189,
+            622,
+            367
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We show examples of 2-hop local neighborhood of nodes that are mistaken by GCN but correctly classified by AGNN. ",
+        "bbox": [
+            173,
+            411,
+            825,
+            440
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/e4934394b1d8b00da6d1f5ba19edaf716754392d6b2bea3861bb5150deafc241.jpg",
+        "image_caption": [
+            "Figure 4: Examples from CiteSeer dataset of attention strength in the local neighborhood of a target node (in thick outline) from the test set that is mistaken by GCN but correctly classified by AGNN. Colors are true classes and node sizes are proportional to the attention strength from a neighbor to the target node. Labeled nodes from training set are marked with ‘\\*’. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            458,
+            846,
+            690
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B EXPERIMENT AND ARCHITECT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            787,
+            545,
+            804
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In this section we will list all the choices made in training and tuning of hyper-parameters. The parameters are chosen as to maximize the validation. All the models use Adam optimization algorithm with full-batchs, as standard in other works on GNNs (Kipf & Welling, 2016; Such et al., 2017). We also a weight decay term to the objective function for all the learnable weights. We add dropout to the first and last layers of all models. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Table 6. we show the hyper-parameters used in training the AGNN models for various settings and datasets. For Cora dataset the architecture consist of $\\ell = 3$ propagation layers, but the first propagation layer $P ^ { ( t = 1 ) }$ is non-trainable and the variable $\\beta ^ { ( t = 1 ) }$ value is fixed at zero. While training these AGNN models we maintain the validation accuracy for each iteration and finally choose the trained model parameters from the iteration where average validation accuracy of previous 4 epochs is maximized. For the $k$ -fold cross validation setting we take the epoch with maximum validation accuracy. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/154ecc254c87ebbf4f9d53d65bc0dd13354298aaa3517792e26baa5b82a4dcbc.jpg",
+        "image_caption": [
+            "Figure 5: Examples from Cora dataset of attention strength in the local neighborhood of a target node (in thick outline) from the test set that is mistaken by GCN but correctly classified by AGNN. Colors are true classes and node sizes are proportional to the attention strength from a neighbor to the target node. Labeled nodes from training set are marked with ‘\\*’. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            104,
+            816,
+            359
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb7c08d490ed620cf75a6bc19d8ae206e115d8cc8bcf9e5410bde7b6e9065d14.jpg",
+        "image_caption": [
+            "Figure 6: Examples from Pubmed dataset of attention strength in the local neighborhood of a target node (in thick outline) from the test set that is mistaken by GCN but correctly classified by AGNN. Colors are true classes and node sizes are proportional to the attention strength from a neighbor to the target node. Labeled nodes from training set are marked with ‘\\*’. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            493,
+            854,
+            746
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            852,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/aa2c40b7ab4030cff9a152e6ea8331696a421a504c60796d0c0106397aec957e.jpg",
+        "table_caption": [
+            "Table 6: Hyper-parameters for AGNN model "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"> Setting</td><td rowspan=\"2\">Dataset</td><td rowspan=\"2\">Propagation layers (l)</td><td rowspan=\"2\">Hidden state dimension (dh)</td><td rowspan=\"2\">Learning Rate</td><td rowspan=\"2\">Weight Decay</td><td rowspan=\"2\">Dropout</td><td rowspan=\"2\">Epochs</td></tr><tr><td></td></tr><tr><td>Fixed Split</td><td>CiteSeer</td><td>4</td><td>16</td><td>0.005</td><td>0.0005</td><td>0.5</td><td>1000</td></tr><tr><td>Fixed Split</td><td>Cora</td><td>3</td><td>16</td><td>0.01</td><td>0.0005</td><td>0.5</td><td>1000</td></tr><tr><td>Fixed Split</td><td>PubMed</td><td>4</td><td>16</td><td>0.008</td><td>0.001</td><td>0.5</td><td>400</td></tr><tr><td>Rand. Split</td><td>CiteSeer</td><td>4</td><td>16</td><td>0.01</td><td>0.0005</td><td>0.5</td><td>1000</td></tr><tr><td>Rand. Split</td><td>Cora</td><td>3</td><td>16</td><td>0.01</td><td>0.0005</td><td>0.5</td><td>1000</td></tr><tr><td>Rand. Split</td><td>PubMed</td><td>4</td><td>16</td><td>0.008</td><td>0.001</td><td>0.5</td><td>1000</td></tr><tr><td>Cross Val.</td><td>Cora</td><td>3</td><td>16</td><td>0.04</td><td>0.0005</td><td>0.25</td><td>500</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            872,
+            229
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "For the Graph Linear Network (GLN) as define in (3), we use the same hyper-parameters as GCN (Kipf & Welling, 2016) for all the experimental settings: hidden dimension of 16, learning rate of 0.01, weight decay of $5 \\times 1 0 ^ { - 4 }$ , dropout of 0.5, 200 epochs and early stopping criteria with a window size of 10. ",
+        "bbox": [
+            173,
+            286,
+            825,
+            342
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "C PERFORMANCE VERSUS NUMBER OF PROPAGATION LAYERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            362,
+            710,
+            380
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In this section we provide experimental results justifying the choice of number of propagation layers for each dataset. We use the same data split and hyper-parameters (except number of propagation layer) as in the fixed data splits setting in Section 5.1. Similar to other settings the first propagation layer for Cora dataset is non-trainable with $\\beta ^ { ( t = 1 ) } = 0$ . Tables 7 gives the average (over 10 trials) testing accuracy respectively for various choices of number of propagation layers. We note that different datasets require different number of propagation layers for best performance. ",
+        "bbox": [
+            173,
+            393,
+            826,
+            479
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab84dff101a7be513f462a9a8f8f92c659ebdd71f05a4465a00b79d00ac56005.jpg",
+        "table_caption": [
+            "Table 7: Average testing error of AGNN for different number of Propagation Layers. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Propagation Layers ()</td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td>1</td><td>69.08</td><td>80.52</td><td>78.31</td></tr><tr><td>2</td><td>70.83</td><td>83.07</td><td>79.66</td></tr><tr><td>3</td><td>71.06</td><td>82.62</td><td>79.56</td></tr><tr><td>4</td><td>71.70</td><td>82.24</td><td>80.10</td></tr><tr><td>5</td><td>71.37</td><td>82.07</td><td>80.13</td></tr></table>",
+        "bbox": [
+            334,
+            492,
+            658,
+            592
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/5df7b0dadb876221850732792614b5675e555c31d91c4861628552ded8026730.jpg",
+        "table_caption": [
+            "D PERFORMANCE OF GCN ON OTHER DATASET SPLITS. ",
+            "Table 8: Classification accuracy with random splits of the data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>CiteSeer</td><td>Cora</td><td>PubMed</td></tr><tr><td>DeepWalk (Perozzi et al., 2014)</td><td>47.2</td><td>70.2</td><td>72.0</td></tr><tr><td>node2vec (Grover &amp; Leskovec,2016)</td><td>47.3</td><td>72.9</td><td>72.4</td></tr><tr><td>Bootstrap (Buchnik &amp; Cohen,2017)</td><td>50.3</td><td>78.2</td><td>75.6</td></tr><tr><td>GCN</td><td>66.9±0.50</td><td>79.2±0.46</td><td>77.5±0.61</td></tr><tr><td>GLN</td><td>68.4±0.45</td><td>80.0±0.43</td><td>77.7±0.63</td></tr><tr><td>AGNN (this paper)</td><td>69.8±0.35</td><td>81.0±0.34</td><td>78.0±0.46</td></tr></table>",
+        "bbox": [
+            228,
+            684,
+            764,
+            787
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Here we provide the performance of GCN on random splits and larger training set dataset splits from Section 5.1. We relegate these tables to the appendix since they were not present in Kipf & Welling (2016). We conducted the experiments with the same hyper-parameters as chosen by Kipf & Welling (2016) for the fixed split. In Tables 8 and 9 we provide average testing accuracy and standard error over 20 and 10 runs on random splits and larger training set respectively. ",
+        "bbox": [
+            174,
+            833,
+            825,
+            905
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/d0324e24029a3f1d08cd76bde86228b2b3f2df253fa460370a08cb273d2379be.jpg",
+        "table_caption": [
+            "Table 9: Classification accuracy with larger sets of labelled nodes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>3-fold Split</td><td>10-fold split</td></tr><tr><td>Graph-CNN (Such et al., 2017)</td><td>87.55±1.38</td><td>89.18±1.96</td></tr><tr><td>GCN</td><td>87.23±0.21</td><td>87.78±0.04</td></tr><tr><td>GLN</td><td>87.98±0.08</td><td>88.24±0.07</td></tr><tr><td>AGNN (this paper)</td><td>89.07±0.08</td><td>89.60±0.09</td></tr></table>",
+        "bbox": [
+            284,
+            458,
+            710,
+            531
+        ],
+        "page_idx": 16
+    }
+]