Add files using upload-large-folder tool

parse/train/H1ewdiR5tQ/H1ewdiR5tQ.md

@@ -0,0 +1,327 @@
+# GRAPH WAVELET NEURAL NETWORK
+
+Bingbing $\mathbf { X } \mathbf { u } ^ { 1 , 2 }$ , Huawei Shen1,2, Qi $\mathbf { C a o } ^ { 1 , 2 }$ , Yunqi $\mathbf { Q i u } ^ { 1 , 2 }$ & Xueqi Cheng1,2
+
+1CAS Key Laboratory of Network Data Science and Technology,   
+Institute of Computing Technology, Chinese Academy of Sciences;   
+2School of Computer and Control Engineering,   
+University of Chinese Academy of Sciences   
+Beijing, China   
+{xubingbing,shenhuawei,caoqi,qiuyunqi,cxq}@ict.ac.cn
+
+# ABSTRACT
+
+We present graph wavelet neural network (GWNN), a novel graph convolutional neural network (CNN), leveraging graph wavelet transform to address the shortcomings of previous spectral graph CNN methods that depend on graph Fourier transform. Different from graph Fourier transform, graph wavelet transform can be obtained via a fast algorithm without requiring matrix eigendecomposition with high computational cost. Moreover, graph wavelets are sparse and localized in vertex domain, offering high efficiency and good interpretability for graph convolution. The proposed GWNN significantly outperforms previous spectral graph CNNs in the task of graph-based semi-supervised classification on three benchmark datasets: Cora, Citeseer and Pubmed.
+
+# 1 INTRODUCTION
+
+Convolutional neural networks (CNNs) (LeCun et al., 1998) have been successfully used in many machine learning problems, such as image classification (He et al., 2016) and speech recognition (Hinton et al., 2012), where there is an underlying Euclidean structure. The success of CNNs lies in their ability to leverage the statistical properties of Euclidean data, e.g., translation invariance. However, in many research areas, data are naturally located in a non-Euclidean space, with graph or network being one typical case. The non-Euclidean nature of graph is the main obstacle or challenge when we attempt to generalize CNNs to graph. For example, convolution is not well defined in graph, due to that the size of neighborhood for each node varies dramatically (Bronstein et al., 2017).
+
+Existing methods attempting to generalize CNNs to graph data fall into two categories, spatial methods and spectral methods, according to the way that convolution is defined. Spatial methods define convolution directly on the vertex domain, following the practice of the conventional CNN. For each vertex, convolution is defined as a weighted average function over all vertices located in its neighborhood, with the weighting function characterizing the influence exerting to the target vertex by its neighbors (Monti et al., 2017). The main challenge is to define a convolution operator that can handle neighborhood with different sizes and maintain the weight sharing property of CNN. Although spatial methods gain some initial success and offer us a flexible framework to generalize CNNs to graph, it is still elusive to determine appropriate neighborhood.
+
+Spectral methods define convolution via graph Fourier transform and convolution theorem. Spectral methods leverage graph Fourier transform to convert signals defined in vertex domain into spectral domain, e.g., the space spanned by the eigenvectors of the graph Laplacian matrix, and then filter is defined in spectral domain, maintaining the weight sharing property of CNN. As the pioneering work of spectral methods, spectral CNN (Bruna et al., 2014) exploited graph data with the graph Fourier transform to implement convolution operator using convolution theorem. Some subsequent works make spectral methods spectrum-free (Defferrard et al., 2016; Kipf & Welling, 2017; Khasanova & Frossard, 2017), achieving locality in spatial domain and avoiding high computational cost of the eigendecomposition of Laplacian matrix.
+
+In this paper, we present graph wavelet neural network to implement efficient convolution on graph data. We take graph wavelets instead of the eigenvectors of graph Laplacian as a set of bases, and define the convolution operator via wavelet transform and convolution theorem. Graph wavelet neural network distinguishes itself from spectral CNN by its three desirable properties: (1) Graph wavelets can be obtained via a fast algorithm without requiring the eigendecomposition of Laplacian matrix, and thus is efficient; (2) Graph wavelets are sparse, while eigenvectors of Laplacian matrix are dense. As a result, graph wavelet transform is much more efficient than graph Fourier transform; (3) Graph wavelets are localized in vertex domain, reflecting the information diffusion centered at each node (Tremblay & Borgnat, 2014). This property eases the understanding of graph convolution defined by graph wavelets.
+
+We develop an efficient implementation of the proposed graph wavelet neural network. Convolution in conventional CNN learns an individual convolution kernel for each pair of input feature and output feature, causing a huge number of parameters especially when the number of features is high. We detach the feature transformation from convolution and learn a sole convolution kernel among all features, substantially reducing the number of parameters. Finally, we validate the effectiveness of the proposed graph wavelet neural network by applying it to graph-based semi-supervised classification. Experimental results demonstrate that our method consistently outperforms previous spectral CNNs on three benchmark datasets, i.e., Cora, Citeseer, and Pubmed.
+
+# 2 OUR METHOD
+
+# 2.1 PRELIMINARY
+
+Let $\mathcal { G } = \{ \mathbb { V } , \mathbb { E } , A \}$ be an undirected graph, where $\mathbb { V }$ is the set of nodes with $| \mathbb { V } | = n$ , $\mathbb { E }$ is the set of edges, and $\pmb { A }$ is adjacency matrix with $A _ { i , j } = A _ { j , i }$ to define the connection between node $i$ and node $j$ . The graph Laplacian matrix $\mathcal { L }$ is defined as $\overset { \vartriangle } { \boldsymbol { \mathcal { L } } } = \boldsymbol { D } - \boldsymbol { A }$ where $_ { D }$ is a diagonal degree matrix with $\textstyle D _ { i , i } = \sum _ { j } A _ { i , j }$ , and the normalized Laplacian matrix is ${ \cal L } = I _ { n } - { \cal D } ^ { - 1 / 2 } \bar { \cal A } { \cal D } ^ { - 1 / 2 }$ where ${ { I } _ { n } }$ is the identity matrix. Since $\pmb { L }$ is a real symmetric matrix, it has a complete set of orthonormal eigenvectors $U = \left( \ b { u } _ { 1 } , \ b { u } _ { 2 } , . . . , \ b { u } _ { n } \right)$ , known as Laplacian eigenvectors. These eigenvectors have associated real, non-negative eigenvalues $\{ \lambda _ { l } \} _ { l = 1 } ^ { n }$ , identified as the frequencies of graph. Eigenvectors associated with smaller eigenvalues carry slow varying signals, indicating that connected nodes share similar values. In contrast, eigenvectors associated with larger eigenvalues carry faster varying signals across connected nodes.
+
+# 2.2 GRAPH FOURIER TRANSFORM
+
+Taking the eigenvectors of normalized Laplacian matrix as a set of bases, graph Fourier transform of a signal $\pmb { x } \in R ^ { n }$ on graph $\mathcal { G }$ is defined as $\hat { \pmb x } = \pmb U ^ { \top } \pmb x$ , and the inverse graph Fourier transform is $\mathbf { \pmb { x } } = \pmb { U } \hat { \mathbf { x } }$ (Shuman et al., 2013). Graph Fourier transform, according to convolution theorem, offers us a way to define the graph convolution operator, denoted as $^ { \ast _ { \mathcal { G } } }$ . Denoting with $\textbf {  { y } }$ the convolution kernel, $^ { \ast _ { \mathcal { G } } }$ is defined as
+
+$$
+\pmb { x } \ast _ { \mathscr { G } } \pmb { y } = \pmb { U } \big ( ( \pmb { U } ^ { \top } \pmb { y } ) \odot ( \pmb { U } ^ { \top } \pmb { x } ) \big ) ,
+$$
+
+where $\odot$ is the element-wise Hadamard product. Replacing the vector $\pmb { U } ^ { \top } \pmb { y }$ by a diagonal matrix $g _ { \theta }$ , then Hadamard product can be written in the form of matrix multiplication. Filtering the signal $x$ by the filter $g _ { \theta }$ , we can write Equation (1) as $U g _ { \theta } \pmb { U } ^ { \top } \pmb { x }$ .
+
+However, there are some limitations when using Fourier transform to implement graph convolution: (1) Eigendecomposition of Laplacian matrix to obtain Fourier basis $U$ is of high computational cost with $\bar { O } ( n ^ { 3 } )$ ; (2) Graph Fourier transform is inefficient, since it involves the multiplication between a dense matrix $U$ and the signal $_ { \textbf { \em x } }$ ; (3) Graph convolution defined through Fourier transform is not localized in vertex domain, i.e., the influence to the signal on one node is not localized in its neighborhood. To address these limitations, ChebyNet (Defferrard et al., 2016) restricts convolution kernel $g _ { \theta }$ to a polynomial expansion
+
+$$
+g _ { \theta } = \sum _ { k = 0 } ^ { K - 1 } \theta _ { k } \Lambda ^ { k } ,
+$$
+
+where $K$ is a hyper-parameter to determine the range of node neighborhoods via the shortest path distance, $\theta \in \bar { R } ^ { \bar { K } }$ is a vector of polynomial coefficients, and $\Lambda = \mathrm { d i a g } \big ( \{ \lambda _ { l } \} _ { l = 1 } ^ { n } \big )$ . However, such a polynomial approximation limits the flexibility to define appropriate convolution on graph, i.e., with a smaller $K$ , it’s hard to approximate the diagonal matrix $g _ { \boldsymbol { \theta } }$ with $n$ free parameters. While with a larger $K$ , locality is no longer guaranteed. Different from ChebyNet, we address the aforementioned three limitations through replacing graph Fourier transform with graph wavelet transform.
+
+# 2.3 GRAPH WAVELET TRANSFORM
+
+Similar to graph Fourier transform, graph wavelet transform projects graph signal from vertex domain into spectral domain. Graph wavelet transform employs a set of wavelets as bases, defined as $\psi _ { s } = ( \psi _ { s 1 } , \psi _ { s 2 } , . . . , \psi _ { s n } )$ , where each wavelet $\psi _ { s i }$ corresponds to a signal on graph diffused away from node $i$ and $s$ is a scaling parameter. Mathematically, $\psi _ { s i }$ can be written as
+
+$$
+\psi _ { s } = U G _ { s } U ^ { \top } ,
+$$
+
+where $U$ is Laplacian eigenvectors, $G _ { s } \mathrm { = d i a g } \big ( g ( s \lambda _ { 1 } ) , . . . , g ( s \lambda _ { n } ) \big )$ is a scaling matrix and $g ( s \lambda _ { i } ) =$ $e ^ { \lambda _ { i } s }$ .
+
+Using graph wavelets as bases, graph wavelet transform of a signal $_ { \textbf { \em x } }$ on graph is defined as ${ \hat { \mathbf { x } } } = { }$ ${ \psi } _ { s } ^ { - 1 } \bar { x }$ and the inverse graph wavelet transform is $\boldsymbol { x } = \psi _ { s } \hat { \pmb { x } }$ . Note that $\bar { \psi } _ { s } ^ { - 1 }$ can be obtained by simply replacing the $g ( s \lambda _ { i } )$ in $\psi _ { s }$ with $g ( - s \lambda _ { i } )$ corresponding to a heat kernel (Donnat et al., 2018). Replacing the graph Fourier transform in Equation (1) with graph wavelet transform, we obtain the graph convolution as
+
+$$
+\pmb { x } * _ { \mathscr { G } } \pmb { y } = \psi _ { s } ( ( \psi _ { s } ^ { - 1 } \pmb { y } ) \odot ( \psi _ { s } ^ { - 1 } \pmb { x } ) ) .
+$$
+
+Compared to graph Fourier transform, graph wavelet transform has the following benefits when being used to define graph convolution:
+
+1. High efficiency: graph wavelets can be obtained via a fast algorithm without requiring the eigendecomposition of Laplacian matrix. In Hammond et al. (2011), a method is proposed to use Chebyshev polynomials to efficiently approximate $\psi _ { s }$ and $\psi _ { s } ^ { - 1 }$ , with the computational complexity $O ( m \times | \mathbb { E } | )$ , where $\lvert \mathbb { E } \rvert$ is the number of edges and $m$ is the order of Chebyshev polynomials.
+
+2. High spareness: the matrix $\psi _ { s }$ and $\psi _ { s } ^ { - 1 }$ are both sparse for real world networks, given that these networks are usually sparse. Therefore, graph wavelet transform is much more computationally efficient than graph Fourier transform. For example, in the Cora dataset, more than $9 7 \%$ elements in $\psi _ { s } ^ { - 1 }$ are zero while only less than $1 \%$ elements in $U ^ { \top }$ are zero (Table 4).
+
+3. Localized convolution: each wavelet corresponds to a signal on graph diffused away from a centered node, highly localized in vertex domain. As a result, the graph convolution defined in Equation (4) is localized in vertex domain. We show the localization property of graph convolution in Appendix A. It is the localization property that explains why graph wavelet transform outperforms Fourier transform in defining graph convolution and the associated tasks like graph-based semisupervised learning.
+
+![](images/3babc8cc3ed3a06ed78d5a3fc82cb836ef0d897c86a6206ca71e5d2283c3d072.jpg)  
+Figure 1: Wavelets on an example graph at (a) small scale and (b) large scale.
+
+4. Flexible neighborhood: graph wavelets are more flexible to adjust node’s neighborhoods. Different from previous methods which constrain neighborhoods by the discrete shortest path distance, our method leverages a continuous manner, i.e., varying the scaling parameter $s$ . A small value of $s$ generally corresponds to a smaller neighborhood. Figure 1 shows two wavelet bases at different scale on an example network, depicted using GSP toolbox (Perraudin et al., 2014).
+
+# 2.4 GRAPH WAVELET NEURAL NETWORK
+
+Replacing Fourier transform with wavelet transform, graph wavelet neural network (GWNN) is a multi-layer convolutional neural network. The structure of the $m$ -th layer is
+
+$$
+{ \pmb X } _ { [ : , j ] } ^ { m + 1 } = h ( \psi _ { s } \sum _ { i = 1 } ^ { p } { \pmb F } _ { i , j } ^ { m } \psi _ { s } ^ { - 1 } { \pmb X } _ { [ : , i ] } ^ { m } ) \qquad j = 1 , \cdots , q ,
+$$
+
+where $\psi _ { s }$ is wavelet bases, $\psi _ { s } ^ { - 1 }$ is the graph wavelet transform matrix at scale $s$ which projects signal in vertex domain into spectral domain, $X _ { [ : , i ] } ^ { m }$ with dimensions $n \times 1$ is the $i$ -th column of ${ \pmb X } ^ { m }$ , ${ \bf \it F } _ { i , j } ^ { m }$ is a diagonal filter matrix learned in spectral domain, and $h$ is a non-linear activation function. This layer transforms an input tensor ${ \pmb X } ^ { m }$ with dimensions $n \times p$ into an output tensor $X ^ { m + 1 }$ with dimensions $n \times q$ .
+
+In this paper, we consider a two-layer GWNN for semi-supervised node classification on graph. The formulation of our model is
+
+$$
+\mathrm { f i r s t ~ l a y e r : ~ } X _ { [ : , j ] } ^ { 2 } = \mathrm { R e L U } ( \psi _ { s } \sum _ { i = 1 } ^ { p } F _ { i , j } ^ { 1 } \psi _ { s } ^ { - 1 } X _ { [ : , i ] } ^ { 1 } ) \qquad j = 1 , \cdots , q ,
+$$
+
+$$
+\mathrm { s e c o n d l a y e r : ~ } Z _ { j } = \mathrm { s o f t m a x } ( \psi _ { s } \sum _ { i = 1 } ^ { q } F _ { i , j } ^ { 2 } \psi _ { s } ^ { - 1 } X _ { [ : , \ : , i ] } ^ { 2 } ) \qquad j = 1 , \cdots , c ,
+$$
+
+where $c$ is the number of classes in node classification, $z$ of dimensions $n \times c$ is the prediction result. The loss function is the cross-entropy error over all labeled examples:
+
+$$
+\boldsymbol { L o s s } = - \sum _ { l \in y _ { L } } \sum _ { i = 1 } ^ { c } Y _ { l i } \mathrm { l n } { \boldsymbol { Z } _ { l i } } ,
+$$
+
+where $y _ { L }$ is the labeled node set, $Y _ { l i } = 1$ if the label of node $l$ is $i$ , and ${ Y _ { l i } } = 0$ otherwise. The weights $\pmb { F }$ are trained using gradient descent.
+
+# 2.5 REDUCING PARAMETER COMPLEXITY
+
+In Equation (5), the parameter complexity of each layer is $O ( n \times p \times q )$ , where $n$ is the number of nodes, $p$ is the number of features of each vertex in current layer, and $q$ is the number of features of each vertex in next layer. Conventional CNN methods learn convolution kernel for each pair of input feature and output feature. This results in a huge number of parameters and generally requires huge training data for parameter learning. This is prohibited for graph-based semi-supervised learning. To combat this issue, we detach the feature transformation from graph convolution. Each layer in GWNN is divided into two components: feature transformation and graph convolution. Spectially, we have
+
+$$
+\begin{array} { c } { { \mathrm { f e a t u r e ~ t r a n s f o r m a t i o n : } ~ { \cal X } ^ { m ^ { \prime } } = { \cal X } ^ { m } { \cal W } , } } \\ { { \mathrm { g r a p h ~ c o n v o l u t i o n : } ~ { \cal X } ^ { m + 1 } = h ( \psi _ { s } { \cal F } ^ { m } \psi _ { s } ^ { - 1 } { \cal X } ^ { m ^ { \prime } } ) . } } \end{array}
+$$
+
+where $W \in \mathbb { R } ^ { p \times q }$ is the parameter matrix for feature transformation, $X ^ { m ^ { \prime } }$ with dimensions $n \times q$ is the feature matrix after feature transformation, ${ \pmb F } ^ { m }$ is the diagonal matrix for graph convolution kernel, and $h$ is a non-linear activation function.
+
+After detaching feature transformation from graph convolution, the parameter complexity is reduced from $O ( n \times p \times q )$ to $O ( n + p \times q )$ . The reduction of parameters is particularly valuable fro graphbased semi-supervised learning where labels are quite limited.
+
+# 3 RELATED WORKS
+
+Graph convolutional neural networks on graphs. The success of CNNs when dealing with images, videos, and speeches motivates researchers to design graph convolutional neural network on graphs. The key of generalizing CNNs to graphs is defining convolution operator on graphs. Existing methods are classified into two categories, i.e., spectral methods and spatial methods.
+
+Spectral methods define convolution via convolution theorem. Spectral CNN (Bruna et al., 2014) is the first attempt at implementing CNNs on graphs, leveraging graph Fourier transform and defining convolution kernel in spectral domain. Boscaini et al. (2015) developed a local spectral CNN approach based on the graph Windowed Fourier Transform. Defferrard et al. (2016) introduced a Chebyshev polynomial parametrization for spectral filter, offering us a fast localized spectral filtering method. Kipf & Welling (2017) provided a simplified version of ChebyNet, gaining success in graph-based semi-supervised learning task. Khasanova & Frossard (2017) represented images as signals on graph and learned their transformation invariant representations. They used Chebyshev approximations to implement graph convolution, avoiding matrix eigendecomposition. Levie et al. (2017) used rational functions instead of polynomials and created anisotropic spectral filters on manifolds.
+
+Spatial methods define convolution as a weighted average function over neighborhood of target vertex. GraphSAGE takes one-hop neighbors as neighborhoods and defines the weighting function as various aggregators over neighborhood (Hamilton et al., 2017). Graph attention network (GAT) proposes to learn the weighting function via self-attention mechanism (Velickovic et al., 2017). MoNet offers us a general framework for design spatial methods, taking convolution as the weighted average of multiple weighting functions defined over neighborhood (Monti et al., 2017). Some works devote to making graph convolutional networks more powerful. Monti et al. (2018) alternated convolutions on vertices and edges, generalizing GAT and leading to better performance. GraphsGAN (Ding et al., 2018) generalizes GANs to graph, and generates fake samples in low-density areas between subgraphs to improve the performance on graph-based semi-supervised learning.
+
+Graph wavelets. Sweldens (1998) presented a lifting scheme, a simple construction of wavelets that can be adapted to graphs without learning process. Hammond et al. (2011) proposed a method to construct wavelet transform on graphs. Moreover, they designed an efficient way to bypass the eigendecomposition of the Laplacian and approximated wavelets with Chebyshev polynomials. Tremblay & Borgnat (2014) leveraged graph wavelets for multi-scale community mining by modulating a scaling parameter. Owing to the property of describing information diffusion, Donnat et al. (2018) learned structural node embeddings via wavelets. All these works prove that graph wavelets are not only local and sparse but also valuable for signal processiong on graph.
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS
+
+To evaluate the proposed GWNN, we apply GWNN on semi-supervised node classification, and conduct experiments on three benchmark datasets, namely, Cora, Citeseer and Pubmed (Sen et al., 2008). In the three citation network datasets, nodes represent documents and edges are citation links. Details of these datasets are demonstrated in Table 1. Here, the label rate denotes the proportion of labeled nodes used for training. Following the experimental setup of GCN (Kipf & Welling, 2017), we fetch 20 labeled nodes per class in each dataset to train the model.
+
+Table 1: The Statistics of Datasets   
+
+<table><tr><td>Dataset</td><td>Nodes</td><td>Edges</td><td>Classes</td><td>Features</td><td>Label Rate</td></tr><tr><td>Cora</td><td>2,708</td><td>5,429</td><td>7</td><td>1,433</td><td>0.052</td></tr><tr><td>Citeseer</td><td>3,327</td><td>4,732</td><td>6</td><td>3,703</td><td>0.036</td></tr><tr><td>Pubmed</td><td>19,717</td><td>44,338</td><td>3</td><td>500</td><td>0.003</td></tr></table>
+
+# 4.2 BASELINES
+
+We compare with several traditional semi-supervised learning methods, including label propagation (LP) (Zhu et al., 2003), semi-supervised embedding (SemiEmb) (Weston et al., 2012), manifold regularization (ManiReg) (Belkin et al., 2006), graph embeddings (DeepWalk) (Perozzi et al., 2014), iterative classification algorithm (ICA) (Lu & Getoor, 2003) and Planetoid (Yang et al., 2016).
+
+Furthermore, along with the development of deep learning on graph, graph convolutional networks are proved to be effective in semi-supervised learning. Since our method is a spectral method based on convolution theorem, we compare it with the Spectral CNN (Bruna et al., 2014). ChebyNet (Defferrard et al., 2016) and GCN (Kipf & Welling, 2017), two variants of the Spectral CNN, are also included as our baselines. Considering spatial methods, we take MoNet (Monti et al., 2017) as our baseline, which also depends on Laplacian matrix.
+
+# 4.3 EXPERIMENTAL SETTINGS
+
+We train a two-layer graph wavelet neural network with 16 hidden units, and prediction accuracy is evaluated on a test set of 1000 labeled samples. The partition of datasets is the same as GCN (Kipf & Welling, 2017) with an additional validation set of 500 labeled samples to determine hyper-parameters.
+
+Weights are initialized following Glorot & Bengio (2010). We adopt the Adam optimizer (Kingma & Ba, 2014) for parameter optimization with an initial learning rate $l r = 0 . 0 1$ . For computational efficiency, we set the elements of $\psi _ { s }$ and $\psi _ { s } ^ { - 1 }$ smaller than a threshold $t$ to 0. We find the optimal hyper-parameters $s$ and $t$ through grid search, and the detailed discussion about the two hyperparameters is introduced in Appendix B. For Cora, $s = 1 . 0$ and $t = 1 e - 4$ . For Citeseer, $s = 0 . 7$ and $t = 1 e - 5$ . For Pubmed, $s = 0 . 5$ and $t = 1 e - 7$ . To avoid overfitting, dropout (Srivastava et al., 2014) is applied. Meanwhile, we terminate the training if the validation loss does not decrease for 100 consecutive epochs.
+
+# 4.4 ANALYSIS ON DETACHING FEATURE TRANSFORMATION FROM CONVOLUTION
+
+Since the number of parameters for the undetached version of GWNN is $O ( n \times p \times q )$ , we can hardly implement this version in the case of networks with a large number $n$ of nodes and a huge number $p$ of input features. Here, we validate the effectiveness of detaching feature transformation form convolution on ChebyNet (introduced in Section 2.2), whose parameter complexity is $O ( K \times$ $p \times q \rangle$ . For ChebyNet of detaching feature transformation from graph convolution, the number of parameters is reduced to $O ( K + p \times q )$ . Table 2 shows the performance and the number of parameters on three datasets. Here, the reported performance is the optimal performance varying the order $K = 2 , 3 , 4$ .
+
+Table 2: Results of Detaching Feature Transformation from Convolution   
+
+<table><tr><td></td><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td rowspan="2">Prediction Accuracy</td><td>ChebyNet</td><td>81.2%</td><td>69.8%</td><td>74.4%</td></tr><tr><td>Detaching-ChebyNet</td><td>81.6%</td><td>68.5%</td><td>78.6%</td></tr><tr><td rowspan="2">Number of Parameters</td><td>ChebyNet</td><td>46.080 (K=2)</td><td>178,032 (K=3)</td><td>24,144 (K=3)</td></tr><tr><td>Detaching-ChebyNet</td><td>23,048 (K=4)</td><td>59,348 (K=2)</td><td>8,054 (K=3)</td></tr></table>
+
+As demonstrated in Table 2, with fewer parameters, we improve the accuracy on Pubmed by a large margin. This is due to that the label rate of Pubmed is only 0.003. By detaching feature transformation from convolution, the parameter complexity is significantly reduced, alleviating overfitting in semi-supervised learning and thus remarkably improving prediction accuracy. On Citeseer, there is a little drop on the accuracy. One possible explanation is that reducing the number of parameters may restrict the modeling capacity to some degree.
+
+# 4.5 PERFORMANCE OF GWNN
+
+We now validate the effectiveness of GWNN with detaching technique on node classification. Experimental results are reported in Table 3. GWNN improves the classification accuracy on all the three datasets. In particular, replacing Fourier transform with wavelet transform, the proposed GWNN is comfortably ahead of Spectral CNN, achieving $1 0 \%$ improvement on Cora and Citeseer, and $5 \%$ improvement on Pubmed. The large improvement could be explained from two perspectives: (1) Convolution in Spectral CNN is non-local in vertex domain, and thus the range of feature diffusion is not restricted to neighboring nodes; (2) The scaling parameter $s$ of wavelet transform is flexible to adjust the diffusion range to suit different applications and different networks. GWNN consistently outperforms ChebyNet, since it has enough degree of freedom to learn the convolution kernel, while ChebyNet is a kind of approximation with limited degree of freedom. Furthermore, our GWNN also performs better than GCN and MoNet, reflecting that it is promising to design appropriate bases for spectral methods to achieve good performance.
+
+Table 3: Results of Node Classification   
+
+<table><tr><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td>MLP</td><td>55.1%</td><td>46.5%</td><td>71.4%</td></tr><tr><td>ManiReg</td><td>59.5%</td><td>60.1%</td><td>70.7%</td></tr><tr><td>SemiEmb</td><td>59.0%</td><td>59.6%</td><td>71.7%</td></tr><tr><td>LP</td><td>68.0%</td><td>45.3%</td><td>63.0%</td></tr><tr><td>DeepWalk</td><td>67.2%</td><td>43.2%</td><td>65.3%</td></tr><tr><td>ICA</td><td>75.1%</td><td>69.1%</td><td>73.9%</td></tr><tr><td>Planetoid</td><td>75.7%</td><td>64.7%</td><td>77.2%</td></tr><tr><td>Spectral CNN</td><td>73.3%</td><td>58.9%</td><td>73.9%</td></tr><tr><td>ChebyNet</td><td>81.2%</td><td>69.8%</td><td>74.4%</td></tr><tr><td>GCN</td><td>81.5%</td><td>70.3%</td><td>79.0%</td></tr><tr><td>MoNet</td><td>81.7±0.5%</td><td></td><td>78.8±0.3%</td></tr><tr><td>GWNN</td><td>82.8%</td><td>71.7%</td><td>79.1%</td></tr></table>
+
+# 4.6 ANALYSIS ON SPARSITY
+
+Besides the improvement on prediction accuracy, wavelet transform with localized and sparse transform matrix holds sparsity in both spatial domain and spectral domain. Here, we take Cora as an example to illustrate the sparsity of graph wavelet transform.
+
+The sparsity of transform matrix. There are 2,708 nodes in Cora. Thus, the wavelet transform matrix $\psi _ { s } ^ { - 1 }$ and the Fourier transform matrix $U ^ { \top }$ both belong to $\mathbb { R } ^ { 2 , 7 0 8 \times 2 , 7 0 8 }$ . The first two rows in Table 4 demonstrate that $\psi _ { s } ^ { - 1 }$ is much sparser than $U ^ { \top }$ . Sparse wavelets not only accelerate the computation, but also well capture the neighboring topology centered at each node.
+
+The sparsity of projected signal. As mentioned above, each node in Cora represents a document and has a sparse bag-of-words feature. The input feature $\ b { X } \in \mathbb { R } ^ { n \times p }$ is a binary matrix, and $X _ { [ i , j ] } =$ 1 when the $i$ -th document contains the $j$ -th word in the bag of words, it equals 0 otherwise. Here, $X _ { [ : , j ] }$ denotes the $j$ -th column of $\boldsymbol { X }$ , and each column represents the feature vector of a word. Considering a specific signal $X _ { [ : , 9 8 4 ] }$ , we project the spatial signal into spectral domain, and get its projected vector. Here, $p = \bar { \psi _ { s } ^ { - 1 } } X _ { [ : , 9 8 4 ] }$ denotes the projected vector via wavelet transform, $\pmb { q } = \pmb { U } ^ { \top } \pmb { X } _ { [ : , 9 8 4 ] }$ denotes the projected vector via Fourier transform, and $\pmb { p } , \pmb { q } \in \mathbb { R } ^ { 2 , 7 0 8 }$ . The last row in Table 4 lists the numbers of non-zero elements in $\pmb { p }$ and $\pmb q$ . As shown in Table 4, with wavelet transform, the projected signal is much sparser.
+
+Table 4: Statistics of wavelet transform and Fourier transform on Cora   
+
+<table><tr><td></td><td>Statistical Property</td><td>wavelettransform</td><td>Fouriertransform</td></tr><tr><td rowspan="2">Transform Matrix</td><td>Density</td><td>2.8%</td><td>99.1%</td></tr><tr><td>Number of Non-zero Elements</td><td>205,774</td><td>7,274,383</td></tr><tr><td rowspan="2">Projected Signal</td><td>Density</td><td>10.9%</td><td>100%</td></tr><tr><td>Number of Non-zero Elements</td><td>297</td><td>2,708</td></tr></table>
+
+# 4.7 ANALYSIS ON INTERPRETABILITY
+
+Compare with graph convolution network using Fourier transform, GWNN provides good interpretability. Here, we show the interpretability with specific examples in Cora.
+
+Each feature, i.e. word in the bag of words, has a projected vector, and each element in this vector is associated with a spectral wavelet basis. Here, each basis is centered at a node, corresponding to a document. The value can be regarded as the relation between the word and the document. Thus, each value in $\pmb { p }$ can be interpreted as the relation between $W o r d _ { 9 8 4 }$ and a document. In order to elaborate the interpretability of wavelet transform, we analyze the projected values of different feature as following.
+
+Considering two features $W o r d _ { 9 8 4 }$ and $W o r d _ { 1 1 7 7 }$ , we select the top-10 active bases, which have the 10 largest projected values of each feature. As illustrated in Figure 2, for clarity, we magnify the local structure of corresponding nodes and marked them with bold rims. The central network in each subgraph denotes the dataset Cora, each node represents a document, and 7 different colors represent 7 classes. These nodes are clustered by OpenOrd (Martin et al., 2011) based on the adjacency matrix.
+
+Figure 2a shows the top-10 active bases of $W o r d _ { 9 8 4 }$ . In Cora, this word only appears 8 times, and all the documents containing $W o r d _ { 9 8 4 }$ belong to the class “ Case-Based ”. Consistently, all top-10 nodes activated by $W o r d _ { 9 8 4 }$ are concentrated and belong to the class “ Case-Based ”. And, the frequencies of $W o r d _ { 1 1 7 7 }$ appearing in different classes are similar, indicating that $W o r d _ { 1 1 7 7 }$ is a universal word. In concordance with our expectation, the top-10 active bases of $W o r d _ { 1 1 7 7 }$ are discrete and belong to different classes in Figure 2b.
+
+![](images/4ea6f31973347c969205987dfaf594ad41a7761eb7d83787038298d9e7dd7f3d.jpg)  
+Figure 2: Top-10 active bases of two words in Cora. The central network of each subgraph represents the dataset Cora, which is split into 7 classes. Each node represents a document, and its color indicates its label. The nodes that represent the top-10 active bases are marked with bold rims. (a) $W o r d _ { 9 8 4 }$ only appears in documents of the class “ Case-Based ” in Cora. Consistently, all its 10 active bases also belong to the class “ Case-Based ”. (b) The frequencies of $W o r d _ { 1 1 7 7 }$ appearing in different classes are similar in Cora. As expected, the top-10 active bases of $W o r d _ { 1 1 7 7 }$ also belong to different classes.
+
+Owing to the properties of graph wavelets, which describe the neighboring topology centered at each node, the projected values of wavelet transform can be explained as the correlation between features and nodes. These properties provide an interpretable domain transformation and ease the understanding of graph convolution.
+
+# 5 CONCLUSION
+
+Replacing graph Fourier transform with graph wavelet transform, we proposed GWNN. Graph wavelet transform has three desirable properties: (1) Graph wavelets are local and sparse; (2) Graph wavelet transform is computationally efficient; (3) Convolution is localized in vertex domain. These advantages make the whole learning process interpretable and efficient. Moreover, to reduce the number of parameters and the dependence on huge training data, we detached the feature transformation from convolution. This practice makes GWNN applicable to large graphs, with remarkable performance improvement on graph-based semi-supervised learning.
+
+# 6 ACKNOWLEDGEMENTS
+
+This work is funded by the National Natural Science Foundation of China under grant numbers 61425016, 61433014, and 91746301. Huawei Shen is also funded by K.C. Wong Education Foundation and the Youth Innovation Promotion Association of the Chinese Academy of Sciences.
+
+# REFERENCES
+
+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.
+
+Davide Boscaini, Jonathan Masci, Simone Melzi, Michael M Bronstein, Umberto Castellani, and Pierre Vandergheynst. Learning class-specific descriptors for deformable shapes using localized spectral convolutional networks. In Computer Graphics Forum, volume 34, pp. 13–23. Wiley Online Library, 2015.
+
+Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann Lecun. Spectral networks and locally connected networks on graphs. In International Conference on Learning Representations (ICLR2014), CBLS, April 2014, 2014.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks ¨ on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3844–3852, 2016.
+
+Ming Ding, Jie Tang, and Jie Zhang. Semi-supervised learning on graphs with generative adversarial nets. In Proceedings of the 27th ACM International Conference on Information and Knowledge Management, pp. 913–922. ACM, 2018.
+
+Claire Donnat, Marinka Zitnik, David Hallac, and Jure Leskovec. Learning structural node embeddings via diffusion wavelets. 2018.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 249–256, 2010.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1024–1034, 2017.
+
+David K Hammond, Pierre Vandergheynst, and Remi Gribonval. Wavelets on graphs via spectral ´ graph theory. Applied and Computational Harmonic Analysis, 30(2):129–150, 2011.
+
+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.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal processing magazine, 29(6):82–97, 2012.
+
+Renata Khasanova and Pascal Frossard. Graph-based isometry invariant representation learning. In International Conference on Machine Learning, pp. 1847–1856, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Ron Levie, Federico Monti, Xavier Bresson, and Michael M Bronstein. Cayleynets: Graph convolutional neural networks with complex rational spectral filters. arXiv preprint arXiv:1705.07664, 2017.
+
+Qing Lu and Lise Getoor. Link-based classification. In Proceedings of the 20th International Conference on Machine Learning (ICML-03), pp. 496–503, 2003.
+
+Shawn Martin, W Michael Brown, Richard Klavans, and Kevin W Boyack. Openord: an opensource toolbox for large graph layout. In Visualization and Data Analysis 2011, volume 7868, pp. 786806. International Society for Optics and Photonics, 2011.
+
+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. In Proc. CVPR, volume 1, pp. 3, 2017.
+
+Federico Monti, Oleksandr Shchur, Aleksandar Bojchevski, Or Litany, Stephan Gunnemann, ¨ and Michael M Bronstein. Dual-primal graph convolutional networks. arXiv preprint arXiv:1806.00770, 2018.
+
+Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014.
+
+Nathanael Perraudin, Johan Paratte, David Shuman, Lionel Martin, Vassilis Kalofolias, Pierre Van-¨ dergheynst, and David K Hammond. Gspbox: A toolbox for signal processing on graphs. arXiv preprint arXiv:1408.5781, 2014.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93, 2008.
+
+David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. IEEE Signal Processing Magazine, 30(3):83–98, 2013.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Wim Sweldens. The lifting scheme: A construction of second generation wavelets. SIAM journal on mathematical analysis, 29(2):511–546, 1998.
+
+Nicolas Tremblay and Pierre Borgnat. Graph wavelets for multiscale community mining. IEEE Transactions on Signal Processing, 62(20):5227–5239, 2014.
+
+Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 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.
+
+Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In International Conference on Machine Learning, pp. 40–48, 2016.
+
+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.
+
+We use a diagonal matrix $\Theta$ to represent the learned kernel transformed by wavelets $\psi _ { s } ^ { - 1 } \pmb { y }$ , and replace the Hadamard product with matrix muplication. Then Equation (4) is:
+
+$$
+\pmb { x } * _ { \mathcal { G } } \pmb { y } = \psi _ { s } \Theta \psi _ { s } ^ { - 1 } \pmb { x } .
+$$
+
+We set $\psi _ { s } = ( \psi _ { s 1 } , \psi _ { s 2 } , . . . , \psi _ { s n } )$ , $\psi _ { s } ^ { - 1 } = ( \psi _ { s 1 } ^ { * } , \psi _ { s 2 } ^ { * } , . . . , \psi _ { s n } ^ { * } )$ , and $\Theta = \mathrm { d i a g } ( \{ \theta _ { k } \} _ { k = 1 } ^ { n } )$ . Equation (11) becomes :
+
+$$
+\pmb { x } * _ { \mathscr { G } } \pmb { y } = \sum _ { k = 1 } ^ { n } \theta _ { k } \psi _ { s k } ( \psi _ { s k } ^ { * } ) ^ { \top } \pmb { x } .
+$$
+
+As proved by Hammond et al. (2011), both $\psi _ { s }$ and $\psi _ { s } ^ { - 1 }$ are local in small scale (s). Figure 3 shows the locality of $\psi _ { s 1 }$ and $\psi _ { s 1 } ^ { * }$ , i.e., the first column in $\psi _ { s }$ and $\psi _ { s } ^ { - 1 }$ when $s = 3$ . Each column in $\psi _ { s }$ and $\psi _ { s } ^ { - 1 }$ describes the neighboring topology of target node, which means that $\psi _ { s }$ and $\psi _ { s } ^ { - 1 }$ are local. The locality of $\psi _ { s k }$ and $\psi _ { s k } ^ { * }$ leads to the locality of the resulting matrix of multiplication between the column vector $\psi _ { s k }$ and row vector $( \psi _ { s k } ^ { * } ) ^ { \top }$ . For convenience, we set $M _ { k } = \psi _ { s k } ( \psi _ { s k } ^ { * } ) ^ { \top }$ , $M _ { k [ i , j ] } > 0$ only when $\psi _ { s k } [ i ] > 0$ and $( \psi _ { s k } ^ { * } ) ^ { \top } [ j ] > 0$ . In other words, if $M _ { k [ i , j ] } > 0$ , vertex $i$ and vertex $j$ can correlate with each other through vertex $k$ .
+
+![](images/3bace0dca654718860a873ae36fecfdf5825bb2d5b239f07e6fb3900d9126899.jpg)  
+Figure 3: Locality of (a) $\psi _ { s 1 }$ and (b) $\psi _ { s 1 } ^ { * }$ .
+
+Since each $M _ { k }$ is local, for any convolution kernel $\Theta$ , $\psi _ { s } \Theta \psi _ { s } ^ { - 1 }$ is local, and it means that convolution is localized in vertex domain. By replacing $\Theta$ with an identity matrix in Equation (12), we get $\begin{array} { r } { \pmb { x } * _ { \mathcal { G } } \pmb { y } = \sum _ { k = 1 } ^ { n } M _ { k } \pmb { x } } \end{array}$ . We define $\begin{array} { r } { \mathbf { \dot { H } } = \sum _ { k = 1 } ^ { n ^ { * } } M _ { k } } \end{array}$ , and Figure 4 shows $H _ { [ 1 , : ] }$ in different scaling, i.e., correlation between the first node and other nodes during convolution. The locality of $\pmb { H }$ suggests that graph convolution is localized in vertex domain. Moreover, as the scaling parameter $s$ becomes larger, the range of feature diffusion becomes larger.
+
+![](images/377dd1763f6ee42479178aa2c4bcb662df3cbd7f5dd463a3b122c3167e6d6b46.jpg)  
+Figure 4: Correlation between first node and other nodes at (a) small scale and (b) large scale. Nonzero value of node represents correlation between this node and target node during convolution. Locality of $\pmb { H }$ suggests that graph convolution is localized in vertex domain. Moreover, with scaling parameter $s$ becoming larger, the range of feature diffusion becomes larger.
+
+![](images/40fcbdd4a017ec82e8d7bce4e03011ac72b42888e765e88a447a7ae0220b410e.jpg)  
+Figure 5: Influence of $s$ and $t$ on Cora.
+
+GWNN leverages graph wavelets to implement graph convolution, where $s$ is used to modulate the range of neighborhoods. From Figure 5, as $s$ becomes larger starting from 0, the range of neighboring nodes becomes large, resulting the increase of accuracy on Cora. However when $s$ becomes too large, some irrelevant nodes are included, leading to decreasing of accuracy. The hyperparameter $t$ only used for computational efficiency, has any slight influence on its performance.
+
+For experiments on specific dataset, $s$ and $t$ are choosen via grid search using validation. Generally, a appropriate $s$ is in the range of [0.5, 1], which can not only capture the graph structure but also guarantee the locality of convolution, and $t$ is less insensive to dataset.
+
+# APPENDIX C PARAMETER COMPLEXITY OF NODE CLASSIFICATION
+
+We show the parameter complexity of node classification in Table 5. The high parameter complexity $O ( n * p * q )$ of Spectral CNN makes it difficult to generalize to real world networks. ChebyNet approximates the convolution kernel via polynomial function of the diagonal matrix of Laplacian eigenvalues, reducing parameter complexity to $O ( K * p * q )$ with $K$ being the order of polynomial function. GCN simplifies ChebyNet via setting $K { = } 1$ . We detach feature transformation from graph convolution to implement GWNN and Spectral CNN in our experiments, which can reduce parameter to $O ( n + p * q )$ .
+
+Table 5: Parameter complexity of Node Classification   
+
+<table><tr><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td>Spectral CNN</td><td>62,392,320</td><td>197,437,488</td><td>158,682,416</td></tr><tr><td>Spectral CNN (detaching)</td><td>28,456</td><td>65,379</td><td>47,482</td></tr><tr><td>ChebyNet</td><td>46,080 (K=2)</td><td>178,032 (K=3)</td><td>24,144 (K=3)</td></tr><tr><td>GCN</td><td>23,040</td><td>59,344</td><td>8.048</td></tr><tr><td>GWNN</td><td>28,456</td><td>65,379</td><td>47,482</td></tr></table>
+
+In Cora and Citeseer, with smaller parameter complexity, GWNN achieves better performance than ChebyNet, reflecting that it is promising to implement convolution via graph wavelet transform. As Pubmed has a large number of nodes, the parameter complexity of GWNN is larger than ChebyNet. As future work, it is an interesting attempt to select wavelets associated with a subset of nodes, further reducing parameter complexity with potential loss of performance.
+
+# APPENDIX D FAST GRAPH WAVELETS WITH CHEBYSHEV POLYNOMIAL APPROXIMATION
+
+Hammond et al. (2011) proposed a method, using Chebyshev polynomials to efficiently approximate $\psi _ { s }$ and $\psi _ { s } ^ { - 1 }$ . The computational complexity is $O ( m \times | \mathbb { E } | )$ , where $\lvert \mathbb { E } \rvert$ is the number of edges and $m$ is the order of Chebyshev polynomials. We give the details of the approximation proposed in Hammond et al. (2011).
+
+With the stable recurrence relation $T _ { k } ( y ) = 2 y T _ { k - 1 } ( y ) - T _ { k - 2 } ( y )$ , we can generate the Chebyshev polynomials $T _ { k } ( y )$ . Here $T _ { 0 } = 1$ and $T _ { 1 } = y$ . For $y$ sampled between $^ { - 1 }$ and 1, the trigonometric expression $T _ { k } ( y ) = c o s ( k a r c c o s ( y ) )$ is satisfied. It shows that $T _ { k } ( y ) \in [ - 1 , 1 ]$ when $y \in [ - 1 , 1 ]$ . Through the Chebyshev polynomials, an orthogonal basis for the Hilbert space of square integrable functions $L ^ { 2 } ( [ - 1 , 1 ] , \frac { d y } { \sqrt { 1 - y ^ { 2 } } } )$ is formed. For each $h$ in this Hilbert space, we have a uniformly convergent Chebyshev series $\begin{array} { r } { h ( y ) = \frac { 1 } { 2 } c _ { 0 } + \sum _ { k = 1 } ^ { \infty } c _ { k } T _ { k } ( y ) } \end{array}$ , and the Chebyshev coefficients $c _ { k } =$ $\begin{array} { r } { \frac { 2 } { \pi } \int _ { - 1 } ^ { 1 } \frac { T _ { k } ( y ) h ( y ) } { \sqrt { 1 - y ^ { 2 } } } d y = \frac { 2 } { \pi } \int _ { 0 } ^ { \pi } c o s ( k \theta ) h ( \bar { c o s } ( \theta ) ) d \theta } \end{array}$ . A fixed scale $s$ is assumed. To approximate $g ( s x )$ for $x \in [ 0 , \lambda _ { m a x } ]$ , we can shift the domain through the transformation $x = a ( y + 1 ) $ , where $a =$ $\frac { \lambda _ { m a x } } { 2 }$ $\begin{array} { r } { T _ { k } ^ { \prime } ( x ) = T _ { k } ( \frac { x - a } { a } ) } \end{array}$ e shif, and , $\frac { x - a } { a } \in [ - 1 , 1 ]$ . $\begin{array} { r } { g ( s x ) = \frac { 1 } { 2 } c _ { 0 } + \sum _ { k = 1 } ^ { \infty } c _ { k } T _ { k } ^ { \prime } ( x ) } \end{array}$ $x \in [ 0 , \lambda _ { m a x } ]$ $\begin{array} { r } { c _ { k } = \frac { 2 } { \pi } \int _ { 0 } ^ { \pi } c o s ( k \theta ) g ( s ( a ( c o s ( \theta ) + 1 ) ) ) d \theta } \end{array}$ we truncate the Chebyshev expansion to $m$ terms and achieve Polynomial approximation.
+
+sgive the fast approximation wavelets by Here we give the example of the $\psi _ { s } ^ { - 1 }$ and $\begin{array} { r } { \psi _ { s } ^ { - 1 } \pmb { f } ^ { \prime } = \frac { 1 } { 2 } c _ { 0 } \pmb { f } + \sum _ { k = 1 } ^ { m } c _ { k } \tilde { T _ { k } ^ { \prime } } ( \pmb { L } ) \pmb { f } } \end{array}$ $g ( s x ) = e ^ { - s x }$ , the graph signal is . The efficient compu- $\pmb { f } \in R ^ { n }$ . Then we can tation of $T _ { k } ^ { \prime } ( { \pmb { L } } )$ determines the utility of this approach, where $\begin{array} { r } { T _ { k } ^ { \prime } ( L ) \dag = \frac { 2 } { a } ( L - \pmb { I } ) ( T _ { k - 1 } ^ { \prime } ( L ) \pmb { f } ) - } \end{array}$ $T _ { k - 2 } ^ { \prime } ( { \pmb { L } } ) f$ .
+
+# APPENDIX E ANALYSIS ON SPASITY OF SPECTRAL TRANSFORM AND LAPLACIAN MATRIX
+
+The sparsity of the graph wavelets depends on the sparsity of the Laplacian matrix and the hyperparameter $s$ , We show the sparsity of spectral transform matrix and Laplacian matrix in Table 6.
+
+Table 6: Statistics of spectral transform and Laplacian matrix on Cora   
+
+<table><tr><td></td><td>Density</td><td>NumofNon-zeroElements</td></tr><tr><td>wavelettransform</td><td>2.8%</td><td>205,774</td></tr><tr><td>Fouriertransform</td><td>99.1%</td><td>7,274,383</td></tr><tr><td>Laplacian matrix</td><td>0.15%</td><td>10,858</td></tr></table>
+
+The sparsity of Laplacian matrix is sparser than graph wavelets, and this property limits our method, i.e., the higher time complexity than some methods depending on Laplacian matrix and identity matrix, e.g., GCN. Specifically, both our method and GCN aim to improve Spectral CNN via designing localized graph convolution. GCN, as a simplified version of ChebyNet, leverages Laplacian matrix as weighted matrix and expresses the spectral graph convolution in spatial domain, acting as spatial-like method (Monti et al., 2017). However, our method resorts to using graph wavelets as a new set of bases, directly designing localized spectral graph convolution. GWNN offers a localized graph convolution via replacing graph Fourier transform with graph wavelet transform, finding good spectral basis with localization property and good interpretability. This distinguishes GWNN from ChebyNet and GCN, which express the graph convolution defined via graph Fourier transform in vertex domain.

parse/train/H1ewdiR5tQ/H1ewdiR5tQ_content_list.json

@@ -0,0 +1,1671 @@
+[
+    {
+        "type": "text",
+        "text": "GRAPH WAVELET NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            617,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bingbing $\\mathbf { X } \\mathbf { u } ^ { 1 , 2 }$ , Huawei Shen1,2, Qi $\\mathbf { C a o } ^ { 1 , 2 }$ , Yunqi $\\mathbf { Q i u } ^ { 1 , 2 }$ & Xueqi Cheng1,2 ",
+        "bbox": [
+            183,
+            143,
+            700,
+            160
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1CAS Key Laboratory of Network Data Science and Technology,   \nInstitute of Computing Technology, Chinese Academy of Sciences;   \n2School of Computer and Control Engineering,   \nUniversity of Chinese Academy of Sciences   \nBeijing, China   \n{xubingbing,shenhuawei,caoqi,qiuyunqi,cxq}@ict.ac.cn ",
+        "bbox": [
+            184,
+            161,
+            692,
+            244
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            280,
+            544,
+            296
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present graph wavelet neural network (GWNN), a novel graph convolutional neural network (CNN), leveraging graph wavelet transform to address the shortcomings of previous spectral graph CNN methods that depend on graph Fourier transform. Different from graph Fourier transform, graph wavelet transform can be obtained via a fast algorithm without requiring matrix eigendecomposition with high computational cost. Moreover, graph wavelets are sparse and localized in vertex domain, offering high efficiency and good interpretability for graph convolution. The proposed GWNN significantly outperforms previous spectral graph CNNs in the task of graph-based semi-supervised classification on three benchmark datasets: Cora, Citeseer and Pubmed. ",
+        "bbox": [
+            233,
+            318,
+            764,
+            457
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            497,
+            336,
+            513
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional neural networks (CNNs) (LeCun et al., 1998) have been successfully used in many machine learning problems, such as image classification (He et al., 2016) and speech recognition (Hinton et al., 2012), where there is an underlying Euclidean structure. The success of CNNs lies in their ability to leverage the statistical properties of Euclidean data, e.g., translation invariance. However, in many research areas, data are naturally located in a non-Euclidean space, with graph or network being one typical case. The non-Euclidean nature of graph is the main obstacle or challenge when we attempt to generalize CNNs to graph. For example, convolution is not well defined in graph, due to that the size of neighborhood for each node varies dramatically (Bronstein et al., 2017). ",
+        "bbox": [
+            174,
+            534,
+            825,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Existing methods attempting to generalize CNNs to graph data fall into two categories, spatial methods and spectral methods, according to the way that convolution is defined. Spatial methods define convolution directly on the vertex domain, following the practice of the conventional CNN. For each vertex, convolution is defined as a weighted average function over all vertices located in its neighborhood, with the weighting function characterizing the influence exerting to the target vertex by its neighbors (Monti et al., 2017). The main challenge is to define a convolution operator that can handle neighborhood with different sizes and maintain the weight sharing property of CNN. Although spatial methods gain some initial success and offer us a flexible framework to generalize CNNs to graph, it is still elusive to determine appropriate neighborhood. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Spectral methods define convolution via graph Fourier transform and convolution theorem. Spectral methods leverage graph Fourier transform to convert signals defined in vertex domain into spectral domain, e.g., the space spanned by the eigenvectors of the graph Laplacian matrix, and then filter is defined in spectral domain, maintaining the weight sharing property of CNN. As the pioneering work of spectral methods, spectral CNN (Bruna et al., 2014) exploited graph data with the graph Fourier transform to implement convolution operator using convolution theorem. Some subsequent works make spectral methods spectrum-free (Defferrard et al., 2016; Kipf & Welling, 2017; Khasanova & Frossard, 2017), achieving locality in spatial domain and avoiding high computational cost of the eigendecomposition of Laplacian matrix. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present graph wavelet neural network to implement efficient convolution on graph data. We take graph wavelets instead of the eigenvectors of graph Laplacian as a set of bases, and define the convolution operator via wavelet transform and convolution theorem. Graph wavelet neural network distinguishes itself from spectral CNN by its three desirable properties: (1) Graph wavelets can be obtained via a fast algorithm without requiring the eigendecomposition of Laplacian matrix, and thus is efficient; (2) Graph wavelets are sparse, while eigenvectors of Laplacian matrix are dense. As a result, graph wavelet transform is much more efficient than graph Fourier transform; (3) Graph wavelets are localized in vertex domain, reflecting the information diffusion centered at each node (Tremblay & Borgnat, 2014). This property eases the understanding of graph convolution defined by graph wavelets. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We develop an efficient implementation of the proposed graph wavelet neural network. Convolution in conventional CNN learns an individual convolution kernel for each pair of input feature and output feature, causing a huge number of parameters especially when the number of features is high. We detach the feature transformation from convolution and learn a sole convolution kernel among all features, substantially reducing the number of parameters. Finally, we validate the effectiveness of the proposed graph wavelet neural network by applying it to graph-based semi-supervised classification. Experimental results demonstrate that our method consistently outperforms previous spectral CNNs on three benchmark datasets, i.e., Cora, Citeseer, and Pubmed. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 OUR METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            383,
+            321,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 PRELIMINARY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            416,
+            313,
+            431
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { G } = \\{ \\mathbb { V } , \\mathbb { E } , A \\}$ be an undirected graph, where $\\mathbb { V }$ is the set of nodes with $| \\mathbb { V } | = n$ , $\\mathbb { E }$ is the set of edges, and $\\pmb { A }$ is adjacency matrix with $A _ { i , j } = A _ { j , i }$ to define the connection between node $i$ and node $j$ . The graph Laplacian matrix $\\mathcal { L }$ is defined as $\\overset { \\vartriangle } { \\boldsymbol { \\mathcal { L } } } = \\boldsymbol { D } - \\boldsymbol { A }$ where $_ { D }$ is a diagonal degree matrix with $\\textstyle D _ { i , i } = \\sum _ { j } A _ { i , j }$ , and the normalized Laplacian matrix is ${ \\cal L } = I _ { n } - { \\cal D } ^ { - 1 / 2 } \\bar { \\cal A } { \\cal D } ^ { - 1 / 2 }$ where ${ { I } _ { n } }$ is the identity matrix. Since $\\pmb { L }$ is a real symmetric matrix, it has a complete set of orthonormal eigenvectors $U = \\left( \\ b { u } _ { 1 } , \\ b { u } _ { 2 } , . . . , \\ b { u } _ { n } \\right)$ , known as Laplacian eigenvectors. These eigenvectors have associated real, non-negative eigenvalues $\\{ \\lambda _ { l } \\} _ { l = 1 } ^ { n }$ , identified as the frequencies of graph. Eigenvectors associated with smaller eigenvalues carry slow varying signals, indicating that connected nodes share similar values. In contrast, eigenvectors associated with larger eigenvalues carry faster varying signals across connected nodes. ",
+        "bbox": [
+            173,
+            443,
+            825,
+            585
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 GRAPH FOURIER TRANSFORM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            604,
+            423,
+            619
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Taking the eigenvectors of normalized Laplacian matrix as a set of bases, graph Fourier transform of a signal $\\pmb { x } \\in R ^ { n }$ on graph $\\mathcal { G }$ is defined as $\\hat { \\pmb x } = \\pmb U ^ { \\top } \\pmb x$ , and the inverse graph Fourier transform is $\\mathbf { \\pmb { x } } = \\pmb { U } \\hat { \\mathbf { x } }$ (Shuman et al., 2013). Graph Fourier transform, according to convolution theorem, offers us a way to define the graph convolution operator, denoted as $^ { \\ast _ { \\mathcal { G } } }$ . Denoting with $\\textbf {  { y } }$ the convolution kernel, $^ { \\ast _ { \\mathcal { G } } }$ is defined as ",
+        "bbox": [
+            173,
+            631,
+            823,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/792d44ff25be5f0ba03e2804988f586d1c384a358bb3250bd2d0a52e8b0f5f33.jpg",
+        "text": "$$\n\\pmb { x } \\ast _ { \\mathscr { G } } \\pmb { y } = \\pmb { U } \\big ( ( \\pmb { U } ^ { \\top } \\pmb { y } ) \\odot ( \\pmb { U } ^ { \\top } \\pmb { x } ) \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            703,
+            609,
+            723
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ is the element-wise Hadamard product. Replacing the vector $\\pmb { U } ^ { \\top } \\pmb { y }$ by a diagonal matrix $g _ { \\theta }$ , then Hadamard product can be written in the form of matrix multiplication. Filtering the signal $x$ by the filter $g _ { \\theta }$ , we can write Equation (1) as $U g _ { \\theta } \\pmb { U } ^ { \\top } \\pmb { x }$ . ",
+        "bbox": [
+            174,
+            729,
+            825,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, there are some limitations when using Fourier transform to implement graph convolution: (1) Eigendecomposition of Laplacian matrix to obtain Fourier basis $U$ is of high computational cost with $\\bar { O } ( n ^ { 3 } )$ ; (2) Graph Fourier transform is inefficient, since it involves the multiplication between a dense matrix $U$ and the signal $_ { \\textbf { \\em x } }$ ; (3) Graph convolution defined through Fourier transform is not localized in vertex domain, i.e., the influence to the signal on one node is not localized in its neighborhood. To address these limitations, ChebyNet (Defferrard et al., 2016) restricts convolution kernel $g _ { \\theta }$ to a polynomial expansion ",
+        "bbox": [
+            173,
+            779,
+            825,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/56153eebc08218a1387d07d8512ad64584f87392911bf9218394fd6d413643bf.jpg",
+        "text": "$$\ng _ { \\theta } = \\sum _ { k = 0 } ^ { K - 1 } \\theta _ { k } \\Lambda ^ { k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            878,
+            553,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $K$ is a hyper-parameter to determine the range of node neighborhoods via the shortest path distance, $\\theta \\in \\bar { R } ^ { \\bar { K } }$ is a vector of polynomial coefficients, and $\\Lambda = \\mathrm { d i a g } \\big ( \\{ \\lambda _ { l } \\} _ { l = 1 } ^ { n } \\big )$ . However, such a polynomial approximation limits the flexibility to define appropriate convolution on graph, i.e., with a smaller $K$ , it’s hard to approximate the diagonal matrix $g _ { \\boldsymbol { \\theta } }$ with $n$ free parameters. While with a larger $K$ , locality is no longer guaranteed. Different from ChebyNet, we address the aforementioned three limitations through replacing graph Fourier transform with graph wavelet transform. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 GRAPH WAVELET TRANSFORM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            205,
+            426,
+            219
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Similar to graph Fourier transform, graph wavelet transform projects graph signal from vertex domain into spectral domain. Graph wavelet transform employs a set of wavelets as bases, defined as $\\psi _ { s } = ( \\psi _ { s 1 } , \\psi _ { s 2 } , . . . , \\psi _ { s n } )$ , where each wavelet $\\psi _ { s i }$ corresponds to a signal on graph diffused away from node $i$ and $s$ is a scaling parameter. Mathematically, $\\psi _ { s i }$ can be written as ",
+        "bbox": [
+            174,
+            232,
+            823,
+            289
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04e7f8b32db6c7a150115ab9e4bd040abcbc33f498ad5dd82f28c2b0686634d9.jpg",
+        "text": "$$\n\\psi _ { s } = U G _ { s } U ^ { \\top } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            296,
+            553,
+            314
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $U$ is Laplacian eigenvectors, $G _ { s } \\mathrm { = d i a g } \\big ( g ( s \\lambda _ { 1 } ) , . . . , g ( s \\lambda _ { n } ) \\big )$ is a scaling matrix and $g ( s \\lambda _ { i } ) =$ $e ^ { \\lambda _ { i } s }$ . ",
+        "bbox": [
+            176,
+            321,
+            826,
+            353
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using graph wavelets as bases, graph wavelet transform of a signal $_ { \\textbf { \\em x } }$ on graph is defined as ${ \\hat { \\mathbf { x } } } = { }$ ${ \\psi } _ { s } ^ { - 1 } \\bar { x }$ and the inverse graph wavelet transform is $\\boldsymbol { x } = \\psi _ { s } \\hat { \\pmb { x } }$ . Note that $\\bar { \\psi } _ { s } ^ { - 1 }$ can be obtained by simply replacing the $g ( s \\lambda _ { i } )$ in $\\psi _ { s }$ with $g ( - s \\lambda _ { i } )$ corresponding to a heat kernel (Donnat et al., 2018). Replacing the graph Fourier transform in Equation (1) with graph wavelet transform, we obtain the graph convolution as ",
+        "bbox": [
+            173,
+            359,
+            825,
+            430
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9e004a1ced473b2db4a84803136e5c6d1e66a7e0e72e1dbdd5b4da5bdd50fd11.jpg",
+        "text": "$$\n\\pmb { x } * _ { \\mathscr { G } } \\pmb { y } = \\psi _ { s } ( ( \\psi _ { s } ^ { - 1 } \\pmb { y } ) \\odot ( \\psi _ { s } ^ { - 1 } \\pmb { x } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            429,
+            614,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Compared to graph Fourier transform, graph wavelet transform has the following benefits when being used to define graph convolution: ",
+        "bbox": [
+            173,
+            459,
+            825,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. High efficiency: graph wavelets can be obtained via a fast algorithm without requiring the eigendecomposition of Laplacian matrix. In Hammond et al. (2011), a method is proposed to use Chebyshev polynomials to efficiently approximate $\\psi _ { s }$ and $\\psi _ { s } ^ { - 1 }$ , with the computational complexity $O ( m \\times | \\mathbb { E } | )$ , where $\\lvert \\mathbb { E } \\rvert$ is the number of edges and $m$ is the order of Chebyshev polynomials. ",
+        "bbox": [
+            173,
+            494,
+            825,
+            551
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2. High spareness: the matrix $\\psi _ { s }$ and $\\psi _ { s } ^ { - 1 }$ are both sparse for real world networks, given that these networks are usually sparse. Therefore, graph wavelet transform is much more computationally efficient than graph Fourier transform. For example, in the Cora dataset, more than $9 7 \\%$ elements in $\\psi _ { s } ^ { - 1 }$ are zero while only less than $1 \\%$ elements in $U ^ { \\top }$ are zero (Table 4). ",
+        "bbox": [
+            173,
+            558,
+            825,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3. Localized convolution: each wavelet corresponds to a signal on graph diffused away from a centered node, highly localized in vertex domain. As a result, the graph convolution defined in Equation (4) is localized in vertex domain. We show the localization property of graph convolution in Appendix A. It is the localization property that explains why graph wavelet transform outperforms Fourier transform in defining graph convolution and the associated tasks like graph-based semisupervised learning. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            705
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/3babc8cc3ed3a06ed78d5a3fc82cb836ef0d897c86a6206ca71e5d2283c3d072.jpg",
+        "image_caption": [
+            "Figure 1: Wavelets on an example graph at (a) small scale and (b) large scale. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            736,
+            805,
+            893
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4. Flexible neighborhood: graph wavelets are more flexible to adjust node’s neighborhoods. Different from previous methods which constrain neighborhoods by the discrete shortest path distance, our method leverages a continuous manner, i.e., varying the scaling parameter $s$ . A small value of $s$ generally corresponds to a smaller neighborhood. Figure 1 shows two wavelet bases at different scale on an example network, depicted using GSP toolbox (Perraudin et al., 2014). ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4 GRAPH WAVELET NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            190,
+            472,
+            205
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Replacing Fourier transform with wavelet transform, graph wavelet neural network (GWNN) is a multi-layer convolutional neural network. The structure of the $m$ -th layer is ",
+        "bbox": [
+            171,
+            217,
+            825,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92c8cfcb9aca6335fd97c6b299506ade4cb6186adc544637355b21d8f23f0b25.jpg",
+        "text": "$$\n{ \\pmb X } _ { [ : , j ] } ^ { m + 1 } = h ( \\psi _ { s } \\sum _ { i = 1 } ^ { p } { \\pmb F } _ { i , j } ^ { m } \\psi _ { s } ^ { - 1 } { \\pmb X } _ { [ : , i ] } ^ { m } ) \\qquad j = 1 , \\cdots , q ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            252,
+            674,
+            295
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\psi _ { s }$ is wavelet bases, $\\psi _ { s } ^ { - 1 }$ is the graph wavelet transform matrix at scale $s$ which projects signal in vertex domain into spectral domain, $X _ { [ : , i ] } ^ { m }$ with dimensions $n \\times 1$ is the $i$ -th column of ${ \\pmb X } ^ { m }$ , ${ \\bf \\it F } _ { i , j } ^ { m }$ is a diagonal filter matrix learned in spectral domain, and $h$ is a non-linear activation function. This layer transforms an input tensor ${ \\pmb X } ^ { m }$ with dimensions $n \\times p$ into an output tensor $X ^ { m + 1 }$ with dimensions $n \\times q$ . ",
+        "bbox": [
+            174,
+            301,
+            826,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we consider a two-layer GWNN for semi-supervised node classification on graph. The formulation of our model is ",
+        "bbox": [
+            173,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e3ed3b8b55e2735e72729ae725daf15e2a2e147ac38adf82ad65617597efc57a.jpg",
+        "text": "$$\n\\mathrm { f i r s t ~ l a y e r : ~ } X _ { [ : , j ] } ^ { 2 } = \\mathrm { R e L U } ( \\psi _ { s } \\sum _ { i = 1 } ^ { p } F _ { i , j } ^ { 1 } \\psi _ { s } ^ { - 1 } X _ { [ : , i ] } ^ { 1 } ) \\qquad j = 1 , \\cdots , q ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            414,
+            728,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa69fc60467c37bbf7fc84193bc05ae7094880cca1b4cae3e4478c1c85501f82.jpg",
+        "text": "$$\n\\mathrm { s e c o n d l a y e r : ~ } Z _ { j } = \\mathrm { s o f t m a x } ( \\psi _ { s } \\sum _ { i = 1 } ^ { q } F _ { i , j } ^ { 2 } \\psi _ { s } ^ { - 1 } X _ { [ : , \\ : , i ] } ^ { 2 } ) \\qquad j = 1 , \\cdots , c ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            463,
+            738,
+            505
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $c$ is the number of classes in node classification, $z$ of dimensions $n \\times c$ is the prediction result. The loss function is the cross-entropy error over all labeled examples: ",
+        "bbox": [
+            174,
+            507,
+            823,
+            536
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0388fb65683efc5fe6011f13ab36f3df734526d9828931e4596522e2eecbdb17.jpg",
+        "text": "$$\n\\boldsymbol { L o s s } = - \\sum _ { l \\in y _ { L } } \\sum _ { i = 1 } ^ { c } Y _ { l i } \\mathrm { l n } { \\boldsymbol { Z } _ { l i } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            542,
+            594,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { L }$ is the labeled node set, $Y _ { l i } = 1$ if the label of node $l$ is $i$ , and ${ Y _ { l i } } = 0$ otherwise. The weights $\\pmb { F }$ are trained using gradient descent. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5 REDUCING PARAMETER COMPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            638,
+            478,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Equation (5), the parameter complexity of each layer is $O ( n \\times p \\times q )$ , where $n$ is the number of nodes, $p$ is the number of features of each vertex in current layer, and $q$ is the number of features of each vertex in next layer. Conventional CNN methods learn convolution kernel for each pair of input feature and output feature. This results in a huge number of parameters and generally requires huge training data for parameter learning. This is prohibited for graph-based semi-supervised learning. To combat this issue, we detach the feature transformation from graph convolution. Each layer in GWNN is divided into two components: feature transformation and graph convolution. Spectially, we have ",
+        "bbox": [
+            173,
+            664,
+            825,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d7dcd753043560ff1f8563014754b4c65f6de01cd098fa1c48574749f5944621.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\mathrm { f e a t u r e ~ t r a n s f o r m a t i o n : } ~ { \\cal X } ^ { m ^ { \\prime } } = { \\cal X } ^ { m } { \\cal W } , } } \\\\ { { \\mathrm { g r a p h ~ c o n v o l u t i o n : } ~ { \\cal X } ^ { m + 1 } = h ( \\psi _ { s } { \\cal F } ^ { m } \\psi _ { s } ^ { - 1 } { \\cal X } ^ { m ^ { \\prime } } ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            772,
+            671,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W \\in \\mathbb { R } ^ { p \\times q }$ is the parameter matrix for feature transformation, $X ^ { m ^ { \\prime } }$ with dimensions $n \\times q$ is the feature matrix after feature transformation, ${ \\pmb F } ^ { m }$ is the diagonal matrix for graph convolution kernel, and $h$ is a non-linear activation function. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After detaching feature transformation from graph convolution, the parameter complexity is reduced from $O ( n \\times p \\times q )$ to $O ( n + p \\times q )$ . The reduction of parameters is particularly valuable fro graphbased semi-supervised learning where labels are quite limited. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            349,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Graph convolutional neural networks on graphs. The success of CNNs when dealing with images, videos, and speeches motivates researchers to design graph convolutional neural network on graphs. The key of generalizing CNNs to graphs is defining convolution operator on graphs. Existing methods are classified into two categories, i.e., spectral methods and spatial methods. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Spectral methods define convolution via convolution theorem. Spectral CNN (Bruna et al., 2014) is the first attempt at implementing CNNs on graphs, leveraging graph Fourier transform and defining convolution kernel in spectral domain. Boscaini et al. (2015) developed a local spectral CNN approach based on the graph Windowed Fourier Transform. Defferrard et al. (2016) introduced a Chebyshev polynomial parametrization for spectral filter, offering us a fast localized spectral filtering method. Kipf & Welling (2017) provided a simplified version of ChebyNet, gaining success in graph-based semi-supervised learning task. Khasanova & Frossard (2017) represented images as signals on graph and learned their transformation invariant representations. They used Chebyshev approximations to implement graph convolution, avoiding matrix eigendecomposition. Levie et al. (2017) used rational functions instead of polynomials and created anisotropic spectral filters on manifolds. ",
+        "bbox": [
+            174,
+            203,
+            825,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Spatial methods define convolution as a weighted average function over neighborhood of target vertex. GraphSAGE takes one-hop neighbors as neighborhoods and defines the weighting function as various aggregators over neighborhood (Hamilton et al., 2017). Graph attention network (GAT) proposes to learn the weighting function via self-attention mechanism (Velickovic et al., 2017). MoNet offers us a general framework for design spatial methods, taking convolution as the weighted average of multiple weighting functions defined over neighborhood (Monti et al., 2017). Some works devote to making graph convolutional networks more powerful. Monti et al. (2018) alternated convolutions on vertices and edges, generalizing GAT and leading to better performance. GraphsGAN (Ding et al., 2018) generalizes GANs to graph, and generates fake samples in low-density areas between subgraphs to improve the performance on graph-based semi-supervised learning. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Graph wavelets. Sweldens (1998) presented a lifting scheme, a simple construction of wavelets that can be adapted to graphs without learning process. Hammond et al. (2011) proposed a method to construct wavelet transform on graphs. Moreover, they designed an efficient way to bypass the eigendecomposition of the Laplacian and approximated wavelets with Chebyshev polynomials. Tremblay & Borgnat (2014) leveraged graph wavelets for multi-scale community mining by modulating a scaling parameter. Owing to the property of describing information diffusion, Donnat et al. (2018) learned structural node embeddings via wavelets. All these works prove that graph wavelets are not only local and sparse but also valuable for signal processiong on graph. ",
+        "bbox": [
+            173,
+            508,
+            825,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            326,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            689,
+            287,
+            704
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the proposed GWNN, we apply GWNN on semi-supervised node classification, and conduct experiments on three benchmark datasets, namely, Cora, Citeseer and Pubmed (Sen et al., 2008). In the three citation network datasets, nodes represent documents and edges are citation links. Details of these datasets are demonstrated in Table 1. Here, the label rate denotes the proportion of labeled nodes used for training. Following the experimental setup of GCN (Kipf & Welling, 2017), we fetch 20 labeled nodes per class in each dataset to train the model. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/46f47136cd2e57d6c2f4a847207ad40352c6c9a762d65d6f9b2277a136fbcf2c.jpg",
+        "table_caption": [
+            "Table 1: The Statistics of Datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Nodes</td><td>Edges</td><td>Classes</td><td>Features</td><td>Label Rate</td></tr><tr><td>Cora</td><td>2,708</td><td>5,429</td><td>7</td><td>1,433</td><td>0.052</td></tr><tr><td>Citeseer</td><td>3,327</td><td>4,732</td><td>6</td><td>3,703</td><td>0.036</td></tr><tr><td>Pubmed</td><td>19,717</td><td>44,338</td><td>3</td><td>500</td><td>0.003</td></tr></table>",
+        "bbox": [
+            285,
+            848,
+            707,
+            905
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            294,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare with several traditional semi-supervised learning methods, including label propagation (LP) (Zhu et al., 2003), semi-supervised embedding (SemiEmb) (Weston et al., 2012), manifold regularization (ManiReg) (Belkin et al., 2006), graph embeddings (DeepWalk) (Perozzi et al., 2014), iterative classification algorithm (ICA) (Lu & Getoor, 2003) and Planetoid (Yang et al., 2016). ",
+        "bbox": [
+            174,
+            130,
+            825,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, along with the development of deep learning on graph, graph convolutional networks are proved to be effective in semi-supervised learning. Since our method is a spectral method based on convolution theorem, we compare it with the Spectral CNN (Bruna et al., 2014). ChebyNet (Defferrard et al., 2016) and GCN (Kipf & Welling, 2017), two variants of the Spectral CNN, are also included as our baselines. Considering spatial methods, we take MoNet (Monti et al., 2017) as our baseline, which also depends on Laplacian matrix. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            276
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 EXPERIMENTAL SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            294,
+            398,
+            308
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train a two-layer graph wavelet neural network with 16 hidden units, and prediction accuracy is evaluated on a test set of 1000 labeled samples. The partition of datasets is the same as GCN (Kipf & Welling, 2017) with an additional validation set of 500 labeled samples to determine hyper-parameters. ",
+        "bbox": [
+            174,
+            320,
+            823,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Weights are initialized following Glorot & Bengio (2010). We adopt the Adam optimizer (Kingma & Ba, 2014) for parameter optimization with an initial learning rate $l r = 0 . 0 1$ . For computational efficiency, we set the elements of $\\psi _ { s }$ and $\\psi _ { s } ^ { - 1 }$ smaller than a threshold $t$ to 0. We find the optimal hyper-parameters $s$ and $t$ through grid search, and the detailed discussion about the two hyperparameters is introduced in Appendix B. For Cora, $s = 1 . 0$ and $t = 1 e - 4$ . For Citeseer, $s = 0 . 7$ and $t = 1 e - 5$ . For Pubmed, $s = 0 . 5$ and $t = 1 e - 7$ . To avoid overfitting, dropout (Srivastava et al., 2014) is applied. Meanwhile, we terminate the training if the validation loss does not decrease for 100 consecutive epochs. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            494
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 ANALYSIS ON DETACHING FEATURE TRANSFORMATION FROM CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            513,
+            746,
+            526
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since the number of parameters for the undetached version of GWNN is $O ( n \\times p \\times q )$ , we can hardly implement this version in the case of networks with a large number $n$ of nodes and a huge number $p$ of input features. Here, we validate the effectiveness of detaching feature transformation form convolution on ChebyNet (introduced in Section 2.2), whose parameter complexity is $O ( K \\times$ $p \\times q \\rangle$ . For ChebyNet of detaching feature transformation from graph convolution, the number of parameters is reduced to $O ( K + p \\times q )$ . Table 2 shows the performance and the number of parameters on three datasets. Here, the reported performance is the optimal performance varying the order $K = 2 , 3 , 4$ . ",
+        "bbox": [
+            174,
+            537,
+            825,
+            650
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/d8b7835732339c77405a5253f8a71360b62a31a0f64147efd6311681195d4217.jpg",
+        "table_caption": [
+            "Table 2: Results of Detaching Feature Transformation from Convolution "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td rowspan=\"2\">Prediction Accuracy</td><td>ChebyNet</td><td>81.2%</td><td>69.8%</td><td>74.4%</td></tr><tr><td>Detaching-ChebyNet</td><td>81.6%</td><td>68.5%</td><td>78.6%</td></tr><tr><td rowspan=\"2\">Number of Parameters</td><td>ChebyNet</td><td>46.080 (K=2)</td><td>178,032 (K=3)</td><td>24,144 (K=3)</td></tr><tr><td>Detaching-ChebyNet</td><td>23,048 (K=4)</td><td>59,348 (K=2)</td><td>8,054 (K=3)</td></tr></table>",
+        "bbox": [
+            187,
+            685,
+            807,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As demonstrated in Table 2, with fewer parameters, we improve the accuracy on Pubmed by a large margin. This is due to that the label rate of Pubmed is only 0.003. By detaching feature transformation from convolution, the parameter complexity is significantly reduced, alleviating overfitting in semi-supervised learning and thus remarkably improving prediction accuracy. On Citeseer, there is a little drop on the accuracy. One possible explanation is that reducing the number of parameters may restrict the modeling capacity to some degree. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.5 PERFORMANCE OF GWNN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            868,
+            401,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now validate the effectiveness of GWNN with detaching technique on node classification. Experimental results are reported in Table 3. GWNN improves the classification accuracy on all the three datasets. In particular, replacing Fourier transform with wavelet transform, the proposed GWNN is comfortably ahead of Spectral CNN, achieving $1 0 \\%$ improvement on Cora and Citeseer, and $5 \\%$ improvement on Pubmed. The large improvement could be explained from two perspectives: (1) Convolution in Spectral CNN is non-local in vertex domain, and thus the range of feature diffusion is not restricted to neighboring nodes; (2) The scaling parameter $s$ of wavelet transform is flexible to adjust the diffusion range to suit different applications and different networks. GWNN consistently outperforms ChebyNet, since it has enough degree of freedom to learn the convolution kernel, while ChebyNet is a kind of approximation with limited degree of freedom. Furthermore, our GWNN also performs better than GCN and MoNet, reflecting that it is promising to design appropriate bases for spectral methods to achieve good performance. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/efcc48009a768d9a3fb2248ded3c8d2323d70d2efe5c7ea490293d52b4341c0a.jpg",
+        "table_caption": [
+            "Table 3: Results of Node Classification "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td>MLP</td><td>55.1%</td><td>46.5%</td><td>71.4%</td></tr><tr><td>ManiReg</td><td>59.5%</td><td>60.1%</td><td>70.7%</td></tr><tr><td>SemiEmb</td><td>59.0%</td><td>59.6%</td><td>71.7%</td></tr><tr><td>LP</td><td>68.0%</td><td>45.3%</td><td>63.0%</td></tr><tr><td>DeepWalk</td><td>67.2%</td><td>43.2%</td><td>65.3%</td></tr><tr><td>ICA</td><td>75.1%</td><td>69.1%</td><td>73.9%</td></tr><tr><td>Planetoid</td><td>75.7%</td><td>64.7%</td><td>77.2%</td></tr><tr><td>Spectral CNN</td><td>73.3%</td><td>58.9%</td><td>73.9%</td></tr><tr><td>ChebyNet</td><td>81.2%</td><td>69.8%</td><td>74.4%</td></tr><tr><td>GCN</td><td>81.5%</td><td>70.3%</td><td>79.0%</td></tr><tr><td>MoNet</td><td>81.7±0.5%</td><td></td><td>78.8±0.3%</td></tr><tr><td>GWNN</td><td>82.8%</td><td>71.7%</td><td>79.1%</td></tr></table>",
+        "bbox": [
+            320,
+            122,
+            673,
+            292
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            318,
+            825,
+            457
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.6 ANALYSIS ON SPARSITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            380,
+            488
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Besides the improvement on prediction accuracy, wavelet transform with localized and sparse transform matrix holds sparsity in both spatial domain and spectral domain. Here, we take Cora as an example to illustrate the sparsity of graph wavelet transform. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            542
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The sparsity of transform matrix. There are 2,708 nodes in Cora. Thus, the wavelet transform matrix $\\psi _ { s } ^ { - 1 }$ and the Fourier transform matrix $U ^ { \\top }$ both belong to $\\mathbb { R } ^ { 2 , 7 0 8 \\times 2 , 7 0 8 }$ . The first two rows in Table 4 demonstrate that $\\psi _ { s } ^ { - 1 }$ is much sparser than $U ^ { \\top }$ . Sparse wavelets not only accelerate the computation, but also well capture the neighboring topology centered at each node. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The sparsity of projected signal. As mentioned above, each node in Cora represents a document and has a sparse bag-of-words feature. The input feature $\\ b { X } \\in \\mathbb { R } ^ { n \\times p }$ is a binary matrix, and $X _ { [ i , j ] } =$ 1 when the $i$ -th document contains the $j$ -th word in the bag of words, it equals 0 otherwise. Here, $X _ { [ : , j ] }$ denotes the $j$ -th column of $\\boldsymbol { X }$ , and each column represents the feature vector of a word. Considering a specific signal $X _ { [ : , 9 8 4 ] }$ , we project the spatial signal into spectral domain, and get its projected vector. Here, $p = \\bar { \\psi _ { s } ^ { - 1 } } X _ { [ : , 9 8 4 ] }$ denotes the projected vector via wavelet transform, $\\pmb { q } = \\pmb { U } ^ { \\top } \\pmb { X } _ { [ : , 9 8 4 ] }$ denotes the projected vector via Fourier transform, and $\\pmb { p } , \\pmb { q } \\in \\mathbb { R } ^ { 2 , 7 0 8 }$ . The last row in Table 4 lists the numbers of non-zero elements in $\\pmb { p }$ and $\\pmb q$ . As shown in Table 4, with wavelet transform, the projected signal is much sparser. ",
+        "bbox": [
+            173,
+            612,
+            825,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b83a988b9d0546311226519134a20bc2d2eef6892a04afc155ea89885703e987.jpg",
+        "table_caption": [
+            "Table 4: Statistics of wavelet transform and Fourier transform on Cora "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Statistical Property</td><td>wavelettransform</td><td>Fouriertransform</td></tr><tr><td rowspan=\"2\">Transform Matrix</td><td>Density</td><td>2.8%</td><td>99.1%</td></tr><tr><td>Number of Non-zero Elements</td><td>205,774</td><td>7,274,383</td></tr><tr><td rowspan=\"2\">Projected Signal</td><td>Density</td><td>10.9%</td><td>100%</td></tr><tr><td>Number of Non-zero Elements</td><td>297</td><td>2,708</td></tr></table>",
+        "bbox": [
+            192,
+            776,
+            802,
+            845
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.7 ANALYSIS ON INTERPRETABILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            449,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Compare with graph convolution network using Fourier transform, GWNN provides good interpretability. Here, we show the interpretability with specific examples in Cora. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Each feature, i.e. word in the bag of words, has a projected vector, and each element in this vector is associated with a spectral wavelet basis. Here, each basis is centered at a node, corresponding to a document. The value can be regarded as the relation between the word and the document. Thus, each value in $\\pmb { p }$ can be interpreted as the relation between $W o r d _ { 9 8 4 }$ and a document. In order to elaborate the interpretability of wavelet transform, we analyze the projected values of different feature as following. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Considering two features $W o r d _ { 9 8 4 }$ and $W o r d _ { 1 1 7 7 }$ , we select the top-10 active bases, which have the 10 largest projected values of each feature. As illustrated in Figure 2, for clarity, we magnify the local structure of corresponding nodes and marked them with bold rims. The central network in each subgraph denotes the dataset Cora, each node represents a document, and 7 different colors represent 7 classes. These nodes are clustered by OpenOrd (Martin et al., 2011) based on the adjacency matrix. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 2a shows the top-10 active bases of $W o r d _ { 9 8 4 }$ . In Cora, this word only appears 8 times, and all the documents containing $W o r d _ { 9 8 4 }$ belong to the class “ Case-Based ”. Consistently, all top-10 nodes activated by $W o r d _ { 9 8 4 }$ are concentrated and belong to the class “ Case-Based ”. And, the frequencies of $W o r d _ { 1 1 7 7 }$ appearing in different classes are similar, indicating that $W o r d _ { 1 1 7 7 }$ is a universal word. In concordance with our expectation, the top-10 active bases of $W o r d _ { 1 1 7 7 }$ are discrete and belong to different classes in Figure 2b. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ea6f31973347c969205987dfaf594ad41a7761eb7d83787038298d9e7dd7f3d.jpg",
+        "image_caption": [
+            "Figure 2: Top-10 active bases of two words in Cora. The central network of each subgraph represents the dataset Cora, which is split into 7 classes. Each node represents a document, and its color indicates its label. The nodes that represent the top-10 active bases are marked with bold rims. (a) $W o r d _ { 9 8 4 }$ only appears in documents of the class “ Case-Based ” in Cora. Consistently, all its 10 active bases also belong to the class “ Case-Based ”. (b) The frequencies of $W o r d _ { 1 1 7 7 }$ appearing in different classes are similar in Cora. As expected, the top-10 active bases of $W o r d _ { 1 1 7 7 }$ also belong to different classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            386,
+            816,
+            579
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Owing to the properties of graph wavelets, which describe the neighboring topology centered at each node, the projected values of wavelet transform can be explained as the correlation between features and nodes. These properties provide an interpretable domain transformation and ease the understanding of graph convolution. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            765
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            318,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Replacing graph Fourier transform with graph wavelet transform, we proposed GWNN. Graph wavelet transform has three desirable properties: (1) Graph wavelets are local and sparse; (2) Graph wavelet transform is computationally efficient; (3) Convolution is localized in vertex domain. These advantages make the whole learning process interpretable and efficient. Moreover, to reduce the number of parameters and the dependence on huge training data, we detached the feature transformation from convolution. This practice makes GWNN applicable to large graphs, with remarkable performance improvement on graph-based semi-supervised learning. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            398,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work is funded by the National Natural Science Foundation of China under grant numbers 61425016, 61433014, and 91746301. Huawei Shen is also funded by K.C. Wong Education Foundation and the Youth Innovation Promotion Association of the Chinese Academy of Sciences. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            175
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            196,
+            285,
+            212
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Davide Boscaini, Jonathan Masci, Simone Melzi, Michael M Bronstein, Umberto Castellani, and Pierre Vandergheynst. Learning class-specific descriptors for deformable shapes using localized spectral convolutional networks. In Computer Graphics Forum, volume 34, pp. 13–23. Wiley Online Library, 2015. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            327
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017. ",
+        "bbox": [
+            173,
+            335,
+            825,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann Lecun. Spectral networks and locally connected networks on graphs. In International Conference on Learning Representations (ICLR2014), CBLS, April 2014, 2014. ",
+        "bbox": [
+            173,
+            387,
+            825,
+            429
+        ],
+        "page_idx": 8
+    },
+    {
+        "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. 3844–3852, 2016. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ming Ding, Jie Tang, and Jie Zhang. Semi-supervised learning on graphs with generative adversarial nets. In Proceedings of the 27th ACM International Conference on Information and Knowledge Management, pp. 913–922. ACM, 2018. ",
+        "bbox": [
+            174,
+            488,
+            823,
+            531
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Claire Donnat, Marinka Zitnik, David Hallac, and Jure Leskovec. Learning structural node embeddings via diffusion wavelets. 2018. ",
+        "bbox": [
+            171,
+            540,
+            823,
+            569
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 249–256, 2010. ",
+        "bbox": [
+            173,
+            577,
+            823,
+            621
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1024–1034, 2017. ",
+        "bbox": [
+            171,
+            628,
+            823,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David K Hammond, Pierre Vandergheynst, and Remi Gribonval. Wavelets on graphs via spectral ´ graph theory. Applied and Computational Harmonic Analysis, 30(2):129–150, 2011. ",
+        "bbox": [
+            173,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "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,
+            703,
+            823,
+            746
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal processing magazine, 29(6):82–97, 2012. ",
+        "bbox": [
+            173,
+            755,
+            825,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Renata Khasanova and Pascal Frossard. Graph-based isometry invariant representation learning. In International Conference on Machine Learning, pp. 1847–1856, 2017. ",
+        "bbox": [
+            173,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            858,
+            821,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ron Levie, Federico Monti, Xavier Bresson, and Michael M Bronstein. Cayleynets: Graph convolutional neural networks with complex rational spectral filters. arXiv preprint arXiv:1705.07664, 2017. ",
+        "bbox": [
+            176,
+            140,
+            823,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            173,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shawn Martin, W Michael Brown, Richard Klavans, and Kevin W Boyack. Openord: an opensource toolbox for large graph layout. In Visualization and Data Analysis 2011, volume 7868, pp. 786806. International Society for Optics and Photonics, 2011. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "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. In Proc. CVPR, volume 1, pp. 3, 2017. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Federico Monti, Oleksandr Shchur, Aleksandar Bojchevski, Or Litany, Stephan Gunnemann, ¨ and Michael M Bronstein. Dual-primal graph convolutional networks. arXiv preprint arXiv:1806.00770, 2018. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nathanael Perraudin, Johan Paratte, David Shuman, Lionel Martin, Vassilis Kalofolias, Pierre Van-¨ dergheynst, and David K Hammond. Gspbox: A toolbox for signal processing on graphs. arXiv preprint arXiv:1408.5781, 2014. ",
+        "bbox": [
+            173,
+            436,
+            825,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93, 2008. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. IEEE Signal Processing Magazine, 30(3):83–98, 2013. ",
+        "bbox": [
+            174,
+            525,
+            823,
+            569
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            176,
+            577,
+            823,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wim Sweldens. The lifting scheme: A construction of second generation wavelets. SIAM journal on mathematical analysis, 29(2):511–546, 1998. ",
+        "bbox": [
+            168,
+            628,
+            825,
+            659
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Tremblay and Pierre Borgnat. Graph wavelets for multiscale community mining. IEEE Transactions on Signal Processing, 62(20):5227–5239, 2014. ",
+        "bbox": [
+            171,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017. ",
+        "bbox": [
+            171,
+            704,
+            823,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            171,
+            742,
+            821,
+            772
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In International Conference on Machine Learning, pp. 40–48, 2016. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            174,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We use a diagonal matrix $\\Theta$ to represent the learned kernel transformed by wavelets $\\psi _ { s } ^ { - 1 } \\pmb { y }$ , and replace the Hadamard product with matrix muplication. Then Equation (4) is: ",
+        "bbox": [
+            173,
+            132,
+            823,
+            162
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb00eaaf20b8fc973533ae8321393cb8c9ad33242addee8f301279cb366623ee.jpg",
+        "text": "$$\n\\pmb { x } * _ { \\mathcal { G } } \\pmb { y } = \\psi _ { s } \\Theta \\psi _ { s } ^ { - 1 } \\pmb { x } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            167,
+            571,
+            186
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We set $\\psi _ { s } = ( \\psi _ { s 1 } , \\psi _ { s 2 } , . . . , \\psi _ { s n } )$ , $\\psi _ { s } ^ { - 1 } = ( \\psi _ { s 1 } ^ { * } , \\psi _ { s 2 } ^ { * } , . . . , \\psi _ { s n } ^ { * } )$ , and $\\Theta = \\mathrm { d i a g } ( \\{ \\theta _ { k } \\} _ { k = 1 } ^ { n } )$ . Equation (11) becomes : ",
+        "bbox": [
+            176,
+            199,
+            826,
+            228
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2826006a58deaa6e5c37eafe3865ee4566bc2a2852206f1de1021d4d95fed886.jpg",
+        "text": "$$\n\\pmb { x } * _ { \\mathscr { G } } \\pmb { y } = \\sum _ { k = 1 } ^ { n } \\theta _ { k } \\psi _ { s k } ( \\psi _ { s k } ^ { * } ) ^ { \\top } \\pmb { x } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            227,
+            599,
+            268
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "As proved by Hammond et al. (2011), both $\\psi _ { s }$ and $\\psi _ { s } ^ { - 1 }$ are local in small scale (s). Figure 3 shows the locality of $\\psi _ { s 1 }$ and $\\psi _ { s 1 } ^ { * }$ , i.e., the first column in $\\psi _ { s }$ and $\\psi _ { s } ^ { - 1 }$ when $s = 3$ . Each column in $\\psi _ { s }$ and $\\psi _ { s } ^ { - 1 }$ describes the neighboring topology of target node, which means that $\\psi _ { s }$ and $\\psi _ { s } ^ { - 1 }$ are local. The locality of $\\psi _ { s k }$ and $\\psi _ { s k } ^ { * }$ leads to the locality of the resulting matrix of multiplication between the column vector $\\psi _ { s k }$ and row vector $( \\psi _ { s k } ^ { * } ) ^ { \\top }$ . For convenience, we set $M _ { k } = \\psi _ { s k } ( \\psi _ { s k } ^ { * } ) ^ { \\top }$ , $M _ { k [ i , j ] } > 0$ only when $\\psi _ { s k } [ i ] > 0$ and $( \\psi _ { s k } ^ { * } ) ^ { \\top } [ j ] > 0$ . In other words, if $M _ { k [ i , j ] } > 0$ , vertex $i$ and vertex $j$ can correlate with each other through vertex $k$ . ",
+        "bbox": [
+            173,
+            279,
+            826,
+            383
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/3bace0dca654718860a873ae36fecfdf5825bb2d5b239f07e6fb3900d9126899.jpg",
+        "image_caption": [
+            "Figure 3: Locality of (a) $\\psi _ { s 1 }$ and (b) $\\psi _ { s 1 } ^ { * }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            412,
+            807,
+            553
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Since each $M _ { k }$ is local, for any convolution kernel $\\Theta$ , $\\psi _ { s } \\Theta \\psi _ { s } ^ { - 1 }$ is local, and it means that convolution is localized in vertex domain. By replacing $\\Theta$ with an identity matrix in Equation (12), we get $\\begin{array} { r } { \\pmb { x } * _ { \\mathcal { G } } \\pmb { y } = \\sum _ { k = 1 } ^ { n } M _ { k } \\pmb { x } } \\end{array}$ . We define $\\begin{array} { r } { \\mathbf { \\dot { H } } = \\sum _ { k = 1 } ^ { n ^ { * } } M _ { k } } \\end{array}$ , and Figure 4 shows $H _ { [ 1 , : ] }$ in different scaling, i.e., correlation between the first node and other nodes during convolution. The locality of $\\pmb { H }$ suggests that graph convolution is localized in vertex domain. Moreover, as the scaling parameter $s$ becomes larger, the range of feature diffusion becomes larger. ",
+        "bbox": [
+            173,
+            593,
+            826,
+            679
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/377dd1763f6ee42479178aa2c4bcb662df3cbd7f5dd463a3b122c3167e6d6b46.jpg",
+        "image_caption": [
+            "Figure 4: Correlation between first node and other nodes at (a) small scale and (b) large scale. Nonzero value of node represents correlation between this node and target node during convolution. Locality of $\\pmb { H }$ suggests that graph convolution is localized in vertex domain. Moreover, with scaling parameter $s$ becoming larger, the range of feature diffusion becomes larger. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            704,
+            807,
+            844
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/40fcbdd4a017ec82e8d7bce4e03011ac72b42888e765e88a447a7ae0220b410e.jpg",
+        "image_caption": [
+            "Figure 5: Influence of $s$ and $t$ on Cora. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            142,
+            725,
+            393
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "GWNN leverages graph wavelets to implement graph convolution, where $s$ is used to modulate the range of neighborhoods. From Figure 5, as $s$ becomes larger starting from 0, the range of neighboring nodes becomes large, resulting the increase of accuracy on Cora. However when $s$ becomes too large, some irrelevant nodes are included, leading to decreasing of accuracy. The hyperparameter $t$ only used for computational efficiency, has any slight influence on its performance. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            518
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For experiments on specific dataset, $s$ and $t$ are choosen via grid search using validation. Generally, a appropriate $s$ is in the range of [0.5, 1], which can not only capture the graph structure but also guarantee the locality of convolution, and $t$ is less insensive to dataset. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            566
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C PARAMETER COMPLEXITY OF NODE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            588,
+            746,
+            606
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We show the parameter complexity of node classification in Table 5. The high parameter complexity $O ( n * p * q )$ of Spectral CNN makes it difficult to generalize to real world networks. ChebyNet approximates the convolution kernel via polynomial function of the diagonal matrix of Laplacian eigenvalues, reducing parameter complexity to $O ( K * p * q )$ with $K$ being the order of polynomial function. GCN simplifies ChebyNet via setting $K { = } 1$ . We detach feature transformation from graph convolution to implement GWNN and Spectral CNN in our experiments, which can reduce parameter to $O ( n + p * q )$ . ",
+        "bbox": [
+            173,
+            621,
+            825,
+            720
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/3397826a3f2f195422d11af03b53a1ac8fa2f563cee28d60d393f567a468acc8.jpg",
+        "table_caption": [
+            "Table 5: Parameter complexity of Node Classification "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td>Spectral CNN</td><td>62,392,320</td><td>197,437,488</td><td>158,682,416</td></tr><tr><td>Spectral CNN (detaching)</td><td>28,456</td><td>65,379</td><td>47,482</td></tr><tr><td>ChebyNet</td><td>46,080 (K=2)</td><td>178,032 (K=3)</td><td>24,144 (K=3)</td></tr><tr><td>GCN</td><td>23,040</td><td>59,344</td><td>8.048</td></tr><tr><td>GWNN</td><td>28,456</td><td>65,379</td><td>47,482</td></tr></table>",
+        "bbox": [
+            254,
+            757,
+            740,
+            838
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In Cora and Citeseer, with smaller parameter complexity, GWNN achieves better performance than ChebyNet, reflecting that it is promising to implement convolution via graph wavelet transform. As Pubmed has a large number of nodes, the parameter complexity of GWNN is larger than ChebyNet. As future work, it is an interesting attempt to select wavelets associated with a subset of nodes, further reducing parameter complexity with potential loss of performance. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX D FAST GRAPH WAVELETS WITH CHEBYSHEV POLYNOMIAL APPROXIMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            777,
+            136
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hammond et al. (2011) proposed a method, using Chebyshev polynomials to efficiently approximate $\\psi _ { s }$ and $\\psi _ { s } ^ { - 1 }$ . The computational complexity is $O ( m \\times | \\mathbb { E } | )$ , where $\\lvert \\mathbb { E } \\rvert$ is the number of edges and $m$ is the order of Chebyshev polynomials. We give the details of the approximation proposed in Hammond et al. (2011). ",
+        "bbox": [
+            174,
+            150,
+            825,
+            207
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "With the stable recurrence relation $T _ { k } ( y ) = 2 y T _ { k - 1 } ( y ) - T _ { k - 2 } ( y )$ , we can generate the Chebyshev polynomials $T _ { k } ( y )$ . Here $T _ { 0 } = 1$ and $T _ { 1 } = y$ . For $y$ sampled between $^ { - 1 }$ and 1, the trigonometric expression $T _ { k } ( y ) = c o s ( k a r c c o s ( y ) )$ is satisfied. It shows that $T _ { k } ( y ) \\in [ - 1 , 1 ]$ when $y \\in [ - 1 , 1 ]$ . Through the Chebyshev polynomials, an orthogonal basis for the Hilbert space of square integrable functions $L ^ { 2 } ( [ - 1 , 1 ] , \\frac { d y } { \\sqrt { 1 - y ^ { 2 } } } )$ is formed. For each $h$ in this Hilbert space, we have a uniformly convergent Chebyshev series $\\begin{array} { r } { h ( y ) = \\frac { 1 } { 2 } c _ { 0 } + \\sum _ { k = 1 } ^ { \\infty } c _ { k } T _ { k } ( y ) } \\end{array}$ , and the Chebyshev coefficients $c _ { k } =$ $\\begin{array} { r } { \\frac { 2 } { \\pi } \\int _ { - 1 } ^ { 1 } \\frac { T _ { k } ( y ) h ( y ) } { \\sqrt { 1 - y ^ { 2 } } } d y = \\frac { 2 } { \\pi } \\int _ { 0 } ^ { \\pi } c o s ( k \\theta ) h ( \\bar { c o s } ( \\theta ) ) d \\theta } \\end{array}$ . A fixed scale $s$ is assumed. To approximate $g ( s x )$ for $x \\in [ 0 , \\lambda _ { m a x } ]$ , we can shift the domain through the transformation $x = a ( y + 1 ) $ , where $a =$ $\\frac { \\lambda _ { m a x } } { 2 }$ $\\begin{array} { r } { T _ { k } ^ { \\prime } ( x ) = T _ { k } ( \\frac { x - a } { a } ) } \\end{array}$ e shif, and , $\\frac { x - a } { a } \\in [ - 1 , 1 ]$ . $\\begin{array} { r } { g ( s x ) = \\frac { 1 } { 2 } c _ { 0 } + \\sum _ { k = 1 } ^ { \\infty } c _ { k } T _ { k } ^ { \\prime } ( x ) } \\end{array}$ $x \\in [ 0 , \\lambda _ { m a x } ]$ $\\begin{array} { r } { c _ { k } = \\frac { 2 } { \\pi } \\int _ { 0 } ^ { \\pi } c o s ( k \\theta ) g ( s ( a ( c o s ( \\theta ) + 1 ) ) ) d \\theta } \\end{array}$ we truncate the Chebyshev expansion to $m$ terms and achieve Polynomial approximation. ",
+        "bbox": [
+            173,
+            213,
+            825,
+            395
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "sgive the fast approximation wavelets by Here we give the example of the $\\psi _ { s } ^ { - 1 }$ and $\\begin{array} { r } { \\psi _ { s } ^ { - 1 } \\pmb { f } ^ { \\prime } = \\frac { 1 } { 2 } c _ { 0 } \\pmb { f } + \\sum _ { k = 1 } ^ { m } c _ { k } \\tilde { T _ { k } ^ { \\prime } } ( \\pmb { L } ) \\pmb { f } } \\end{array}$ $g ( s x ) = e ^ { - s x }$ , the graph signal is . The efficient compu- $\\pmb { f } \\in R ^ { n }$ . Then we can tation of $T _ { k } ^ { \\prime } ( { \\pmb { L } } )$ determines the utility of this approach, where $\\begin{array} { r } { T _ { k } ^ { \\prime } ( L ) \\dag = \\frac { 2 } { a } ( L - \\pmb { I } ) ( T _ { k - 1 } ^ { \\prime } ( L ) \\pmb { f } ) - } \\end{array}$ $T _ { k - 2 } ^ { \\prime } ( { \\pmb { L } } ) f$ . ",
+        "bbox": [
+            173,
+            400,
+            825,
+            462
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX E ANALYSIS ON SPASITY OF SPECTRAL TRANSFORM AND LAPLACIAN MATRIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            481,
+            756,
+            515
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The sparsity of the graph wavelets depends on the sparsity of the Laplacian matrix and the hyperparameter $s$ , We show the sparsity of spectral transform matrix and Laplacian matrix in Table 6. ",
+        "bbox": [
+            171,
+            530,
+            823,
+            559
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/766f9b8ab3931be049c017c6559748ef27c69445d22629dd37dc23d433d61e67.jpg",
+        "table_caption": [
+            "Table 6: Statistics of spectral transform and Laplacian matrix on Cora "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Density</td><td>NumofNon-zeroElements</td></tr><tr><td>wavelettransform</td><td>2.8%</td><td>205,774</td></tr><tr><td>Fouriertransform</td><td>99.1%</td><td>7,274,383</td></tr><tr><td>Laplacian matrix</td><td>0.15%</td><td>10,858</td></tr></table>",
+        "bbox": [
+            297,
+            593,
+            694,
+            648
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The sparsity of Laplacian matrix is sparser than graph wavelets, and this property limits our method, i.e., the higher time complexity than some methods depending on Laplacian matrix and identity matrix, e.g., GCN. Specifically, both our method and GCN aim to improve Spectral CNN via designing localized graph convolution. GCN, as a simplified version of ChebyNet, leverages Laplacian matrix as weighted matrix and expresses the spectral graph convolution in spatial domain, acting as spatial-like method (Monti et al., 2017). However, our method resorts to using graph wavelets as a new set of bases, directly designing localized spectral graph convolution. GWNN offers a localized graph convolution via replacing graph Fourier transform with graph wavelet transform, finding good spectral basis with localization property and good interpretability. This distinguishes GWNN from ChebyNet and GCN, which express the graph convolution defined via graph Fourier transform in vertex domain. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            815
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HShLSEcVZJ4/HShLSEcVZJ4.md

@@ -0,0 +1,283 @@
+# Do Different Tracking Tasks Require Different Appearance Models?
+
+Zhongdao Wang1,2
+
+Hengshuang Zhao3,4
+
+Ya-Li Li1,2
+
+Shengjin Wang1,2∗
+
+Philip H.S. Torr3
+
+Luca Bertinetto5
+
+1Beijing National Research Center for Information Science and Technology (BNRist) 2Department of Electronic Engineering, Tsinghua University 3Torr Vision Group, University of Oxford 4The University of Hong Kong 5Five AI
+
+https://zhongdao.github.io/UniTrack
+
+# Abstract
+
+Tracking objects of interest in a video is one of the most popular and widely applicable problems in computer vision. However, with the years, a Cambrian explosion of use cases and benchmarks has fragmented the problem in a multitude of different experimental setups. As a consequence, the literature has fragmented too, and now novel approaches proposed by the community are usually specialised to fit only one specific setup. To understand to what extent this specialisation is necessary, in this work we present UniTrack, a solution to address five different tasks within the same framework. UniTrack consists of a single and task-agnostic appearance model, which can be learned in a supervised or self-supervised fashion, and multiple “heads” that address individual tasks and do not require training. We show how most tracking tasks can be solved within this framework, and that the same appearance model can be successfully used to obtain results that are competitive against specialised methods for most of the tasks considered. The framework also allows us to analyse appearance models obtained with the most recent self-supervised methods, thus extending their evaluation and comparison to a larger variety of important problems.
+
+# 1 Introduction
+
+Unlike popular image-based computer vision tasks such as classification and object detection, which are (for the most part) unambiguous and clearly defined, the problem of object tracking has been considered under different setups and scenarios, each motivating the design of a separate set of benchmarks and methods. For instance, for the Single Object Tracking (SOT) and Video Object Segmentation (VOS) communities [70, 29, 48], tracking means estimating the location of an arbitrary user-annotated target object throughout a video, where the location of the object is represented by a bounding box in SOT and by a pixel-wise mask in VOS. Instead, in multiple object tracking settings (MOT [41], MOTS [57] and PoseTrack [2]), tracking means connecting sets of (often given) detections across video frames to address the problem of identity association and forming trajectories. Despite these tasks only differing in the number of objects per frame to consider and observation format (bounding boxes, keypoints or masks), the best practices developed by the methods tackling them vary significantly.
+
+Though the proliferation of setups, benchmarks and methods is positive in that it allows specific use cases to be thoroughly studied, we argue it makes increasingly harder to effectively study one of the fundamental problems that all these tasks have in common, i.e. what constitutes a good representation to track objects throughout a video? Recent advancements in large-scale models for language [15, 6] and vision [24, 10] have suggested that a strong representation can help addressing multiple downstream tasks. Similarly, we speculate that a good representation is likely to benefit many different tracking tasks, regardless of their specific setup. In order to validate our speculation, in this paper we present a framework that allows to adopt the same appearance model to address five different tracking tasks (Figure 2). In our taxonomy (Figure 4), we consider existing tracking tasks as problems that have either propagation or association at their core. When the core problem is propagation (as in SOT and VOS), one has to localise a target object in the current frame given its location in the previous one. Instead, in association problems (MOT, MOTS, and PoseTrack), target states in both previous and current frames are given, and the goal is to determine the correspondence between the two sets of observations. We show how most tracking tasks currently considered by the community can be simply expressed starting from the primitives of propagation or association. For propagation tasks, we employ existing box and mask propagation algorithms [5, 61, 58]. For association tasks, we propose a novel reconstruction-based metric that leverages fine-grained correspondence to measure similarities between observations. In the proposed framework, each individual task is assigned to a dedicated “head” that allows to represent the object(s) in the appropriate format to compare against prior arts on the relevant benchmarks.
+
+Note that, in our framework, only the appearance model contains parameters that can be learned via back-propagation, and that we do not experiment with appearance models that have been trained on specific tracking tasks. Instead, we adopt models trained via recent self-supervised learning (SSL) techniques and that have already demonstrated their effectiveness on a variety of image-based tasks. Our motivation is twofold. First, SSL models are particularly interesting for our use-case, as they are explicitly conceived to be of general purpose. As a byproduct, our work also serves the purpose of evaluating and comparing appearance models obtained from self-supervised learning approaches (see Figure 1). Second, we hope to facilitate the tracking community in directly benefiting from the rapid advancements of the self-supervised learning literature.
+
+To summarise, the contributions of our work are as follows:
+
+• We propose UniTrack, a framework that supports five tracking tasks: SOT [70], VOS [48], MOT [41], MOTS [57], and PoseTrack [2]; and that can be easily extended to new ones. • We show how UniTrack can leverage many existing general-purpose appearance models to achieve a performance that is competitive with the state-of-the-art on several tracking tasks. • We propose a novel reconstruction-based similarity metric for association that preserves fine-grained visual features and supports multiple observation formats (box, mask and pose). • We perform an extensive evaluation of self-supervised models, significantly extending the empirical analysis of prior literature to video-based tasks.
+
+# 2 The UniTrack Framework
+
+# 2.1 Overview
+
+Inspecting existing tracking tasks and benchmarks, we noticed that their differences can be roughly categorised across four axes, illustrated in Figure 2 and detailed below.
+
+1. Whether the requirement is to track a single object (SOT [70, 29], VOS [48]), or multiple objects (MOT [48], MOTS [57], PoseTrack [2]).   
+2. Whether the targets are specified by a user in the first frame only (SOT, VOS), or instead are given in every frame, e.g. by a pre-trained detector (MOT, MOTS, PoseTrack).   
+3. Whether the target objects are represented by bounding-boxes (SOT, MOT), pixel-wise masks (VOS, MOTS) or pose annotations (PoseTrack).   
+4. Whether the task is class-agnostic, i.e. the target objects can be of any class (SOT, VOS); or if instead they are from a predefined set of classes (MOT, MOTS, PoseTrack).
+
+![](images/973edc595a191507bf2aea6445c5996ec93f72ddb0e88f26b36898a37c68af52.jpg)  
+Figure 1: High-level overview of the performance of sixteen self-supervised learning models on five tracking tasks: SOT, VOS, MOT, PoseTracking and MOTS. A higher rank (better performance) corresponds to a vertex nearer to the outer circle. A larger area of the pentagon signifies better overall performance of its respective appearance model. Results of a vanilla ImageNet-supervised model are indicated with a gray dashed line as reference. Notice how the best model VFS [74] dominates on four out of the five tasks considered.
+
+![](images/bbb9bbd4ea2617640f93f785e04a83089c4d9e40003bce1b4598c8efce9b5721.jpg)  
+Figure 2: Existing tracking problems and their respective benchmarks differ from each other under several aspects: the assumption could be that there is a single or multiple objects to track; targets can be specified by the user in the first frame only, or assumed to be given at every frame (e.g. provided by a detector); the classes of the targets can be known (classspecific) or unknown (class-agnostic); the representation of the targets can be bounding boxes, pixel-wise masks, or pose annotations.
+
+![](images/3e4c1d7a0a214e23bfae3bfd3eb4d0f1e7cffa401be4de9a82fa1cb0dbdbfff7.jpg)  
+Figure 3: Overview of UniTrack. The framework can be divided in three levels. Level-1: a trainable appearance model. Level-2: the fundamental primitives of propagation and association. Level-3: task-specific heads.
+
+Typically, in single-object tasks the target is specified by the user in the first frame, and it can be of any class. Instead, for multi-object tasks detections are generally considered as given for every frame, and the main challenge is to solve identity association for the several objects. Moreover, in multi-object tasks the set of classes to address is generally known (e.g. pedestrians or cars).
+
+Figure 3 depicts a schematic overview of the proposed UniTrack framework, which can be understood as conceptually divided in three “levels”. The first level is represented by the appearance model, responsible for extracting high-resolution feature maps from the input frame (Section 2.2). The second level consists of the algorithmic primitives addressing propagation (Section 2.3) and association (Section 2.4). Finally, the last level comprises multiple task-specific algorithms that make direct use of the primitives of the second level. In this work, we illustrate how UniTrack can be used to obtain competitive performance on all of the five tracking tasks of level-3 from Figure 3. Moreover, new tracking tasks can be easily integrated.
+
+Importantly, note that the appearance model is the only component containing trainable parameters. The reason we opted for a shared and non task-specific representation is twofold. Firstly, the large amount of different setups motivated us to investigate whether having separately-trained models for each setup is necessary. Since training on specific datasets can bias the representation towards a limited set of visual concepts (e.g. animals or vehicles) and limit its applicability to “open-world” settings, we wanted to understand how far can a shared representation go. Second, we wanted to provide the community with multiple baselines that can be used to better assess newly proposed contributions, and that can be immediately used on new datasets and tasks without the need of retraining.
+
+![](images/c9435ea1ecca12f41b32445059642d2821ee0a2c6e98ee2db02ea1a012fc3958.jpg)  
+Figure 4: Propagation v.s. Association. In the propagation problem, the goal is to estimate the target state at the current frame given the observation in the previous one. This is typically addressed for one object at the time. In the association problem, observations in both previous and current frames are given, and the goal is to determine correspondences between the two sets.
+
+# 2.2 Base appearance model
+
+The base appearance model $\phi$ takes as input a 2D image $I$ and outputs a feature map $X = \phi ( I ) \in$ $\mathbb { R } ^ { H \times W \times C }$ . Since ideally an appearance model used for object propagation and association should be able to leverage fine-grained semantic correspondences between images, we choose a network with a small stride of $r = 8$ , so that its output in feature space can have a relatively large resolution.
+
+We refer to the vector (along the channel dimension) of a single point in the feature map as a point vector. We expect a point vector $x _ { 1 } ^ { i } \in \mathbb { R } ^ { C }$ from the feature map $X _ { 1 }$ to have a high similarity with its “true match” point vector $x _ { 2 } ^ { \hat { i } }$ in $X _ { 2 }$ , while being far apart from all the other point vectors $x _ { 2 } ^ { j }$ in $X _ { 2 }$ ; i.e. we expect $s ( x _ { 1 } ^ { i } , x _ { 2 } ^ { \hat { i } } ) > s ( x _ { 1 } ^ { i } , x _ { 2 } ^ { j } ) , \forall j \neq \hat { i }$ , where $s ( \cdot , \cdot )$ represents a similarity function.
+
+In order to learn fine-grained correspondences, fully-supervised methods are only amenable for synthetic datasets (e.g. Flying Chairs for optical flow [16]). With real-world data, it is intractable to label pixel-level correspondences and train models in a fully-supervised fashion. To overcome this obstacle, in this paper we adopt representations obtained with self-supervision. We experiment both with models trained with approaches that leverage pixel-wise pretext tasks [27, 58] and, inspired by prior works that have pointed out how fine-grained correspondences emerge in middle-level features [39, 74], with models obtained from image-level tasks (e.g. MoCo [24], SimCLR [10]).
+
+# 2.3 Propagation
+
+Problem definition. Figure 4a schematically illustrates the problem of propagation, which we use as a primitive to address SOT and VOS tasks. Considering the single-object case, given video frames $\{ I _ { t } \} _ { t = 1 } ^ { T }$ and an initial ground truth observation $z _ { 1 }$ as input, the goal is to predict object states $\{ \hat { z } _ { t } \} _ { t = 2 } ^ { T }$ for each time-step $t$ . In this work we consider three formats to represent objects: bounding boxes, segmentation masks and pose skeletons.
+
+Mask propagation. In order to propagate masks, we rely on the approach popularised by recent video self-supervised methods [27, 58, 35, 31]. Consider the feature maps of a pair of consecutive frames $X _ { t - 1 }$ and $X _ { t }$ , both $\in \mathbb { R } ^ { s \times C }$ , and the label mask $z _ { t - 1 } \in [ 0 , 1 ] ^ { s }$ of the previous frame 2, where $s = H \times W$ indicates its spatial resolution. We compute the matrix of transitions $K _ { t - 1 } ^ { t } = [ k _ { i , j } ] _ { s \times s }$ as the affinity matrix between $X _ { t - 1 }$ and $X _ { t }$ . Each element $k _ { i , j }$ is defined as
+
+$$
+k _ { i , j } = \mathrm { S o f t m a x } ( X _ { t - 1 } , X _ { t } ^ { \top } ; \tau ) _ { i j } = \frac { \exp ( \left. x _ { t - 1 } ^ { i } , x _ { t } ^ { j } \right. / \tau ) } { \sum _ { k } ^ { s } \exp ( \left. x _ { t - 1 } ^ { i } , x _ { t } ^ { k } \right. / \tau ) } ,
+$$
+
+where $\langle \cdot , \cdot \rangle$ indicates inner product, and $\tau$ is a temperature hyperparameter. As in [27], we only keep the top $K$ values for each row and set other values to zero. Then, the mask for the current frame at time $t$ is predicted by propagating the previous prediction: $z _ { t } = K _ { t - 1 } ^ { t } z _ { t - 1 }$ . Mask propagation proceeds in a recurrent fashion: the output mask of the current frame is used as input for the next one.
+
+Pose propagation. In order to represent pose keypoints, we use the widely adopted Gaussian belief maps [66]. For a keypoint $p$ , we obtain a belief map $z ^ { p } \in [ 0 , 1 ] ^ { s }$ by using a Gaussian with mean equal to the keypoint’s location and variance proportional to the subject’s body size. In order to propagate a pose, we can then individually propagate each belief map in the same manner as mask propagation, again as $z _ { t } ^ { p } = K _ { t - 1 } ^ { t } z _ { t - 1 } ^ { p }$ .
+
+Box propagation. The position of an object can also be more simply expressed with a fourdimensional vector ${ z = ( u , v , w , h ) }$ , where $( u , v )$ are the coordinates of the bounding-box center, and $( w , h )$ are its width and height. While one could reuse the strategy adopted above by simply converting the bounding-box to a pixel-wise mask, we observed that using this strategy leads to inaccurate predictions. Instead, we use the approach of SiamFC [5], which consists in performing cross-correlation (XCORR) between the target template $z _ { t - 1 }$ and the frame $X _ { t }$ to find the new location of the target in frame $t$ . Cross-correlation is performed at different scales, so that the bounding-box representation can be resized accordingly. We also provide a Correlation Filter-based alternative (DCF) [54, 61] (see Appendix B.1).
+
+# 2.4 Association
+
+Problem definition. Figure 4b schematically illustrates the association problem, which we use as primitive to address the tasks of MOT, MOTS and PoseTrack. In this case, observations for object states $\{ \hat { \mathcal { Z } } _ { t } \} _ { t = 1 } ^ { T }$ are given for all the frames $\{ I _ { t } \} _ { t = 1 } ^ { T }$ , typically via the output of a pre-trained detector. The goal here is to form trajectories by connecting observations across adjacent frames according to their identity.
+
+Association algorithm. We adopt the association algorithm proposed in JDE [65] for MOT, MOTS and PoseTrack tasks, of which detailed description can be found in Appendix C.1. In summary, we compute an $N \times M$ distance matrix between $N$ already-existing tracklets and $M$ “new” detections from the last processed frame. We then use the Hungarian algorithm [30] to determine pairs of matches between tracklets and detections, using the distance matrix as input. To obtain the matrix of distances used by the algorithm, we compute the linear combination of two terms accounting for motion and appearance cues. For the former, we compute a matrix indicating how likely a detection corresponds to the object state predicted by a Kalman Filter [28]. Instead, the appearance component is directly computed by using feature-map representations obtained by processing individual frames with the appearance model (Section 2.2). While object-level features for box and mask observations can be directly obtained by cropping frame-level feature maps, when an object is represented via a pose it first needs to be converted to a mask (via a procedure described in Appendix C.2).
+
+A key issue of this scenario is how to measure similarities between object-level features. We find existing methods limited. First, objects are often compared by computing the cosine similarity of average-pooled object-level feature maps [84, 51]. However, the operation of average inherently discards local information, which is important for fine-grained recognition. Approaches [18, 52] that instead to some extent do preserve fine-grained information, such as those computing the cosine similarity of (flattened) feature maps, do not support objects with differently-sized representation (situation that occurs for instance with pixel-level masks). To cope with the above limitations, we propose a reconstruction-based similarity metric that is able to deal with different observation formats, while still preserving fine-grained information.
+
+Reconstruction Similarity Metric (RSM). Let $\{ t _ { i } \} _ { i = 1 } ^ { N }$ denote the object-level features of $N$ existing tracklets, $t _ { i } \in \mathbb { R } ^ { s _ { t _ { i } } \times C }$ and $s _ { t _ { i } }$ indicates the spatial size of the object, i.e. the area of the box or the mask representing it. Similarly, $\{ d _ { j } \} _ { j = 1 } ^ { M }$ denotes the object-level features of $M$ new detections. With the goal of computing similarities to obtain an $N \times M$ affinity matrix to feed to the Hungarian algorithm, we propose a novel reconstruction-based similarity metric (RSM) between pairs $( i , j )$ , which is obtained as
+
+$$
+\mathrm { R S M } ( i , j ) = \frac { 1 } { 2 } ( \cos ( t _ { i } , \hat { t } _ { i  j } ) + \cos ( d _ { j } , \hat { d } _ { j  i } ) ) ,
+$$
+
+where $\hat { t } _ { i  j }$ represents $t _ { i }$ reconstructed from $d _ { j }$ and $\hat { d } _ { j  i }$ represents $d _ { j }$ reconstructed from $t _ { i }$ . In multi-object tracking scenarios, observations are often incomplete due to frequent occlusions. As such, directly comparing features between incomplete and complete observations often fails because of misalignment between local features. Suppose $d _ { j }$ is a detection feature representing a severely occluded pedestrian, while $t _ { i }$ a tracklet feature representing the same person, but unoccluded. Likely, directly computing the cosine similarity between the two will not be very telling. RSM addresses this issue by introducing a step of reconstruction after which the co-occurring parts of point features will be better aligned, thus making the final similarity more likely to be meaningful.
+
+![](images/3c0778a55532a316c020ae1fcced1a6dd69ef2502728dd8706e449a49e823e1a.jpg)  
+Figure 5: Reconstruction Similarity Metric (RSM): First, object-level features of existing tracklets and current detections are flattened and concatenated. Then, an affinity matrix between the two feature sets is computed. For a pair of tracklet $t _ { i }$ and detection $d _ { j }$ , we “extract” the corresponding sub-matrix from the entire affinity matrix as linear weights and reconstruct $t _ { i }$ from $d _ { j }$ using these linear weights. The similarity between the original object-level feature and its reconstructed version is finally taken as the RSM. We want the metric to be symmetric, so we perform reconstruction both forward $( t _ { i }  d _ { j }$ ) and backward $( t _ { i } \to d _ { j }$ ).
+
+The reconstructed object-level feature map $\hat { t } _ { i  j }$ is a simple linear transformation of $d _ { j }$ , i.e. $\hat { t } _ { i  j } = R _ { i  j } d _ { j }$ , where $R _ { i  j } \in \mathbb { R } ^ { s _ { t _ { i } } \times s _ { d _ { j } } }$ is a transformation matrix obtained as follows. We first flatten and concatenate all object-level features belonging to a tracklet (i.e. the set of observations corresponding to an object) into a single feature matrix $\begin{array} { r } { { \cal T } ~ \in ~ \mathbb { R } ^ { ( \sum _ { i } s _ { t _ { i } } ) \times C } } \end{array}$ . Similarly, we obtain all the object-level feature maps of a new set of detections $\begin{array} { r } { D \in \mathbb { R } ^ { ( \sum _ { j } s _ { d _ { j } } ) \times C } } \end{array}$ . Then, we compute the affinity matrix $A = \mathrm { S o f f m a x } ( T D ^ { \top } )$ and “extract” individual $R _ { i  j }$ map$A$ propriate . For a sc $( i , j )$ tracklet-detection pair: tic representation of the p $R _ { i  j } =$ $\begin{array} { r } { A \left[ \sum _ { i ^ { \prime } = 1 } ^ { i - 1 } s _ { i ^ { \prime } } : \sum _ { i ^ { \prime } = 1 } ^ { i } s _ { i ^ { \prime } } , \sum _ { j ^ { \prime } = 1 } ^ { j - 1 } s _ { j ^ { \prime } } : \sum _ { j ^ { \prime } = 1 } ^ { j } s _ { j ^ { \prime } } \right] } \end{array}$   
+just described, see Figure 5.
+
+RSM can be interpreted from an attention [55] perspective. The feature map of a tracklet $t _ { i }$ being reconstructed can be seen as a set of queries, and the “source” detection feature $d _ { j }$ can be interpreted both as keys and values. The goal is to reconstruct the queries by linear combination of the values. The linear combination (attention) weights are computed using the affinity between queries and keys. Specifically, we first compute a global affinity matrix between $t _ { i }$ and all the $d _ { j ^ { \prime } }$ for $j ^ { \prime } = 1 , . . . , M$ , and then extract the corresponding sub-matrix for $t _ { i }$ and $d _ { j ^ { \prime } }$ as the attention weights. Our formulation leads to a desired property: if the attention weights approach zero, the corresponding reconstructed point vectors will approach zero and so the RSM between $t _ { i }$ and $d _ { j }$ .
+
+Measuring similarity by reconstruction is popular in problems such as few-shot learning [67, 80], self-supervised learning [38], and person re-identification [26]. However, reconstruction is typically framed as a ridge regression or optimal transport problem. With $O ( n ^ { 2 } )$ complexity, RSM is more efficient than ridge regression and it has a similar computation cost to calculating the Earth Moving Distance for the optimal transport problem. Appendix D shows a series of ablation studies illustrating the importance of the proposed RSM for the effectiveness of UniTrack on association-type tasks.
+
+# 3 Experiments
+
+Since UniTrack does not require task-specific training, we were able to experiment with many alternative appearance models (see Figure 3) with little computational cost. In Section 3.1 we perform an extensive evaluation to benchmark a wide variety of off-the-shelf, modern self-supervised models, showing their strengths and weaknesses on all five tasks considered. In this section we also conduct a correlation study with the so-called “linear probe” strategy [81], which became a popular way to evaluate representations obtained with self-supervised learning. Then, in Section 3.2 we compare UniTrack (equipped with supervised or unsupervised appearance models) against recent and task-specific tracking methods.
+
+Implementation details. We use ResNet-18 [25] or ResNet-50 as the default architecture. With ImageNet-supervised appearance model, we refer to the ImageNet pre-trained weights made available in PyTorch’s “Model Zoo”. To prevent excessive downsampling, we modify the spatial stride of layer3 and layer4 to 1, achieving a total stride of $r = 8$ . We extract features from both layer3 and layer4. We report results with layer3 features when comparing against task-specific methods (Section 3.2), and with both layer3 and layer4 when evaluating multiple different representations (Section 3.1). Further implementation details are deferred to Appendix B and C.
+
+Datasets and evaluation metrics. For fair comparison with existing methods, we report results on standard benchmarks with conventional metrics for each task. Please refer to Appendix A for details.
+
+# 3.1 UniTrack as evaluation platform of previously-learned representations
+
+The process of evaluating representations obtained via self-supervised learning (SSL) often involves additional training [17, 24, 10], for instance via the use of linear probes [81], which require to fix the pre-trained model and train an additional linear classifier on top of it. In contrast, using UniTrack as evaluation platform (1) does not require any additional training and (2) enables the evaluation on a battery of important video tasks, which have generally been neglected in self-supervised-learning papers in favour of more established image-level tasks such as classification.
+
+In this section, we evaluate three types of SSL representations: (a) Image-level representations learned from images, e.g. MoCo [24] and BYOL [21]; (b) Pixel-level representations learned from images (such as DetCo [72] and PixPro [73]) and (c) videos (such as UVC [35] and CRW [27]). For all methods considered, we use the pre-trained weights provided by the authors.
+
+Results are shown in Table 1 and 2, where we report the results obtained by using features from either layer3 or layer4 of the pre-trained ResNet backbone. We report both results and separate them by a $\cdot / { \cdot }$ in the table. Note that, for this analysis only, for association-type tasks motion cues are discarded to better highlight distinctions between different representations and avoid potential confounding factors. Figure 1 provides a high-level summary of the results by focusing on the ranking obtained by different SSL methods on the five tasks considered (each represented by a vertex in the radar-style plot). Several observations can be made:
+
+(1) There is no significant correlation between “linear probe accuracy” on ImageNet and overall tracking performance. The linear probe approach [81] has become a standard way to compare SSL representations. In Figure 6, we plot tracking performance on five tasks (y-axes) against ImageNet top-1 accuracy of 16 different models ( $\mathbf { \dot { X } }$ -axes), and report Pearson and Spearman (rank) correlation coefficients. We observe that the correlation between ImageNet accuracy and tracking performance is small, i.e. the Pearson’s $r$ ranges from $- 0 . 3 8$ to $+ 0 . 2 0$ , and Spearman’s $\rho$ ranges from $- 0 . 3 6$ to $+ 0 . 2 6$ . For most tasks, there is almost no correlation, while for VOS the two measures are mildly inversely correlated. The result suggests that evaluating SSL models on five extra tasks with UniTrack could constitute a useful complement to ImageNet linear probe evaluation, and encourage the SSL community to pursue the design of even more general purpose representations.
+
+(2) A vanilla ImageNet-trained supervised representation is surprisingly effective across the board. On most tasks, it reports a performance competitive with the best representation for that task. This is particularly evident from Figure 1, where its performance is outlined as a gray dashed line. This result suggests that results obtained with vanilla ImageNet features should be reported when investigating new tracking methods.
+
+(3) The best self-supervised representation ranks first on most tasks. Recently, it has been shown how SSL-trained representations can match or surpass their supervised counterparts on ImageNet classification (e.g. [21]) and many downstream tasks [17, 72]. Within UniTrack, although no individual SSL representation is able to beat the vanilla ImageNet-trained representation on every single task, we observe that the recently proposed VFS [74] ranks first on every task, except for single-object tracking. This suggests that advancements of the self-supervised learning literature can directly benefit the tracking community: it is reasonable to expect that newly-proposed representations will further improve performance across the board.
+
+<table><tr><td rowspan="2">Representation</td><td colspan="2">SOT [70]</td><td>VOS [48]</td><td colspan="2">MOT [41]</td><td colspan="2">MOTS [57]</td><td colspan="2">PoseTrack [2]</td></tr><tr><td>AUCxCorr ↑</td><td>AUCDCF ↑</td><td>J-mean↑</td><td>IDF1个</td><td>HOTA↑</td><td>IDF1个</td><td>HOTA↑</td><td>IDF1个</td><td>IDs↓</td></tr><tr><td>Random Init.</td><td>10.3 /9.0</td><td>28.0 /20.0</td><td>29.3 /33.9</td><td>8.4/8.9</td><td>8.4/8.5</td><td>20.8 / 23.1</td><td>25.9 / 28.7</td><td>40.2 /38.5</td><td>88792/90963</td></tr><tr><td>ImageNet-sup.</td><td>58.6/49.5</td><td>62.0 / 53.9</td><td>62.3/57.9</td><td>75.6/73.2</td><td>63.3/ 61.8</td><td>68.4 /69.4</td><td>70.2/71.0</td><td>73.7/73.3</td><td>6969/7103</td></tr><tr><td>InsDis [71]</td><td>47.6 /47.3</td><td>61.8 / 51.1</td><td>62.6/ 60.1</td><td>66.7 /73.9</td><td>57.9 / 61.9</td><td>68.4 /68.0</td><td>69.6 /70.3</td><td>72.4 /73.9</td><td>7106 /7015</td></tr><tr><td>MoCoV1 [24]</td><td>50.9 /47.9</td><td>62.2/53.7</td><td>61.5 / 57.9</td><td>69.2 /74.1</td><td>59.4 / 61.9</td><td>70.6/ 69.3</td><td>71.6/70.9</td><td>72.8 / 739</td><td>6872/7092</td></tr><tr><td>PCLV1[34]</td><td>56.8/31.5</td><td>61.3/35.0</td><td>60.4/38.8</td><td>74.8/68.8</td><td>62.8 / 59.1</td><td>67.6 / 65.2</td><td>69.7 / 67.3</td><td>73.3 / 71.1</td><td>6855/10694</td></tr><tr><td>PIRL [42]</td><td>43.8 / 51.0</td><td>61.2 / 53.4</td><td>60.8/57.7</td><td>62.0 /73.4</td><td>54.6 / 61.9</td><td>66.0 / 67.4</td><td>66.7 /69.9</td><td>72.1/73.0</td><td>7235/7173</td></tr><tr><td>PCLV2 [34]</td><td>54.9/50.3</td><td>62.5 /51.6</td><td>61.2/52.5</td><td>74.9 /72.9</td><td>62.7/ 61.8</td><td>68.3/66.6</td><td>70.5/69.0</td><td>73.5/73.4</td><td>6859/ 8489</td></tr><tr><td>SimCLRV1[10]</td><td>47.3 / 51.9</td><td>61.3 / 50.7</td><td>60.5 /56.5</td><td>66.9 / 75.6</td><td>57.7 / 63.2</td><td>65.8 / 67.6</td><td>67.7 /69.5</td><td>72.3 /73.5</td><td>7084 /7367</td></tr><tr><td>MoCoV2 [12]</td><td>53.7 /47.2</td><td>61.5 /53.3</td><td>61.2 /54.0</td><td>72.0 / 74.9</td><td>61.2 / 62.8</td><td>67.5 /67.3</td><td>69.6 / 69.6</td><td>73.0 /73.7</td><td>6932 /7702</td></tr><tr><td>SimCLRV2[11]</td><td>50.0 / 54.7</td><td>61.7 /56.8</td><td>61.6 /58.4</td><td>67.6/75.7</td><td>58.1/ 63.3</td><td>69.1 / 67.4</td><td>70.4 / 69.4</td><td>72.5 /73.6</td><td>7228/7856</td></tr><tr><td>SeLaV2 [3]</td><td>51.0/9.6</td><td>63.1/14.2</td><td>60.2/40.2</td><td>68.8/68.9</td><td>59.0 / 59.3</td><td>66.8/66.1</td><td>68.7/ 68.5</td><td>72.9 /72.3</td><td>6983/7815</td></tr><tr><td>Infomin [53]</td><td>48.5/46.8</td><td>61.2 / 51.9</td><td>58.4/51.1</td><td>66.7 /73.4</td><td>57.6/61.9</td><td>66.7/66.3</td><td>68.5/68.8</td><td>72.5 /74.0</td><td>7066/7901</td></tr><tr><td>BarLow [79]</td><td>44.5/55.5</td><td>60.5 /60.1</td><td>61.7 / 57.8</td><td>63.7/74.5</td><td>55.4/62.4</td><td>68.7/67.4</td><td>69.5/ 69.8</td><td>72.3 /74.3</td><td>7131/7456</td></tr><tr><td>BYOL [21]</td><td>48.3/55.5</td><td>58.9 /56.8</td><td>58.8 / 54.3</td><td>65.3 /74.9</td><td>56.8 / 62.9</td><td>70.1/ 66.8</td><td>70.8 /69.3</td><td>72.4 / 73.8</td><td>7213/8032</td></tr><tr><td>DeepCluster [7]</td><td>51.5 / 52.9</td><td>61.2/61.2</td><td>59.3/53.4</td><td>66.9 /75.1</td><td>57.8 / 63.5</td><td>67.7 /67.4</td><td>69.4 /69.8</td><td>72.7 /73.7</td><td>7018/7283</td></tr><tr><td>SwAV [8]</td><td>49.2/52.4 51.1/45.3</td><td>61.5 /59.4 60.3/43.8</td><td>59.4/57.0</td><td>65.6/74.4</td><td>56.9 / 62.3</td><td>68.8/67.0</td><td>69.9 /69.5</td><td>72.7 /73.6</td><td>7025 /7377</td></tr><tr><td>VFS [74]</td><td></td><td></td><td>62.8/56.8</td><td>74.1/ 77.0</td><td>62.6 / 63.9</td><td>71.0/ 68.0</td><td>72.1/70.4</td><td>73.3/74.2</td><td>6731/7091</td></tr><tr><td>PixPro [73]</td><td>40.5 /49.2</td><td>57.4 /49.3</td><td>56.4/52.2</td><td>61.7 /67.7</td><td>54.3/58.6</td><td>64.2/66.2</td><td>65.1/67.6</td><td>72.4 / 73.1</td><td>7163 /6953</td></tr><tr><td>DetCo [72]</td><td>55.0/47.1</td><td>59.0/53.2</td><td>62.3/56.1</td><td>75.3 /72.9</td><td>62.8/61.6</td><td>67.8/66.8</td><td>70.0 /69.4</td><td>73.9/73.3</td><td>7357/8009</td></tr><tr><td>TimeCycle [64]</td><td>43.8 / 24.2</td><td>57.5/48.7</td><td>51.8 / 48.9</td><td>68.7 / 28.2</td><td>59.3 /25.5</td><td>69.9 / 47.1</td><td>71.3 /49.3</td><td>72.0 / 62.3</td><td>7837 /27884</td></tr></table>
+
+Table 1: Tracking performance of pre-trained image-based SSL models. All methods employ a ResNet-50.   
+
+<table><tr><td rowspan="3">Representation</td><td colspan="2">SOT [70]</td><td>vOS [48]</td><td colspan="2">MOT [41]</td><td colspan="2">MOTS [57]</td><td colspan="2">PoseTrack [2]</td></tr><tr><td>AUCxcorr 个</td><td>AUCDcF ↑</td><td>J-mean↑</td><td>IDF1↑</td><td>HOTA↑</td><td>IDF1个</td><td>HOTA↑</td><td>IDF1个</td><td>IDs↓</td></tr><tr><td>Random Init.</td><td>16.0 /18.2</td><td>36.1/ 32.1</td><td>33.0 /36.7</td><td>18.4 / 14.6</td><td>20.2 / 12.9</td><td>34.5 /33.1</td><td>39.9 /37.6</td><td>52.8 / 50.5</td><td>65317 /66230</td></tr><tr><td>ImageNet-sup.</td><td>55.0/46.2</td><td>61.8 / 52.6</td><td>58.4/46.7</td><td>74.8 / 74.5</td><td>62.7 / 62.1</td><td>67.6/ 68.6</td><td>69.8 / 70.5</td><td>72.7 / 73.2</td><td>6808 /7024</td></tr><tr><td>Color.[58]+mem.</td><td>41.6 /43.4</td><td>56.7 /58.7</td><td>53.6 / 59.7</td><td>64.9 / 62.8</td><td>56.8/55.5</td><td>68.8/66.1</td><td>69.4 / 66.3</td><td>72.4 / 72.6</td><td>6850/6778</td></tr><tr><td>UVC [35]</td><td>46.0/38.7</td><td>58.1/59.9</td><td>56.5 / 53.9</td><td>66.9/64.5</td><td>57.7/54.1</td><td>69.9 / 68.7</td><td>69.6 / 69.4</td><td>72.6/72.8</td><td>6843/ 6972</td></tr><tr><td>CRW [27]</td><td>46.3/49.1</td><td>58.9 / 54.9</td><td>63.2/60.7</td><td>67.8/73.0</td><td>58.4 / 61.7</td><td>69.0/71.3</td><td>69.2/71.9</td><td>72.7 /73.0</td><td>6799/6761</td></tr></table>
+
+Table 2: Tracking performance of pre-trained video-based SSL models. All methods employ a ResNet-18. In the above two tables, we report results with [layer3 / layer4] features in each cell, and the best performance between the two is bolded. We use the bolded values to rank the models in each column, and visualise (column-wise) better performance with darker cell colors. Best results in each column are underlined.
+
+![](images/298e1349e66d64591ba9deb65f91e69066f5b3dd00510fe516e2e8e0efd32d1c.jpg)  
+Figure 6: Tracking performance is poorly correlated with ImageNet accuracy. On the $\mathbf { X }$ -axes we plot ImageNet linear probe top-1 accuracy and on the y-axes the tracking performance on five tracking datasets. Correlation coefficients (Spearman’s $\rho$ and Pearson’s $r$ ) are shown in the left bottom of each plot.
+
+(4) Pixel-level SSL representations do not seem to have a consistent advantage in pixel-level tasks. In Table 2 and at the bottom of Table 1 we compare recent SSL representations trained with pixellevel proxy tasks: PixPro [73], DetCo [72], TimeCycle [64], Colorization [58], UVC [35] and Contrastive Random Walk (CRW) [27]. Considering that pixel-level models leverage more finegrained information during training, one may expect them to outperform image-based models in the tracking tasks where this is important. It is not straightforward to compare pixel-level SSL models with image-level ones, as the two types employ different default backbone networks. However, note how good image-based models (MoCo-v1, SimCLR-v2) are on par with their supervised counterpart in all tasks, while good pixel-level models (DetCo, CRW) still have gaps with respect to their supervised counterparts in tasks like SOT and MOT. Moreover, from Table 1, one can notice how the last three rows, despite representing methods leveraging pixel-level information during training, are actually outperformed by image-level representations on the pixel-level tasks of VOS, MOTS and PoseTrack.
+
+(5) Video data can benefit representation learning for video tasks. The top-ranking VFS is similar to MoCo, SimCLR and BYOL in terms of learning scheme: they all perform contrastive learning on image level features. The most important distinction is the training data. Previous SSL methods mostly train on still-image based datasets (typically ImageNet), while VFS employs a large-scale video dataset Kinetics [9]. Clearly, this is not very surprising, as training on video data can help closing the domain gap with the (video-based) downstream tasks considered in this paper.
+
+<table><tr><td>Methods</td><td>IDF1个</td><td>IDs↓</td><td>MOTA↑</td><td>HOTA↑</td></tr><tr><td>JDE [65]</td><td>55.8</td><td>1544</td><td>64.4</td><td>-</td></tr><tr><td>CTracker [47]</td><td>57.2</td><td>1897</td><td>67.6</td><td>48.8</td></tr><tr><td>TubeTK[46]</td><td>62.2</td><td>1236</td><td>66.9</td><td>50.8</td></tr><tr><td>MAT [23]</td><td>63.8</td><td>928</td><td>73.5</td><td>56.3</td></tr><tr><td>TraDes [69]</td><td>64.7</td><td>1144</td><td>70.1</td><td>53.2</td></tr><tr><td>CSTrack [36]</td><td>71.8</td><td>1071</td><td>70.7</td><td>59.8</td></tr><tr><td>FairMOT† [82]</td><td>72.8</td><td>1074</td><td>74.9</td><td>61.6</td></tr><tr><td>UniTrack_ImageNet†</td><td>71.8</td><td>683</td><td>74.7</td><td>59.1</td></tr><tr><td>UniTrack_VFS†</td><td>70.3</td><td>829</td><td>72.7</td><td>58.6</td></tr></table>
+
+(a) MOT@MOT-16 [41] test split, private detection.
+
+(b) MOTS@MOTS [57] test split.   
+
+<table><tr><td>Methods</td><td>IDF1个</td><td>IDs↓</td><td>sMOTA↑</td></tr><tr><td>TrackRCNN [57]</td><td>42.4</td><td>567</td><td>40.6</td></tr><tr><td>SORTS [68]</td><td>57.3</td><td>577</td><td>55.0</td></tr><tr><td>PointTrack [76]</td><td>42.9</td><td>868</td><td>62.3</td></tr><tr><td>GMPHD [50]</td><td>65.6</td><td>566</td><td>69.0</td></tr><tr><td>COSTAt [1]</td><td>70.3</td><td>421</td><td>69.5</td></tr><tr><td>UniTrack_ImageNet†</td><td>67.2</td><td>622</td><td>68.9</td></tr><tr><td>UniTrack_VFSt</td><td>68.2</td><td>342</td><td>69.7</td></tr></table>
+
+Table 3: Comparison with task-tailored unsupervised and supervised methods on five typical tracking tasks. $\dagger$ indicates methods using identical observations.   
+
+<table><tr><td>Methods</td><td>IDF1个</td><td>IDs↓</td><td>MOTA↑</td></tr><tr><td>MDPN [22]</td><td>=</td><td>-</td><td>50.6</td></tr><tr><td>OpenSVAI [44]</td><td></td><td>-</td><td>62.4</td></tr><tr><td>Miracle [78]</td><td></td><td>=</td><td>64.0</td></tr><tr><td>KeyTrack [49]</td><td></td><td>-</td><td>66.6</td></tr><tr><td>TWVA [19]</td><td>=</td><td>=</td><td>64.7</td></tr><tr><td>LightTrack† [43]</td><td>52.2</td><td>3024</td><td>64.8</td></tr><tr><td>UniTrack_ImageNet†</td><td>73.2</td><td>6760</td><td>63.5</td></tr><tr><td>UniTrack_VFS†</td><td>74.2</td><td>7091</td><td>63.3</td></tr></table>
+
+(c) PoseTrack@PoseTrack2018 [2] val split.
+
+<table><tr><td>Methods</td><td>J-mean↑</td></tr><tr><td>Supervised:</td><td></td></tr><tr><td>SiamMask [62]</td><td>54.3</td></tr><tr><td>FEELVOS [56]</td><td>63.7</td></tr><tr><td>STM [45]</td><td>79.2</td></tr><tr><td>Unsupervised:</td><td></td></tr><tr><td>Colorization [58]</td><td>34.6</td></tr><tr><td>TimeCylce [64]</td><td>40.1</td></tr><tr><td>UVC [35]</td><td>56.7</td></tr><tr><td>CRW [27]</td><td>64.8</td></tr><tr><td>UniTrack_ImageNet</td><td>58.4</td></tr><tr><td>UniTrack_VFS</td><td>62.8</td></tr></table>
+
+(d) VOS@DAVIS-2017 [48].
+
+<table><tr><td>Methods</td><td>AUC↑</td></tr><tr><td>Supervised:</td><td></td></tr><tr><td>SiamFC[5]</td><td>58.2</td></tr><tr><td>SiamRPN [33]</td><td>63.7</td></tr><tr><td>SiamRPN++ [32]</td><td>69.6</td></tr><tr><td>Unsupervised:</td><td></td></tr><tr><td>UDT [59]</td><td>59.4</td></tr><tr><td>UDT+[59]</td><td>63.2</td></tr><tr><td>LUDT [60]</td><td>60.2</td></tr><tr><td>LUDT+ [60]</td><td>63.9</td></tr><tr><td>UniTrack_ImageNet_XCorr</td><td>55.5</td></tr><tr><td>UniTrack_ImageNet_DCF</td><td>61.8</td></tr><tr><td>UniTrack_VFS_DCF</td><td>60.3</td></tr></table>
+
+(e) SOT@OTB-2015 [70].
+
+# 3.2 Comparison with task-specific tracking methods
+
+Unsupervised methods. We observe that UniTrack performs competitively against unsupervised state-of-the-art methods in both the propagation-type tasks we considered (Table 3d and 3e). For SOT, UniTrack with a DCF head [61] outperforms UDT [59] (a strong recent method) by 2.4 AUC points, while it is surpassed by LUDT $^ +$ [60] by 2.1 points. Considering that LUDT $^ +$ adopts an additional online template update mechanism [13] while ours does not, we believe the gap could be closed. In VOS, existing unsupervised methods are usually trained on video datasets [35, 27], and some of the most recent outperform UniTrack (with an ImageNet-trained representation). Nonetheless, when we use a VFS-trained representation, this performance difference is reduced to $2 \%$ . Finally, note that for association-type tasks we are not aware of any existing unsupervised learning method, and thus in this case we limit the comparison to supervised methods.
+
+Comparison with supervised methods. In general, UniTrack with a ResNet-18 appearance model already performs on par with several existing task-specific supervised methods, and in several tasks it even shows superior accuracy, especially for identity-related metrics. (1) For SOT, UniTrack with a DCF head outperforms SiamFC [5] by 3.6 AUC points. This is a significant margin considering that SiamFC is trained with a large amount of crops from video datasets with annotated bounding boxes. (2) For VOS, UniTrack surpasses SiamMask [62] by 4.1 $\mathcal { I }$ -mean points, despite this being trained on the joint set of three large-scale video datasets [37, 14, 75]. (3) For MOT, we employ the same detections used by the state-of-the-art tracker FairMOT [82]. The appearance embedding in FairMOT is trained with 270K bounding boxes of 8.7K labeled identities, from a MOT-specific dataset. In contrast, despite our appearance model not being trained with any MOT-specific data, our IDF1 score is quite competitive (71.8 v.s. 72.8 of FairMOT), and the ID switches are considerably reduced by $3 6 . { \overset { - } { 4 } } \%$ , from 1074 to 683. (4) For MOTS, we start from the same segmentation masks used by the COSTA [1] tracker, and observe a degradation in terms of ID switches (622 vs the 421 of the state of the art), and also a gap in IDF1 and sMOTA. (5) Finally, for pose tracking, we employ the same pose estimator used by LightTrack [43]. Compared with LightTrack, the MOTA of UniTrack degrades of 1.3 points because of an increased amount of ID switches. However, the IDF-1 score is improved by a significant margin $( + 2 1 . 0 $ points). This shows UniTrack preserves identity more accurately for long tracklets: even if ID switches occur more frequently, after a short period UniTrack is able to correct the wrong association, leading to a higher IDF-1.
+
+Notice how, overall, UniTrack obtains more competitive performance on tasks that have association at their core, i.e. MOT, MOTS and PoseTrack. Upon inspection, we observed that most failure cases in propagation-type tasks regard the “drift” occurring when the scale of the object is improperly estimated. In future work, this could be addressed for instance by a bounding-box regression module to refine predictions, or by carefully designing a motion model. For association-type tasks, the consequences of any type of inaccuracy are isolated to individual pairs of frames, and thus much less catastrophic by nature.
+
+# 4 Related Work
+
+To the best of our knowledge, sharing the appearance model across multiple tracking tasks has not been extensively studied in the computer vision literature, and especially not in the context of SSL representations. Some existing methods do share a common backbone architecture across tasks. For instance, STEm-Seg [4] addresses VIS [77] and MOTS; while TraDeS [69] addresses MOT, MOTS and VIS. However, both methods need to be trained separately and on different datasets for every task. Conversely, we reuse the same representation across five tasks. A promising direction for future work would be to use UniTrack to train a shared representation in a multi-task fashion. Only a few relevant works do adopt a multi-task approach [62, 83, 40], and they usually consider SOT and VOS tasks only. In general, despite the multi-task direction being surely interesting, it requires the availability of large-scale datasets with annotations in multiple formats, and costly training. These are two of the main reasons for which we believe that having a framework that allows to achieve competitive performance on multiple tasks with previously-trained models is a worthwhile endeavour.
+
+Self-supervised model evaluation. Given the difference between the pretext tasks used to train self-supervised models and the downstream tasks used to evaluate them, the comparison between self-supervised approaches has always been a delicate matter. Existing evaluation strategies typically require additional training once a general-purpose representation has been obtained. One strategy keeps the representation fixed, and then trains additional task-specific heads with very limited capacity (e.g. a linear classifier [20, 10, 24] or a regression head for object detection [20]). A second strategy, instead, leverages SSL to obtain particularly effective initializations, and then proceeds to fine-tune such initialized models on the downstream task of interest. A wider range of tasks can be tested using this setup, such as semantic segmentation [17, 20] and surface normal estimation [20, 63]. In contrast, UniTrack provides a simpler way to evaluate SSL models, one that does not require additional training or fine-tuning. Also, this work is the first to extend SSL evaluation to a set of diverse video tasks. We believe this contribution will allow the study of self-supervised learning methods with a broader scope of applicability. Our work is also related to a line of self-supervised learning methods [27, 58, 35, 31] that learn their representations in a task-agnostic fashion, and then test it on propagation tasks (SOT and VOS). The design of UniTrack is inspired by their task-agnostic philosophy, while significantly extending their scope to a new set of tasks.
+
+# 5 Conclusion
+
+Do different tracking tasks require different appearance models? In order to address this question, the proposed UniTrack framework has been instrumental, as it has allowed to easily experiment with alternative representations on a wide variety of downstream problems. Although the answer is not a resounding “no”, as only sometimes a single shared appearance model can outperform dedicated methods, we argue that a unified framework is an appealing alternative to task-specific methods. The main reason is that it allows us to make the most of the progress made in the representation learning literature at no extra cost. With the rapid development of self-supervised learning, and the large amount of computational resources dedicated to it, we believe it is reasonable to expect that, in the future, a general-purpose representation will be able to outperform task-specific methods across the board. Until then, UniTrack could still serve as a useful evaluation tool for novel representations, especially considering the lack of correlation with the standard linear-probe approach. We believe this will encourage the community to develop self-supervised representations that are of “general purpose” in a broader sense.
+
+Broader impact. Upon reflection, we believe that progress in tracking applications and selfsupervised learning is beneficial for society, as it can significantly impact (for instance) the development of autonomous vehicles, which we consider a net positive for society. We also recognise that the same technologies could constitute a threat if deployed for surveillance by entities hostile to civil liberties.
+
+# 6 Funding Transparency Statement
+
+This work was supported by the National Natural Science Foundation of China under Grant No. 61771288, Cross-Media Intelligent Technology Project of Beijing National Research Center for Information Science and Technology (BNRist) under Grant No. BNR2019TD01022 and the research fund under Grant No. 2019GQG0001 from the Institute for Guo Qiang, Tsinghua University.
+
+This work was also supported by the EPSRC grant: Turing AI Fellowship: EP/W002981/1, EPSRC/MURI grant EP/N019474/1. We would also like to thank the Royal Academy of Engineering and FiveAI.
+
+# References
+
+[1] Costa_st tracker. https://motchallenge.net/method/MOTS 87&chl=17.   
+[2] Mykhaylo Andriluka, Umar Iqbal, Eldar Insafutdinov, Leonid Pishchulin, Anton Milan, Juergen Gall, and Bernt Schiele. Posetrack: A benchmark for human pose estimation and tracking. In CVPR, 2018.   
+[3] Yuki Markus Asano, Christian Rupprecht, and Andrea Vedaldi. Self-labelling via simultaneous clustering and representation learning. In ICLR, 2020.   
+[4] Ali Athar, Sabarinath Mahadevan, Aljoša Ošep, Laura Leal-Taixé, and Bastian Leibe. Stem-seg: Spatiotemporal embeddings for instance segmentation in videos. In ECCV, 2020.   
+[5] Luca Bertinetto, Jack Valmadre, Joao F Henriques, Andrea Vedaldi, and Philip HS Torr. Fully-convolutional siamese networks for object tracking. In ECCV workshops, 2016.   
+[6] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv:2005.14165, 2020.   
+[7] Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In ECCV, 2018.   
+[8] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. In NeurIPS, 2018.   
+[9] Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In CVPR, 2017.   
+[10] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. 2020.   
+[11] Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey Hinton. Big selfsupervised models are strong semi-supervised learners. arXiv:2006.10029, 2020.   
+[12] Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv:2003.04297, 2020.   
+[13] Martin Danelljan, Goutam Bhat, Fahad Shahbaz Khan, and Michael Felsberg. Eco: Efficient convolution operators for tracking. In CVPR, 2017.   
+[14] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.   
+[15] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. 2018.   
+[16] Alexey Dosovitskiy, Philipp Fischer, Eddy Ilg, Philip Hausser, Caner Hazirbas, Vladimir Golkov, Patrick Van Der Smagt, Daniel Cremers, and Thomas Brox. Flownet: Learning optical flow with convolutional networks. In ICCV, 2015.   
+[17] Linus Ericsson, Henry Gouk, and Timothy M Hospedales. How well do self-supervised models transfer? In CVPR, 2021.   
+[18] Masoud Faraki, Xiang Yu, Yi-Hsuan Tsai, Yumin Suh, and Manmohan Chandraker. Cross-domain similarity learning for face recognition in unseen domains. arXiv:2103.07503, 2021.   
+[19] Yang Fu, Sifei Liu, Umar Iqbal, Shalini De Mello, Humphrey Shi, and Jan Kautz. Learning to track instances without video annotations. In CVPR, 2021.   
+[20] Priya Goyal, Dhruv Mahajan, Abhinav Gupta, and Ishan Misra. Scaling and benchmarking self-supervised visual representation learning. arXiv:1905.01235, 2019.   
+[21] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv:2006.07733, 2020.   
+[22] Hengkai Guo, Tang Tang, Guozhong Luo, Riwei Chen, Yongchen Lu, and Linfu Wen. Multi-domain pose network for multi-person pose estimation and tracking. In ECCV, workshop, 2018.   
+[23] Shoudong Han, Piao Huang, Hongwei Wang, En Yu, Donghaisheng Liu, Xiaofeng Pan, and Jun Zhao. Mat: Motion-aware multi-object tracking. arXiv:2009.04794, 2020. visual representation learning. In CVPR, 2020.   
+[25] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   
+[26] Lingxiao He, Jian Liang, Haiqing Li, and Zhenan Sun. Deep spatial feature reconstruction for partial person re-identification: Alignment-free approach. In CVPR, 2018.   
+[27] Allan Jabri, Andrew Owens, and Alexei A Efros. Space-time correspondence as a contrastive random walk. In NeurIPS, 2020.   
+[28] Rudolph Emil Kalman. A new approach to linear filtering and prediction problems. 1960.   
+[29] Matej Kristan, Jiri Matas, Aleš Leonardis, Tomáš Vojíˇr, Roman Pflugfelder, Gustavo Fernandez, Georg Nebehay, Fatih Porikli, and Luka Cehovin. A novel performance evaluation methodology for single-target ˇ trackers. IEEE TPAMI, 2016.   
+[30] Harold W Kuhn. The hungarian method for the assignment problem. Naval research logistics quarterly, 2(1-2):83–97, 1955.   
+[31] Zihang Lai, Erika Lu, and Weidi Xie. Mast: A memory-augmented self-supervised tracker. In CVPR, 2020.   
+[32] Bo Li, Wei Wu, Qiang Wang, Fangyi Zhang, Junliang Xing, and Junjie Yan. Siamrpn $^ { + + }$ : Evolution of siamese visual tracking with very deep networks. In CVPR, 2019.   
+[33] Bo Li, Junjie Yan, Wei Wu, Zheng Zhu, and Xiaolin Hu. High performance visual tracking with siamese region proposal network. In CVPR, 2018.   
+[34] Junnan Li, Pan Zhou, Caiming Xiong, Richard Socher, and Steven CH Hoi. Prototypical contrastive learning of unsupervised representations. In ICLR, 2021.   
+[35] Xueting Li, Sifei Liu, Shalini De Mello, Xiaolong Wang, Jan Kautz, and Ming-Hsuan Yang. Joint-task self-supervised learning for temporal correspondence. In NeurIPS, 2019.   
+[36] Chao Liang, Zhipeng Zhang, Yi Lu, Xue Zhou, Bing Li, Xiyong Ye, and Jianxiao Zou. Rethinking the competition between detection and reid in multi-object tracking. arXiv:2010.12138, 2020.   
+[37] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ECCV, 2014.   
+[38] Songtao Liu, Zeming Li, and Jian Sun. Self-emd: Self-supervised object detection without imagenet. arXiv:2011.13677, 2020.   
+[39] Jonathan Long, Ning Zhang, and Trevor Darrell. Do convnets learn correspondence? In NeurIPS, 2014.   
+[40] Alan Lukezic, Jiri Matas, and Matej Kristan. D3s-a discriminative single shot segmentation tracker. In CVPR, 2020.   
+[41] Anton Milan, Laura Leal-Taixé, Ian Reid, Stefan Roth, and Konrad Schindler. Mot16: A benchmark for multi-object tracking. arXiv:1603.00831, 2016.   
+[42] Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In CVPR, 2020.   
+[43] Guanghan Ning and Heng Huang. Lighttrack: A generic framework for online top-down human pose tracking. In CVPR, workshop, 2020.   
+[44] Guanghan Ning, Ping Liu, Xiaochuan Fan, and Chi Zhang. A top-down approach to articulated human pose estimation and tracking. In ECCV, workshop, 2018.   
+[45] Seoung Wug Oh, Joon-Young Lee, Ning Xu, and Seon Joo Kim. Video object segmentation using space-time memory networks. In ICCV, 2019.   
+[46] Bo Pang, Yizhuo Li, Yifan Zhang, Muchen Li, and Cewu Lu. Tubetk: Adopting tubes to track multi-object in a one-step training model. In CVPR, 2020.   
+[47] Jinlong Peng, Changan Wang, Fangbin Wan, Yang Wu, Yabiao Wang, Ying Tai, Chengjie Wang, Jilin Li, Feiyue Huang, and Yanwei Fu. Chained-tracker: Chaining paired attentive regression results for end-to-end joint multiple-object detection and tracking. In ECCV, 2020.   
+[48] F. Perazzi, J. Pont-Tuset, B. McWilliams, L. Van Gool, M. Gross, and A. Sorkine-Hornung. A benchmark dataset and evaluation methodology for video object segmentation. In CVPR, 2016.   
+[49] Michael Snower, Asim Kadav, Farley Lai, and Hans Peter Graf. 15 keypoints is all you need. In CVPR, 2020.   
+[50] Young-min Song and Moongu Jeon. Online multi-object tracking and segmentation with gmphd filter and simple affinity fusion. arXiv:2009.00100, 2020.   
+[51] Yifan Sun, Qin Xu, Yali Li, Chi Zhang, Yikang Li, Shengjin Wang, and Jian Sun. Perceive where to focus: Learning visibility-aware part-level features for partial person re-identification. In CVPR, 2019.   
+[52] Yifan Sun, Liang Zheng, Yi Yang, Qi Tian, and Shengjin Wang. Beyond part models: Person retrieval with refined part pooling (and a strong convolutional baseline). In ECCV, 2018.   
+[53] Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning. In NeurIPS, 2020.   
+[54] Jack Valmadre, Luca Bertinetto, Joao Henriques, Andrea Vedaldi, and Philip HS Torr. End-to-end representation learning for correlation filter based tracking. In CVPR, 2017.   
+[55] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017.   
+[56] Paul Voigtlaender, Yuning Chai, Florian Schroff, Hartwig Adam, Bastian Leibe, and Liang-Chieh Chen. Feelvos: Fast end-to-end embedding learning for video object segmentation. In CVPR, 2019.   
+[57] Paul Voigtlaender, Michael Krause, Aljosa Osep, Jonathon Luiten, Berin Balachandar Gnana Sekar, Andreas Geiger, and Bastian Leibe. Mots: Multi-object tracking and segmentation. In CVPR, 2019.   
+[58] Carl Vondrick, Abhinav Shrivastava, Alireza Fathi, Sergio Guadarrama, and Kevin Murphy. Tracking emerges by colorizing videos. In ECCV, 2018.   
+[59] Ning Wang, Yibing Song, Chao Ma, Wengang Zhou, Wei Liu, and Houqiang Li. Unsupervised deep tracking. In CVPR, 2019.   
+[60] Ning Wang, Wengang Zhou, Yibing Song, Chao Ma, Wei Liu, and Houqiang Li. Unsupervised deep representation learning for real-time tracking. IJCV, 2020.   
+[61] Qiang Wang, Jin Gao, Junliang Xing, Mengdan Zhang, and Weiming Hu. Dcfnet: Discriminant correlation filters network for visual tracking. arXiv:1704.04057, 2017.   
+[62] Qiang Wang, Li Zhang, Luca Bertinetto, Weiming Hu, and Philip HS Torr. Fast online object tracking and segmentation: A unifying approach. In CVPR, 2019.   
+[63] Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In ICCV, 2015.   
+[64] Xiaolong Wang, Allan Jabri, and Alexei A Efros. Learning correspondence from the cycle-consistency of time. In CVPR, 2019.   
+[65] Zhongdao Wang, Liang Zheng, Yixuan Liu, and Shengjin Wang. Towards real-time multi-object tracking. In ECCV, 2020.   
+[66] Shih-En Wei, Varun Ramakrishna, Takeo Kanade, and Yaser Sheikh. Convolutional pose machines. In CVPR, 2016.   
+[67] Davis Wertheimer, Luming Tang, and Bharath Hariharan. Fine-grained few-shot classification with feature map reconstruction networks. CVPR, 2021.   
+[68] Nicolai Wojke, Alex Bewley, and Dietrich Paulus. Simple online and realtime tracking with a deep association metric. In ICIP, 2017.   
+[69] Jialian Wu, Jiale Cao, Liangchen Song, Yu Wang, Ming Yang, and Junsong Yuan. Track to detect and segment: An online multi-object tracker. In CVPR, 2021.   
+[70] Yi Wu, Jongwoo Lim, and Ming-Hsuan Yang. Online object tracking: A benchmark. In CVPR, 2013.   
+[71] Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via non-parametric instance discrimination. In CVPR, 2018.   
+[72] Enze Xie, Jian Ding, Wenhai Wang, Xiaohang Zhan, Hang Xu, Zhenguo Li, and Ping Luo. Detco: Unsupervised contrastive learning for object detection. arXiv:2102.04803, 2021.   
+[73] Zhenda Xie, Yutong Lin, Zheng Zhang, Yue Cao, Stephen Lin, and Han Hu. Propagate yourself: Exploring pixel-level consistency for unsupervised visual representation learning. In CVPR, 2021.   
+[74] Jiarui Xu and Xiaolong Wang. Rethinking self-supervised correspondence learning: A video frame-level similarity perspective. arXiv:2103.17263, 2021.   
+[75] Ning Xu, Linjie Yang, Yuchen Fan, Jianchao Yang, Dingcheng Yue, Yuchen Liang, Brian Price, Scott Cohen, and Thomas Huang. Youtube-vos: Sequence-to-sequence video object segmentation. In ECCV, 2018.   
+[76] Zhenbo Xu, Wei Zhang, Xiao Tan, Wei Yang, Huan Huang, Shilei Wen, Errui Ding, and Liusheng Huang. Segment as points for efficient online multi-object tracking and segmentation. In ECCV, 2020.   
+[77] Linjie Yang, Yuchen Fan, and Ning Xu. Video instance segmentation. In ICCV, 2019.   
+[78] Dongdong Yu, Kai Su, Jia Sun, and Changhu Wang. Multi-person pose estimation for pose tracking with enhanced cascaded pyramid network. In ECCV, workshop, 2018.   
+[79] Jure Zbontar, Li Jing, Ishan Misra, Yann LeCun, and Stéphane Deny. Barlow twins: Self-supervised learning via redundancy reduction. arXiv:2103.03230, 2021.   
+[80] Chi Zhang, Yujun Cai, Guosheng Lin, and Chunhua Shen. Deepemd: Few-shot image classification with differentiable earth mover’s distance and structured classifiers. In CVPR, 2020.   
+[81] Richard Zhang, Phillip Isola, and Alexei A Efros. Split-brain autoencoders: Unsupervised learning by cross-channel prediction. In CVPR, 2017.   
+[82] Yifu Zhang, Chunyu Wang, Xinggang Wang, Wenjun Zeng, and Wenyu Liu. Fairmot: On the fairness of detection and re-identification in multiple object tracking. arXiv:2004.01888, 2020.   
+[83] Zhipeng Zhang, Bing Li, Weiming Hu, and Houweng Peng. Towards accurate pixel-wise object tracking by attention retrieval. arXiv:2008.02745, 2020.   
+[84] Kuan Zhu, Haiyun Guo, Zhiwei Liu, Ming Tang, and Jinqiao Wang. Identity-guided human semantic parsing for person re-identification. In ECCV, 2020.

parse/train/HShLSEcVZJ4/HShLSEcVZJ4_content_list.json

@@ -0,0 +1,1103 @@
+[
+    {
+        "type": "text",
+        "text": "Do Different Tracking Tasks Require Different Appearance Models? ",
+        "text_level": 1,
+        "bbox": [
+            274,
+            122,
+            723,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zhongdao Wang1,2 ",
+        "bbox": [
+            240,
+            224,
+            375,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hengshuang Zhao3,4 ",
+        "bbox": [
+            442,
+            224,
+            589,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ya-Li Li1,2 ",
+        "bbox": [
+            673,
+            224,
+            751,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shengjin Wang1,2∗ ",
+        "bbox": [
+            251,
+            253,
+            382,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Philip H.S. Torr3 ",
+        "bbox": [
+            459,
+            253,
+            580,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Luca Bertinetto5 ",
+        "bbox": [
+            647,
+            253,
+            766,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Beijing National Research Center for Information Science and Technology (BNRist) 2Department of Electronic Engineering, Tsinghua University 3Torr Vision Group, University of Oxford 4The University of Hong Kong 5Five AI ",
+        "bbox": [
+            220,
+            275,
+            779,
+            347
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "https://zhongdao.github.io/UniTrack ",
+        "bbox": [
+            348,
+            361,
+            648,
+            376
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            411,
+            535,
+            428
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tracking objects of interest in a video is one of the most popular and widely applicable problems in computer vision. However, with the years, a Cambrian explosion of use cases and benchmarks has fragmented the problem in a multitude of different experimental setups. As a consequence, the literature has fragmented too, and now novel approaches proposed by the community are usually specialised to fit only one specific setup. To understand to what extent this specialisation is necessary, in this work we present UniTrack, a solution to address five different tasks within the same framework. UniTrack consists of a single and task-agnostic appearance model, which can be learned in a supervised or self-supervised fashion, and multiple “heads” that address individual tasks and do not require training. We show how most tracking tasks can be solved within this framework, and that the same appearance model can be successfully used to obtain results that are competitive against specialised methods for most of the tasks considered. The framework also allows us to analyse appearance models obtained with the most recent self-supervised methods, thus extending their evaluation and comparison to a larger variety of important problems. ",
+        "bbox": [
+            233,
+            440,
+            766,
+            661
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            685,
+            310,
+            702
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unlike popular image-based computer vision tasks such as classification and object detection, which are (for the most part) unambiguous and clearly defined, the problem of object tracking has been considered under different setups and scenarios, each motivating the design of a separate set of benchmarks and methods. For instance, for the Single Object Tracking (SOT) and Video Object Segmentation (VOS) communities [70, 29, 48], tracking means estimating the location of an arbitrary user-annotated target object throughout a video, where the location of the object is represented by a bounding box in SOT and by a pixel-wise mask in VOS. Instead, in multiple object tracking settings (MOT [41], MOTS [57] and PoseTrack [2]), tracking means connecting sets of (often given) detections across video frames to address the problem of identity association and forming trajectories. Despite these tasks only differing in the number of objects per frame to consider and observation format (bounding boxes, keypoints or masks), the best practices developed by the methods tackling them vary significantly. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            881
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Though the proliferation of setups, benchmarks and methods is positive in that it allows specific use cases to be thoroughly studied, we argue it makes increasingly harder to effectively study one of the fundamental problems that all these tasks have in common, i.e. what constitutes a good representation to track objects throughout a video? Recent advancements in large-scale models for language [15, 6] and vision [24, 10] have suggested that a strong representation can help addressing multiple downstream tasks. Similarly, we speculate that a good representation is likely to benefit many different tracking tasks, regardless of their specific setup. In order to validate our speculation, in this paper we present a framework that allows to adopt the same appearance model to address five different tracking tasks (Figure 2). In our taxonomy (Figure 4), we consider existing tracking tasks as problems that have either propagation or association at their core. When the core problem is propagation (as in SOT and VOS), one has to localise a target object in the current frame given its location in the previous one. Instead, in association problems (MOT, MOTS, and PoseTrack), target states in both previous and current frames are given, and the goal is to determine the correspondence between the two sets of observations. We show how most tracking tasks currently considered by the community can be simply expressed starting from the primitives of propagation or association. For propagation tasks, we employ existing box and mask propagation algorithms [5, 61, 58]. For association tasks, we propose a novel reconstruction-based metric that leverages fine-grained correspondence to measure similarities between observations. In the proposed framework, each individual task is assigned to a dedicated “head” that allows to represent the object(s) in the appropriate format to compare against prior arts on the relevant benchmarks. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            367
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that, in our framework, only the appearance model contains parameters that can be learned via back-propagation, and that we do not experiment with appearance models that have been trained on specific tracking tasks. Instead, we adopt models trained via recent self-supervised learning (SSL) techniques and that have already demonstrated their effectiveness on a variety of image-based tasks. Our motivation is twofold. First, SSL models are particularly interesting for our use-case, as they are explicitly conceived to be of general purpose. As a byproduct, our work also serves the purpose of evaluating and comparing appearance models obtained from self-supervised learning approaches (see Figure 1). Second, we hope to facilitate the tracking community in directly benefiting from the rapid advancements of the self-supervised learning literature. ",
+        "bbox": [
+            173,
+            373,
+            825,
+            498
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarise, the contributions of our work are as follows: ",
+        "bbox": [
+            174,
+            505,
+            565,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose UniTrack, a framework that supports five tracking tasks: SOT [70], VOS [48], MOT [41], MOTS [57], and PoseTrack [2]; and that can be easily extended to new ones. • We show how UniTrack can leverage many existing general-purpose appearance models to achieve a performance that is competitive with the state-of-the-art on several tracking tasks. • We propose a novel reconstruction-based similarity metric for association that preserves fine-grained visual features and supports multiple observation formats (box, mask and pose). • We perform an extensive evaluation of self-supervised models, significantly extending the empirical analysis of prior literature to video-based tasks. ",
+        "bbox": [
+            217,
+            530,
+            826,
+            660
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 The UniTrack Framework ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            426,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Overview ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            717,
+            279,
+            731
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Inspecting existing tracking tasks and benchmarks, we noticed that their differences can be roughly categorised across four axes, illustrated in Figure 2 and detailed below. ",
+        "bbox": [
+            176,
+            742,
+            823,
+            771
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. Whether the requirement is to track a single object (SOT [70, 29], VOS [48]), or multiple objects (MOT [48], MOTS [57], PoseTrack [2]).   \n2. Whether the targets are specified by a user in the first frame only (SOT, VOS), or instead are given in every frame, e.g. by a pre-trained detector (MOT, MOTS, PoseTrack).   \n3. Whether the target objects are represented by bounding-boxes (SOT, MOT), pixel-wise masks (VOS, MOTS) or pose annotations (PoseTrack).   \n4. Whether the task is class-agnostic, i.e. the target objects can be of any class (SOT, VOS); or if instead they are from a predefined set of classes (MOT, MOTS, PoseTrack). ",
+        "bbox": [
+            210,
+            782,
+            825,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/973edc595a191507bf2aea6445c5996ec93f72ddb0e88f26b36898a37c68af52.jpg",
+        "image_caption": [
+            "Figure 1: High-level overview of the performance of sixteen self-supervised learning models on five tracking tasks: SOT, VOS, MOT, PoseTracking and MOTS. A higher rank (better performance) corresponds to a vertex nearer to the outer circle. A larger area of the pentagon signifies better overall performance of its respective appearance model. Results of a vanilla ImageNet-supervised model are indicated with a gray dashed line as reference. Notice how the best model VFS [74] dominates on four out of the five tasks considered. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            88,
+            823,
+            241
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/bbb9bbd4ea2617640f93f785e04a83089c4d9e40003bce1b4598c8efce9b5721.jpg",
+        "image_caption": [
+            "Figure 2: Existing tracking problems and their respective benchmarks differ from each other under several aspects: the assumption could be that there is a single or multiple objects to track; targets can be specified by the user in the first frame only, or assumed to be given at every frame (e.g. provided by a detector); the classes of the targets can be known (classspecific) or unknown (class-agnostic); the representation of the targets can be bounding boxes, pixel-wise masks, or pose annotations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            330,
+            599,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e4c1d7a0a214e23bfae3bfd3eb4d0f1e7cffa401be4de9a82fa1cb0dbdbfff7.jpg",
+        "image_caption": [
+            "Figure 3: Overview of UniTrack. The framework can be divided in three levels. Level-1: a trainable appearance model. Level-2: the fundamental primitives of propagation and association. Level-3: task-specific heads. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            624,
+            356,
+            818,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Typically, in single-object tasks the target is specified by the user in the first frame, and it can be of any class. Instead, for multi-object tasks detections are generally considered as given for every frame, and the main challenge is to solve identity association for the several objects. Moreover, in multi-object tasks the set of classes to address is generally known (e.g. pedestrians or cars). ",
+        "bbox": [
+            174,
+            648,
+            825,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 depicts a schematic overview of the proposed UniTrack framework, which can be understood as conceptually divided in three “levels”. The first level is represented by the appearance model, responsible for extracting high-resolution feature maps from the input frame (Section 2.2). The second level consists of the algorithmic primitives addressing propagation (Section 2.3) and association (Section 2.4). Finally, the last level comprises multiple task-specific algorithms that make direct use of the primitives of the second level. In this work, we illustrate how UniTrack can be used to obtain competitive performance on all of the five tracking tasks of level-3 from Figure 3. Moreover, new tracking tasks can be easily integrated. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Importantly, note that the appearance model is the only component containing trainable parameters. The reason we opted for a shared and non task-specific representation is twofold. Firstly, the large amount of different setups motivated us to investigate whether having separately-trained models for each setup is necessary. Since training on specific datasets can bias the representation towards a limited set of visual concepts (e.g. animals or vehicles) and limit its applicability to “open-world” settings, we wanted to understand how far can a shared representation go. Second, we wanted to provide the community with multiple baselines that can be used to better assess newly proposed contributions, and that can be immediately used on new datasets and tasks without the need of retraining. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9435ea1ecca12f41b32445059642d2821ee0a2c6e98ee2db02ea1a012fc3958.jpg",
+        "image_caption": [
+            "Figure 4: Propagation v.s. Association. In the propagation problem, the goal is to estimate the target state at the current frame given the observation in the previous one. This is typically addressed for one object at the time. In the association problem, observations in both previous and current frames are given, and the goal is to determine correspondences between the two sets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            87,
+            772,
+            185
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            272,
+            825,
+            314
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 Base appearance model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            332,
+            377,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The base appearance model $\\phi$ takes as input a 2D image $I$ and outputs a feature map $X = \\phi ( I ) \\in$ $\\mathbb { R } ^ { H \\times W \\times C }$ . Since ideally an appearance model used for object propagation and association should be able to leverage fine-grained semantic correspondences between images, we choose a network with a small stride of $r = 8$ , so that its output in feature space can have a relatively large resolution. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            415
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We refer to the vector (along the channel dimension) of a single point in the feature map as a point vector. We expect a point vector $x _ { 1 } ^ { i } \\in \\mathbb { R } ^ { C }$ from the feature map $X _ { 1 }$ to have a high similarity with its “true match” point vector $x _ { 2 } ^ { \\hat { i } }$ in $X _ { 2 }$ , while being far apart from all the other point vectors $x _ { 2 } ^ { j }$ in $X _ { 2 }$ ; i.e. we expect $s ( x _ { 1 } ^ { i } , x _ { 2 } ^ { \\hat { i } } ) > s ( x _ { 1 } ^ { i } , x _ { 2 } ^ { j } ) , \\forall j \\neq \\hat { i }$ , where $s ( \\cdot , \\cdot )$ represents a similarity function. ",
+        "bbox": [
+            173,
+            420,
+            825,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to learn fine-grained correspondences, fully-supervised methods are only amenable for synthetic datasets (e.g. Flying Chairs for optical flow [16]). With real-world data, it is intractable to label pixel-level correspondences and train models in a fully-supervised fashion. To overcome this obstacle, in this paper we adopt representations obtained with self-supervision. We experiment both with models trained with approaches that leverage pixel-wise pretext tasks [27, 58] and, inspired by prior works that have pointed out how fine-grained correspondences emerge in middle-level features [39, 74], with models obtained from image-level tasks (e.g. MoCo [24], SimCLR [10]). ",
+        "bbox": [
+            173,
+            489,
+            825,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Propagation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            604,
+            299,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Problem definition. Figure 4a schematically illustrates the problem of propagation, which we use as a primitive to address SOT and VOS tasks. Considering the single-object case, given video frames $\\{ I _ { t } \\} _ { t = 1 } ^ { T }$ and an initial ground truth observation $z _ { 1 }$ as input, the goal is to predict object states $\\{ \\hat { z } _ { t } \\} _ { t = 2 } ^ { T }$ for each time-step $t$ . In this work we consider three formats to represent objects: bounding boxes, segmentation masks and pose skeletons. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Mask propagation. In order to propagate masks, we rely on the approach popularised by recent video self-supervised methods [27, 58, 35, 31]. Consider the feature maps of a pair of consecutive frames $X _ { t - 1 }$ and $X _ { t }$ , both $\\in \\mathbb { R } ^ { s \\times C }$ , and the label mask $z _ { t - 1 } \\in [ 0 , 1 ] ^ { s }$ of the previous frame 2, where $s = H \\times W$ indicates its spatial resolution. We compute the matrix of transitions $K _ { t - 1 } ^ { t } = [ k _ { i , j } ] _ { s \\times s }$ as the affinity matrix between $X _ { t - 1 }$ and $X _ { t }$ . Each element $k _ { i , j }$ is defined as ",
+        "bbox": [
+            173,
+            707,
+            825,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6792461fd2bfb639a1b2d8c133224b2e10957e2ef46de96891a8eed5b93fbc54.jpg",
+        "text": "$$\nk _ { i , j } = \\mathrm { S o f t m a x } ( X _ { t - 1 } , X _ { t } ^ { \\top } ; \\tau ) _ { i j } = \\frac { \\exp ( \\left. x _ { t - 1 } ^ { i } , x _ { t } ^ { j } \\right. / \\tau ) } { \\sum _ { k } ^ { s } \\exp ( \\left. x _ { t - 1 } ^ { i } , x _ { t } ^ { k } \\right. / \\tau ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            786,
+            684,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\langle \\cdot , \\cdot \\rangle$ indicates inner product, and $\\tau$ is a temperature hyperparameter. As in [27], we only keep the top $K$ values for each row and set other values to zero. Then, the mask for the current frame at time $t$ is predicted by propagating the previous prediction: $z _ { t } = K _ { t - 1 } ^ { t } z _ { t - 1 }$ . Mask propagation proceeds in a recurrent fashion: the output mask of the current frame is used as input for the next one. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            885
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pose propagation. In order to represent pose keypoints, we use the widely adopted Gaussian belief maps [66]. For a keypoint $p$ , we obtain a belief map $z ^ { p } \\in [ 0 , 1 ] ^ { s }$ by using a Gaussian with mean equal to the keypoint’s location and variance proportional to the subject’s body size. In order to propagate a pose, we can then individually propagate each belief map in the same manner as mask propagation, again as $z _ { t } ^ { p } = K _ { t - 1 } ^ { t } z _ { t - 1 } ^ { p }$ . ",
+        "bbox": [
+            174,
+            92,
+            825,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Box propagation. The position of an object can also be more simply expressed with a fourdimensional vector ${ z = ( u , v , w , h ) }$ , where $( u , v )$ are the coordinates of the bounding-box center, and $( w , h )$ are its width and height. While one could reuse the strategy adopted above by simply converting the bounding-box to a pixel-wise mask, we observed that using this strategy leads to inaccurate predictions. Instead, we use the approach of SiamFC [5], which consists in performing cross-correlation (XCORR) between the target template $z _ { t - 1 }$ and the frame $X _ { t }$ to find the new location of the target in frame $t$ . Cross-correlation is performed at different scales, so that the bounding-box representation can be resized accordingly. We also provide a Correlation Filter-based alternative (DCF) [54, 61] (see Appendix B.1). ",
+        "bbox": [
+            173,
+            166,
+            825,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 Association ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            308,
+            292,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Problem definition. Figure 4b schematically illustrates the association problem, which we use as primitive to address the tasks of MOT, MOTS and PoseTrack. In this case, observations for object states $\\{ \\hat { \\mathcal { Z } } _ { t } \\} _ { t = 1 } ^ { T }$ are given for all the frames $\\{ I _ { t } \\} _ { t = 1 } ^ { T }$ , typically via the output of a pre-trained detector. The goal here is to form trajectories by connecting observations across adjacent frames according to their identity. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            405
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Association algorithm. We adopt the association algorithm proposed in JDE [65] for MOT, MOTS and PoseTrack tasks, of which detailed description can be found in Appendix C.1. In summary, we compute an $N \\times M$ distance matrix between $N$ already-existing tracklets and $M$ “new” detections from the last processed frame. We then use the Hungarian algorithm [30] to determine pairs of matches between tracklets and detections, using the distance matrix as input. To obtain the matrix of distances used by the algorithm, we compute the linear combination of two terms accounting for motion and appearance cues. For the former, we compute a matrix indicating how likely a detection corresponds to the object state predicted by a Kalman Filter [28]. Instead, the appearance component is directly computed by using feature-map representations obtained by processing individual frames with the appearance model (Section 2.2). While object-level features for box and mask observations can be directly obtained by cropping frame-level feature maps, when an object is represented via a pose it first needs to be converted to a mask (via a procedure described in Appendix C.2). ",
+        "bbox": [
+            174,
+            411,
+            825,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A key issue of this scenario is how to measure similarities between object-level features. We find existing methods limited. First, objects are often compared by computing the cosine similarity of average-pooled object-level feature maps [84, 51]. However, the operation of average inherently discards local information, which is important for fine-grained recognition. Approaches [18, 52] that instead to some extent do preserve fine-grained information, such as those computing the cosine similarity of (flattened) feature maps, do not support objects with differently-sized representation (situation that occurs for instance with pixel-level masks). To cope with the above limitations, we propose a reconstruction-based similarity metric that is able to deal with different observation formats, while still preserving fine-grained information. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            708
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Reconstruction Similarity Metric (RSM). Let $\\{ t _ { i } \\} _ { i = 1 } ^ { N }$ denote the object-level features of $N$ existing tracklets, $t _ { i } \\in \\mathbb { R } ^ { s _ { t _ { i } } \\times C }$ and $s _ { t _ { i } }$ indicates the spatial size of the object, i.e. the area of the box or the mask representing it. Similarly, $\\{ d _ { j } \\} _ { j = 1 } ^ { M }$ denotes the object-level features of $M$ new detections. With the goal of computing similarities to obtain an $N \\times M$ affinity matrix to feed to the Hungarian algorithm, we propose a novel reconstruction-based similarity metric (RSM) between pairs $( i , j )$ , which is obtained as ",
+        "bbox": [
+            174,
+            713,
+            825,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/24c056e18a46adb1271334380cc817197b43c775b5f64436f41bc8408ecbb292.jpg",
+        "text": "$$\n\\mathrm { R S M } ( i , j ) = \\frac { 1 } { 2 } ( \\cos ( t _ { i } , \\hat { t } _ { i  j } ) + \\cos ( d _ { j } , \\hat { d } _ { j  i } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            803,
+            656,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { t } _ { i  j }$ represents $t _ { i }$ reconstructed from $d _ { j }$ and $\\hat { d } _ { j  i }$ represents $d _ { j }$ reconstructed from $t _ { i }$ . In multi-object tracking scenarios, observations are often incomplete due to frequent occlusions. As such, directly comparing features between incomplete and complete observations often fails because of misalignment between local features. Suppose $d _ { j }$ is a detection feature representing a severely occluded pedestrian, while $t _ { i }$ a tracklet feature representing the same person, but unoccluded. Likely, directly computing the cosine similarity between the two will not be very telling. RSM addresses this issue by introducing a step of reconstruction after which the co-occurring parts of point features will be better aligned, thus making the final similarity more likely to be meaningful. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c0778a55532a316c020ae1fcced1a6dd69ef2502728dd8706e449a49e823e1a.jpg",
+        "image_caption": [
+            "Figure 5: Reconstruction Similarity Metric (RSM): First, object-level features of existing tracklets and current detections are flattened and concatenated. Then, an affinity matrix between the two feature sets is computed. For a pair of tracklet $t _ { i }$ and detection $d _ { j }$ , we “extract” the corresponding sub-matrix from the entire affinity matrix as linear weights and reconstruct $t _ { i }$ from $d _ { j }$ using these linear weights. The similarity between the original object-level feature and its reconstructed version is finally taken as the RSM. We want the metric to be symmetric, so we perform reconstruction both forward $( t _ { i }  d _ { j }$ ) and backward $( t _ { i } \\to d _ { j }$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            89,
+            709,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            356,
+            825,
+            398
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The reconstructed object-level feature map $\\hat { t } _ { i  j }$ is a simple linear transformation of $d _ { j }$ , i.e. $\\hat { t } _ { i  j } = R _ { i  j } d _ { j }$ , where $R _ { i  j } \\in \\mathbb { R } ^ { s _ { t _ { i } } \\times s _ { d _ { j } } }$ is a transformation matrix obtained as follows. We first flatten and concatenate all object-level features belonging to a tracklet (i.e. the set of observations corresponding to an object) into a single feature matrix $\\begin{array} { r } { { \\cal T } ~ \\in ~ \\mathbb { R } ^ { ( \\sum _ { i } s _ { t _ { i } } ) \\times C } } \\end{array}$ . Similarly, we obtain all the object-level feature maps of a new set of detections $\\begin{array} { r } { D \\in \\mathbb { R } ^ { ( \\sum _ { j } s _ { d _ { j } } ) \\times C } } \\end{array}$ . Then, we compute the affinity matrix $A = \\mathrm { S o f f m a x } ( T D ^ { \\top } )$ and “extract” individual $R _ { i  j }$ map$A$ propriate . For a sc $( i , j )$ tracklet-detection pair: tic representation of the p $R _ { i  j } =$ $\\begin{array} { r } { A \\left[ \\sum _ { i ^ { \\prime } = 1 } ^ { i - 1 } s _ { i ^ { \\prime } } : \\sum _ { i ^ { \\prime } = 1 } ^ { i } s _ { i ^ { \\prime } } , \\sum _ { j ^ { \\prime } = 1 } ^ { j - 1 } s _ { j ^ { \\prime } } : \\sum _ { j ^ { \\prime } = 1 } ^ { j } s _ { j ^ { \\prime } } \\right] } \\end{array}$   \njust described, see Figure 5. ",
+        "bbox": [
+            173,
+            406,
+            826,
+            547
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "RSM can be interpreted from an attention [55] perspective. The feature map of a tracklet $t _ { i }$ being reconstructed can be seen as a set of queries, and the “source” detection feature $d _ { j }$ can be interpreted both as keys and values. The goal is to reconstruct the queries by linear combination of the values. The linear combination (attention) weights are computed using the affinity between queries and keys. Specifically, we first compute a global affinity matrix between $t _ { i }$ and all the $d _ { j ^ { \\prime } }$ for $j ^ { \\prime } = 1 , . . . , M$ , and then extract the corresponding sub-matrix for $t _ { i }$ and $d _ { j ^ { \\prime } }$ as the attention weights. Our formulation leads to a desired property: if the attention weights approach zero, the corresponding reconstructed point vectors will approach zero and so the RSM between $t _ { i }$ and $d _ { j }$ . ",
+        "bbox": [
+            173,
+            553,
+            826,
+            665
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Measuring similarity by reconstruction is popular in problems such as few-shot learning [67, 80], self-supervised learning [38], and person re-identification [26]. However, reconstruction is typically framed as a ridge regression or optimal transport problem. With $O ( n ^ { 2 } )$ complexity, RSM is more efficient than ridge regression and it has a similar computation cost to calculating the Earth Moving Distance for the optimal transport problem. Appendix D shows a series of ablation studies illustrating the importance of the proposed RSM for the effectiveness of UniTrack on association-type tasks. ",
+        "bbox": [
+            174,
+            671,
+            825,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            773,
+            312,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since UniTrack does not require task-specific training, we were able to experiment with many alternative appearance models (see Figure 3) with little computational cost. In Section 3.1 we perform an extensive evaluation to benchmark a wide variety of off-the-shelf, modern self-supervised models, showing their strengths and weaknesses on all five tasks considered. In this section we also conduct a correlation study with the so-called “linear probe” strategy [81], which became a popular way to evaluate representations obtained with self-supervised learning. Then, in Section 3.2 we compare UniTrack (equipped with supervised or unsupervised appearance models) against recent and task-specific tracking methods. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implementation details. We use ResNet-18 [25] or ResNet-50 as the default architecture. With ImageNet-supervised appearance model, we refer to the ImageNet pre-trained weights made available in PyTorch’s “Model Zoo”. To prevent excessive downsampling, we modify the spatial stride of layer3 and layer4 to 1, achieving a total stride of $r = 8$ . We extract features from both layer3 and layer4. We report results with layer3 features when comparing against task-specific methods (Section 3.2), and with both layer3 and layer4 when evaluating multiple different representations (Section 3.1). Further implementation details are deferred to Appendix B and C. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets and evaluation metrics. For fair comparison with existing methods, we report results on standard benchmarks with conventional metrics for each task. Please refer to Appendix A for details. ",
+        "bbox": [
+            173,
+            242,
+            825,
+            271
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1 UniTrack as evaluation platform of previously-learned representations ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            296,
+            700,
+            311
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The process of evaluating representations obtained via self-supervised learning (SSL) often involves additional training [17, 24, 10], for instance via the use of linear probes [81], which require to fix the pre-trained model and train an additional linear classifier on top of it. In contrast, using UniTrack as evaluation platform (1) does not require any additional training and (2) enables the evaluation on a battery of important video tasks, which have generally been neglected in self-supervised-learning papers in favour of more established image-level tasks such as classification. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            409
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate three types of SSL representations: (a) Image-level representations learned from images, e.g. MoCo [24] and BYOL [21]; (b) Pixel-level representations learned from images (such as DetCo [72] and PixPro [73]) and (c) videos (such as UVC [35] and CRW [27]). For all methods considered, we use the pre-trained weights provided by the authors. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results are shown in Table 1 and 2, where we report the results obtained by using features from either layer3 or layer4 of the pre-trained ResNet backbone. We report both results and separate them by a $\\cdot / { \\cdot }$ in the table. Note that, for this analysis only, for association-type tasks motion cues are discarded to better highlight distinctions between different representations and avoid potential confounding factors. Figure 1 provides a high-level summary of the results by focusing on the ranking obtained by different SSL methods on the five tasks considered (each represented by a vertex in the radar-style plot). Several observations can be made: ",
+        "bbox": [
+            174,
+            477,
+            825,
+            573
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(1) There is no significant correlation between “linear probe accuracy” on ImageNet and overall tracking performance. The linear probe approach [81] has become a standard way to compare SSL representations. In Figure 6, we plot tracking performance on five tasks (y-axes) against ImageNet top-1 accuracy of 16 different models ( $\\mathbf { \\dot { X } }$ -axes), and report Pearson and Spearman (rank) correlation coefficients. We observe that the correlation between ImageNet accuracy and tracking performance is small, i.e. the Pearson’s $r$ ranges from $- 0 . 3 8$ to $+ 0 . 2 0$ , and Spearman’s $\\rho$ ranges from $- 0 . 3 6$ to $+ 0 . 2 6$ . For most tasks, there is almost no correlation, while for VOS the two measures are mildly inversely correlated. The result suggests that evaluating SSL models on five extra tasks with UniTrack could constitute a useful complement to ImageNet linear probe evaluation, and encourage the SSL community to pursue the design of even more general purpose representations. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            718
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(2) A vanilla ImageNet-trained supervised representation is surprisingly effective across the board. On most tasks, it reports a performance competitive with the best representation for that task. This is particularly evident from Figure 1, where its performance is outlined as a gray dashed line. This result suggests that results obtained with vanilla ImageNet features should be reported when investigating new tracking methods. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            794
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(3) The best self-supervised representation ranks first on most tasks. Recently, it has been shown how SSL-trained representations can match or surpass their supervised counterparts on ImageNet classification (e.g. [21]) and many downstream tasks [17, 72]. Within UniTrack, although no individual SSL representation is able to beat the vanilla ImageNet-trained representation on every single task, we observe that the recently proposed VFS [74] ranks first on every task, except for single-object tracking. This suggests that advancements of the self-supervised learning literature can directly benefit the tracking community: it is reasonable to expect that newly-proposed representations will further improve performance across the board. ",
+        "bbox": [
+            173,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/0dc24063e9adab9828c2cfacfba52582dab8eb824e61c01b0b899ae4c005aef2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Representation</td><td colspan=\"2\">SOT [70]</td><td>VOS [48]</td><td colspan=\"2\">MOT [41]</td><td colspan=\"2\">MOTS [57]</td><td colspan=\"2\">PoseTrack [2]</td></tr><tr><td>AUCxCorr ↑</td><td>AUCDCF ↑</td><td>J-mean↑</td><td>IDF1个</td><td>HOTA↑</td><td>IDF1个</td><td>HOTA↑</td><td>IDF1个</td><td>IDs↓</td></tr><tr><td>Random Init.</td><td>10.3 /9.0</td><td>28.0 /20.0</td><td>29.3 /33.9</td><td>8.4/8.9</td><td>8.4/8.5</td><td>20.8 / 23.1</td><td>25.9 / 28.7</td><td>40.2 /38.5</td><td>88792/90963</td></tr><tr><td>ImageNet-sup.</td><td>58.6/49.5</td><td>62.0 / 53.9</td><td>62.3/57.9</td><td>75.6/73.2</td><td>63.3/ 61.8</td><td>68.4 /69.4</td><td>70.2/71.0</td><td>73.7/73.3</td><td>6969/7103</td></tr><tr><td>InsDis [71]</td><td>47.6 /47.3</td><td>61.8 / 51.1</td><td>62.6/ 60.1</td><td>66.7 /73.9</td><td>57.9 / 61.9</td><td>68.4 /68.0</td><td>69.6 /70.3</td><td>72.4 /73.9</td><td>7106 /7015</td></tr><tr><td>MoCoV1 [24]</td><td>50.9 /47.9</td><td>62.2/53.7</td><td>61.5 / 57.9</td><td>69.2 /74.1</td><td>59.4 / 61.9</td><td>70.6/ 69.3</td><td>71.6/70.9</td><td>72.8 / 739</td><td>6872/7092</td></tr><tr><td>PCLV1[34]</td><td>56.8/31.5</td><td>61.3/35.0</td><td>60.4/38.8</td><td>74.8/68.8</td><td>62.8 / 59.1</td><td>67.6 / 65.2</td><td>69.7 / 67.3</td><td>73.3 / 71.1</td><td>6855/10694</td></tr><tr><td>PIRL [42]</td><td>43.8 / 51.0</td><td>61.2 / 53.4</td><td>60.8/57.7</td><td>62.0 /73.4</td><td>54.6 / 61.9</td><td>66.0 / 67.4</td><td>66.7 /69.9</td><td>72.1/73.0</td><td>7235/7173</td></tr><tr><td>PCLV2 [34]</td><td>54.9/50.3</td><td>62.5 /51.6</td><td>61.2/52.5</td><td>74.9 /72.9</td><td>62.7/ 61.8</td><td>68.3/66.6</td><td>70.5/69.0</td><td>73.5/73.4</td><td>6859/ 8489</td></tr><tr><td>SimCLRV1[10]</td><td>47.3 / 51.9</td><td>61.3 / 50.7</td><td>60.5 /56.5</td><td>66.9 / 75.6</td><td>57.7 / 63.2</td><td>65.8 / 67.6</td><td>67.7 /69.5</td><td>72.3 /73.5</td><td>7084 /7367</td></tr><tr><td>MoCoV2 [12]</td><td>53.7 /47.2</td><td>61.5 /53.3</td><td>61.2 /54.0</td><td>72.0 / 74.9</td><td>61.2 / 62.8</td><td>67.5 /67.3</td><td>69.6 / 69.6</td><td>73.0 /73.7</td><td>6932 /7702</td></tr><tr><td>SimCLRV2[11]</td><td>50.0 / 54.7</td><td>61.7 /56.8</td><td>61.6 /58.4</td><td>67.6/75.7</td><td>58.1/ 63.3</td><td>69.1 / 67.4</td><td>70.4 / 69.4</td><td>72.5 /73.6</td><td>7228/7856</td></tr><tr><td>SeLaV2 [3]</td><td>51.0/9.6</td><td>63.1/14.2</td><td>60.2/40.2</td><td>68.8/68.9</td><td>59.0 / 59.3</td><td>66.8/66.1</td><td>68.7/ 68.5</td><td>72.9 /72.3</td><td>6983/7815</td></tr><tr><td>Infomin [53]</td><td>48.5/46.8</td><td>61.2 / 51.9</td><td>58.4/51.1</td><td>66.7 /73.4</td><td>57.6/61.9</td><td>66.7/66.3</td><td>68.5/68.8</td><td>72.5 /74.0</td><td>7066/7901</td></tr><tr><td>BarLow [79]</td><td>44.5/55.5</td><td>60.5 /60.1</td><td>61.7 / 57.8</td><td>63.7/74.5</td><td>55.4/62.4</td><td>68.7/67.4</td><td>69.5/ 69.8</td><td>72.3 /74.3</td><td>7131/7456</td></tr><tr><td>BYOL [21]</td><td>48.3/55.5</td><td>58.9 /56.8</td><td>58.8 / 54.3</td><td>65.3 /74.9</td><td>56.8 / 62.9</td><td>70.1/ 66.8</td><td>70.8 /69.3</td><td>72.4 / 73.8</td><td>7213/8032</td></tr><tr><td>DeepCluster [7]</td><td>51.5 / 52.9</td><td>61.2/61.2</td><td>59.3/53.4</td><td>66.9 /75.1</td><td>57.8 / 63.5</td><td>67.7 /67.4</td><td>69.4 /69.8</td><td>72.7 /73.7</td><td>7018/7283</td></tr><tr><td>SwAV [8]</td><td>49.2/52.4 51.1/45.3</td><td>61.5 /59.4 60.3/43.8</td><td>59.4/57.0</td><td>65.6/74.4</td><td>56.9 / 62.3</td><td>68.8/67.0</td><td>69.9 /69.5</td><td>72.7 /73.6</td><td>7025 /7377</td></tr><tr><td>VFS [74]</td><td></td><td></td><td>62.8/56.8</td><td>74.1/ 77.0</td><td>62.6 / 63.9</td><td>71.0/ 68.0</td><td>72.1/70.4</td><td>73.3/74.2</td><td>6731/7091</td></tr><tr><td>PixPro [73]</td><td>40.5 /49.2</td><td>57.4 /49.3</td><td>56.4/52.2</td><td>61.7 /67.7</td><td>54.3/58.6</td><td>64.2/66.2</td><td>65.1/67.6</td><td>72.4 / 73.1</td><td>7163 /6953</td></tr><tr><td>DetCo [72]</td><td>55.0/47.1</td><td>59.0/53.2</td><td>62.3/56.1</td><td>75.3 /72.9</td><td>62.8/61.6</td><td>67.8/66.8</td><td>70.0 /69.4</td><td>73.9/73.3</td><td>7357/8009</td></tr><tr><td>TimeCycle [64]</td><td>43.8 / 24.2</td><td>57.5/48.7</td><td>51.8 / 48.9</td><td>68.7 / 28.2</td><td>59.3 /25.5</td><td>69.9 / 47.1</td><td>71.3 /49.3</td><td>72.0 / 62.3</td><td>7837 /27884</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            828,
+            310
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/acd0287653158841a782e61e16c8453a3f819c121cee449a14221dc0658f2298.jpg",
+        "table_caption": [
+            "Table 1: Tracking performance of pre-trained image-based SSL models. All methods employ a ResNet-50. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Representation</td><td colspan=\"2\">SOT [70]</td><td>vOS [48]</td><td colspan=\"2\">MOT [41]</td><td colspan=\"2\">MOTS [57]</td><td colspan=\"2\">PoseTrack [2]</td></tr><tr><td>AUCxcorr 个</td><td>AUCDcF ↑</td><td>J-mean↑</td><td>IDF1↑</td><td>HOTA↑</td><td>IDF1个</td><td>HOTA↑</td><td>IDF1个</td><td>IDs↓</td></tr><tr><td>Random Init.</td><td>16.0 /18.2</td><td>36.1/ 32.1</td><td>33.0 /36.7</td><td>18.4 / 14.6</td><td>20.2 / 12.9</td><td>34.5 /33.1</td><td>39.9 /37.6</td><td>52.8 / 50.5</td><td>65317 /66230</td></tr><tr><td>ImageNet-sup.</td><td>55.0/46.2</td><td>61.8 / 52.6</td><td>58.4/46.7</td><td>74.8 / 74.5</td><td>62.7 / 62.1</td><td>67.6/ 68.6</td><td>69.8 / 70.5</td><td>72.7 / 73.2</td><td>6808 /7024</td></tr><tr><td>Color.[58]+mem.</td><td>41.6 /43.4</td><td>56.7 /58.7</td><td>53.6 / 59.7</td><td>64.9 / 62.8</td><td>56.8/55.5</td><td>68.8/66.1</td><td>69.4 / 66.3</td><td>72.4 / 72.6</td><td>6850/6778</td></tr><tr><td>UVC [35]</td><td>46.0/38.7</td><td>58.1/59.9</td><td>56.5 / 53.9</td><td>66.9/64.5</td><td>57.7/54.1</td><td>69.9 / 68.7</td><td>69.6 / 69.4</td><td>72.6/72.8</td><td>6843/ 6972</td></tr><tr><td>CRW [27]</td><td>46.3/49.1</td><td>58.9 / 54.9</td><td>63.2/60.7</td><td>67.8/73.0</td><td>58.4 / 61.7</td><td>69.0/71.3</td><td>69.2/71.9</td><td>72.7 /73.0</td><td>6799/6761</td></tr></table>",
+        "bbox": [
+            174,
+            333,
+            826,
+            415
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Tracking performance of pre-trained video-based SSL models. All methods employ a ResNet-18. In the above two tables, we report results with [layer3 / layer4] features in each cell, and the best performance between the two is bolded. We use the bolded values to rank the models in each column, and visualise (column-wise) better performance with darker cell colors. Best results in each column are underlined. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/298e1349e66d64591ba9deb65f91e69066f5b3dd00510fe516e2e8e0efd32d1c.jpg",
+        "image_caption": [
+            "Figure 6: Tracking performance is poorly correlated with ImageNet accuracy. On the $\\mathbf { X }$ -axes we plot ImageNet linear probe top-1 accuracy and on the y-axes the tracking performance on five tracking datasets. Correlation coefficients (Spearman’s $\\rho$ and Pearson’s $r$ ) are shown in the left bottom of each plot. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            478,
+            808,
+            568
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(4) Pixel-level SSL representations do not seem to have a consistent advantage in pixel-level tasks. In Table 2 and at the bottom of Table 1 we compare recent SSL representations trained with pixellevel proxy tasks: PixPro [73], DetCo [72], TimeCycle [64], Colorization [58], UVC [35] and Contrastive Random Walk (CRW) [27]. Considering that pixel-level models leverage more finegrained information during training, one may expect them to outperform image-based models in the tracking tasks where this is important. It is not straightforward to compare pixel-level SSL models with image-level ones, as the two types employ different default backbone networks. However, note how good image-based models (MoCo-v1, SimCLR-v2) are on par with their supervised counterpart in all tasks, while good pixel-level models (DetCo, CRW) still have gaps with respect to their supervised counterparts in tasks like SOT and MOT. Moreover, from Table 1, one can notice how the last three rows, despite representing methods leveraging pixel-level information during training, are actually outperformed by image-level representations on the pixel-level tasks of VOS, MOTS and PoseTrack. ",
+        "bbox": [
+            173,
+            642,
+            826,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(5) Video data can benefit representation learning for video tasks. The top-ranking VFS is similar to MoCo, SimCLR and BYOL in terms of learning scheme: they all perform contrastive learning on image level features. The most important distinction is the training data. Previous SSL methods mostly train on still-image based datasets (typically ImageNet), while VFS employs a large-scale video dataset Kinetics [9]. Clearly, this is not very surprising, as training on video data can help closing the domain gap with the (video-based) downstream tasks considered in this paper. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/900b810dce854ef48b69b5fd4aa58548c53df54ad22c4cde049fda63bb5dc7e1.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(a) MOT@MOT-16 [41] test split, private detection. "
+        ],
+        "table_body": "<table><tr><td>Methods</td><td>IDF1个</td><td>IDs↓</td><td>MOTA↑</td><td>HOTA↑</td></tr><tr><td>JDE [65]</td><td>55.8</td><td>1544</td><td>64.4</td><td>-</td></tr><tr><td>CTracker [47]</td><td>57.2</td><td>1897</td><td>67.6</td><td>48.8</td></tr><tr><td>TubeTK[46]</td><td>62.2</td><td>1236</td><td>66.9</td><td>50.8</td></tr><tr><td>MAT [23]</td><td>63.8</td><td>928</td><td>73.5</td><td>56.3</td></tr><tr><td>TraDes [69]</td><td>64.7</td><td>1144</td><td>70.1</td><td>53.2</td></tr><tr><td>CSTrack [36]</td><td>71.8</td><td>1071</td><td>70.7</td><td>59.8</td></tr><tr><td>FairMOT† [82]</td><td>72.8</td><td>1074</td><td>74.9</td><td>61.6</td></tr><tr><td>UniTrack_ImageNet†</td><td>71.8</td><td>683</td><td>74.7</td><td>59.1</td></tr><tr><td>UniTrack_VFS†</td><td>70.3</td><td>829</td><td>72.7</td><td>58.6</td></tr></table>",
+        "bbox": [
+            217,
+            88,
+            517,
+            204
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/6be5f5157396ad7bc8873682cc995e34591ba966c033f67ab24ae1ad7632306e.jpg",
+        "table_caption": [
+            "(b) MOTS@MOTS [57] test split. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>IDF1个</td><td>IDs↓</td><td>sMOTA↑</td></tr><tr><td>TrackRCNN [57]</td><td>42.4</td><td>567</td><td>40.6</td></tr><tr><td>SORTS [68]</td><td>57.3</td><td>577</td><td>55.0</td></tr><tr><td>PointTrack [76]</td><td>42.9</td><td>868</td><td>62.3</td></tr><tr><td>GMPHD [50]</td><td>65.6</td><td>566</td><td>69.0</td></tr><tr><td>COSTAt [1]</td><td>70.3</td><td>421</td><td>69.5</td></tr><tr><td>UniTrack_ImageNet†</td><td>67.2</td><td>622</td><td>68.9</td></tr><tr><td>UniTrack_VFSt</td><td>68.2</td><td>342</td><td>69.7</td></tr></table>",
+        "bbox": [
+            552,
+            97,
+            803,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/b05d09529c37ff7520bc914b69932794f5b95f533eac1806916bae536565c9d5.jpg",
+        "table_caption": [
+            "Table 3: Comparison with task-tailored unsupervised and supervised methods on five typical tracking tasks. $\\dagger$ indicates methods using identical observations. "
+        ],
+        "table_footnote": [
+            "(c) PoseTrack@PoseTrack2018 [2] val split. "
+        ],
+        "table_body": "<table><tr><td>Methods</td><td>IDF1个</td><td>IDs↓</td><td>MOTA↑</td></tr><tr><td>MDPN [22]</td><td>=</td><td>-</td><td>50.6</td></tr><tr><td>OpenSVAI [44]</td><td></td><td>-</td><td>62.4</td></tr><tr><td>Miracle [78]</td><td></td><td>=</td><td>64.0</td></tr><tr><td>KeyTrack [49]</td><td></td><td>-</td><td>66.6</td></tr><tr><td>TWVA [19]</td><td>=</td><td>=</td><td>64.7</td></tr><tr><td>LightTrack† [43]</td><td>52.2</td><td>3024</td><td>64.8</td></tr><tr><td>UniTrack_ImageNet†</td><td>73.2</td><td>6760</td><td>63.5</td></tr><tr><td>UniTrack_VFS†</td><td>74.2</td><td>7091</td><td>63.3</td></tr></table>",
+        "bbox": [
+            189,
+            248,
+            437,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/cb1a44962ab760f330da88f79ad5b9b875827c25e05635494e1823bd242c5b73.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(d) VOS@DAVIS-2017 [48]. "
+        ],
+        "table_body": "<table><tr><td>Methods</td><td>J-mean��</td></tr><tr><td>Supervised:</td><td></td></tr><tr><td>SiamMask [62]</td><td>54.3</td></tr><tr><td>FEELVOS [56]</td><td>63.7</td></tr><tr><td>STM [45]</td><td>79.2</td></tr><tr><td>Unsupervised:</td><td></td></tr><tr><td>Colorization [58]</td><td>34.6</td></tr><tr><td>TimeCylce [64]</td><td>40.1</td></tr><tr><td>UVC [35]</td><td>56.7</td></tr><tr><td>CRW [27]</td><td>64.8</td></tr><tr><td>UniTrack_ImageNet</td><td>58.4</td></tr><tr><td>UniTrack_VFS</td><td>62.8</td></tr></table>",
+        "bbox": [
+            449,
+            234,
+            612,
+            369
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/51c5b82ed7f6498fb161a227254e59f619bbee14eb69a816445bc2fb1a5525ed.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(e) SOT@OTB-2015 [70]. "
+        ],
+        "table_body": "<table><tr><td>Methods</td><td>AUC↑</td></tr><tr><td>Supervised:</td><td></td></tr><tr><td>SiamFC[5]</td><td>58.2</td></tr><tr><td>SiamRPN [33]</td><td>63.7</td></tr><tr><td>SiamRPN++ [32]</td><td>69.6</td></tr><tr><td>Unsupervised:</td><td></td></tr><tr><td>UDT [59]</td><td>59.4</td></tr><tr><td>UDT+[59]</td><td>63.2</td></tr><tr><td>LUDT [60]</td><td>60.2</td></tr><tr><td>LUDT+ [60]</td><td>63.9</td></tr><tr><td>UniTrack_ImageNet_XCorr</td><td>55.5</td></tr><tr><td>UniTrack_ImageNet_DCF</td><td>61.8</td></tr><tr><td>UniTrack_VFS_DCF</td><td>60.3</td></tr></table>",
+        "bbox": [
+            625,
+            229,
+            805,
+            375
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.2 Comparison with task-specific tracking methods ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            441,
+            547,
+            455
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised methods. We observe that UniTrack performs competitively against unsupervised state-of-the-art methods in both the propagation-type tasks we considered (Table 3d and 3e). For SOT, UniTrack with a DCF head [61] outperforms UDT [59] (a strong recent method) by 2.4 AUC points, while it is surpassed by LUDT $^ +$ [60] by 2.1 points. Considering that LUDT $^ +$ adopts an additional online template update mechanism [13] while ours does not, we believe the gap could be closed. In VOS, existing unsupervised methods are usually trained on video datasets [35, 27], and some of the most recent outperform UniTrack (with an ImageNet-trained representation). Nonetheless, when we use a VFS-trained representation, this performance difference is reduced to $2 \\%$ . Finally, note that for association-type tasks we are not aware of any existing unsupervised learning method, and thus in this case we limit the comparison to supervised methods. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison with supervised methods. In general, UniTrack with a ResNet-18 appearance model already performs on par with several existing task-specific supervised methods, and in several tasks it even shows superior accuracy, especially for identity-related metrics. (1) For SOT, UniTrack with a DCF head outperforms SiamFC [5] by 3.6 AUC points. This is a significant margin considering that SiamFC is trained with a large amount of crops from video datasets with annotated bounding boxes. (2) For VOS, UniTrack surpasses SiamMask [62] by 4.1 $\\mathcal { I }$ -mean points, despite this being trained on the joint set of three large-scale video datasets [37, 14, 75]. (3) For MOT, we employ the same detections used by the state-of-the-art tracker FairMOT [82]. The appearance embedding in FairMOT is trained with 270K bounding boxes of 8.7K labeled identities, from a MOT-specific dataset. In contrast, despite our appearance model not being trained with any MOT-specific data, our IDF1 score is quite competitive (71.8 v.s. 72.8 of FairMOT), and the ID switches are considerably reduced by $3 6 . { \\overset { - } { 4 } } \\%$ , from 1074 to 683. (4) For MOTS, we start from the same segmentation masks used by the COSTA [1] tracker, and observe a degradation in terms of ID switches (622 vs the 421 of the state of the art), and also a gap in IDF1 and sMOTA. (5) Finally, for pose tracking, we employ the same pose estimator used by LightTrack [43]. Compared with LightTrack, the MOTA of UniTrack degrades of 1.3 points because of an increased amount of ID switches. However, the IDF-1 score is improved by a significant margin $( + 2 1 . 0 $ points). This shows UniTrack preserves identity more accurately for long tracklets: even if ID switches occur more frequently, after a short period UniTrack is able to correct the wrong association, leading to a higher IDF-1. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Notice how, overall, UniTrack obtains more competitive performance on tasks that have association at their core, i.e. MOT, MOTS and PoseTrack. Upon inspection, we observed that most failure cases in propagation-type tasks regard the “drift” occurring when the scale of the object is improperly estimated. In future work, this could be addressed for instance by a bounding-box regression module to refine predictions, or by carefully designing a motion model. For association-type tasks, the consequences of any type of inaccuracy are isolated to individual pairs of frames, and thus much less catastrophic by nature. ",
+        "bbox": [
+            174,
+            883,
+            820,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            186,
+            321,
+            204
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, sharing the appearance model across multiple tracking tasks has not been extensively studied in the computer vision literature, and especially not in the context of SSL representations. Some existing methods do share a common backbone architecture across tasks. For instance, STEm-Seg [4] addresses VIS [77] and MOTS; while TraDeS [69] addresses MOT, MOTS and VIS. However, both methods need to be trained separately and on different datasets for every task. Conversely, we reuse the same representation across five tasks. A promising direction for future work would be to use UniTrack to train a shared representation in a multi-task fashion. Only a few relevant works do adopt a multi-task approach [62, 83, 40], and they usually consider SOT and VOS tasks only. In general, despite the multi-task direction being surely interesting, it requires the availability of large-scale datasets with annotations in multiple formats, and costly training. These are two of the main reasons for which we believe that having a framework that allows to achieve competitive performance on multiple tasks with previously-trained models is a worthwhile endeavour. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Self-supervised model evaluation. Given the difference between the pretext tasks used to train self-supervised models and the downstream tasks used to evaluate them, the comparison between self-supervised approaches has always been a delicate matter. Existing evaluation strategies typically require additional training once a general-purpose representation has been obtained. One strategy keeps the representation fixed, and then trains additional task-specific heads with very limited capacity (e.g. a linear classifier [20, 10, 24] or a regression head for object detection [20]). A second strategy, instead, leverages SSL to obtain particularly effective initializations, and then proceeds to fine-tune such initialized models on the downstream task of interest. A wider range of tasks can be tested using this setup, such as semantic segmentation [17, 20] and surface normal estimation [20, 63]. In contrast, UniTrack provides a simpler way to evaluate SSL models, one that does not require additional training or fine-tuning. Also, this work is the first to extend SSL evaluation to a set of diverse video tasks. We believe this contribution will allow the study of self-supervised learning methods with a broader scope of applicability. Our work is also related to a line of self-supervised learning methods [27, 58, 35, 31] that learn their representations in a task-agnostic fashion, and then test it on propagation tasks (SOT and VOS). The design of UniTrack is inspired by their task-agnostic philosophy, while significantly extending their scope to a new set of tasks. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            633,
+            297,
+            651
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Do different tracking tasks require different appearance models? In order to address this question, the proposed UniTrack framework has been instrumental, as it has allowed to easily experiment with alternative representations on a wide variety of downstream problems. Although the answer is not a resounding “no”, as only sometimes a single shared appearance model can outperform dedicated methods, we argue that a unified framework is an appealing alternative to task-specific methods. The main reason is that it allows us to make the most of the progress made in the representation learning literature at no extra cost. With the rapid development of self-supervised learning, and the large amount of computational resources dedicated to it, we believe it is reasonable to expect that, in the future, a general-purpose representation will be able to outperform task-specific methods across the board. Until then, UniTrack could still serve as a useful evaluation tool for novel representations, especially considering the lack of correlation with the standard linear-probe approach. We believe this will encourage the community to develop self-supervised representations that are of “general purpose” in a broader sense. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            840
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Broader impact. Upon reflection, we believe that progress in tracking applications and selfsupervised learning is beneficial for society, as it can significantly impact (for instance) the development of autonomous vehicles, which we consider a net positive for society. We also recognise that the same technologies could constitute a threat if deployed for surveillance by entities hostile to civil liberties. ",
+        "bbox": [
+            174,
+            843,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Funding Transparency Statement ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            486,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the National Natural Science Foundation of China under Grant No. 61771288, Cross-Media Intelligent Technology Project of Beijing National Research Center for Information Science and Technology (BNRist) under Grant No. BNR2019TD01022 and the research fund under Grant No. 2019GQG0001 from the Institute for Guo Qiang, Tsinghua University. ",
+        "bbox": [
+            174,
+            121,
+            826,
+            176
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was also supported by the EPSRC grant: Turing AI Fellowship: EP/W002981/1, EPSRC/MURI grant EP/N019474/1. We would also like to thank the Royal Academy of Engineering and FiveAI. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            224
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            251,
+            266,
+            267
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Costa_st tracker. https://motchallenge.net/method/MOTS 87&chl=17.   \n[2] Mykhaylo Andriluka, Umar Iqbal, Eldar Insafutdinov, Leonid Pishchulin, Anton Milan, Juergen Gall, and Bernt Schiele. Posetrack: A benchmark for human pose estimation and tracking. In CVPR, 2018.   \n[3] Yuki Markus Asano, Christian Rupprecht, and Andrea Vedaldi. Self-labelling via simultaneous clustering and representation learning. In ICLR, 2020.   \n[4] Ali Athar, Sabarinath Mahadevan, Aljoša Ošep, Laura Leal-Taixé, and Bastian Leibe. Stem-seg: Spatiotemporal embeddings for instance segmentation in videos. In ECCV, 2020.   \n[5] Luca Bertinetto, Jack Valmadre, Joao F Henriques, Andrea Vedaldi, and Philip HS Torr. Fully-convolutional siamese networks for object tracking. In ECCV workshops, 2016.   \n[6] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv:2005.14165, 2020.   \n[7] Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In ECCV, 2018.   \n[8] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. In NeurIPS, 2018.   \n[9] Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In CVPR, 2017.   \n[10] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. 2020.   \n[11] Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey Hinton. Big selfsupervised models are strong semi-supervised learners. arXiv:2006.10029, 2020.   \n[12] Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv:2003.04297, 2020.   \n[13] Martin Danelljan, Goutam Bhat, Fahad Shahbaz Khan, and Michael Felsberg. Eco: Efficient convolution operators for tracking. In CVPR, 2017.   \n[14] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.   \n[15] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. 2018.   \n[16] Alexey Dosovitskiy, Philipp Fischer, Eddy Ilg, Philip Hausser, Caner Hazirbas, Vladimir Golkov, Patrick Van Der Smagt, Daniel Cremers, and Thomas Brox. Flownet: Learning optical flow with convolutional networks. In ICCV, 2015.   \n[17] Linus Ericsson, Henry Gouk, and Timothy M Hospedales. How well do self-supervised models transfer? In CVPR, 2021.   \n[18] Masoud Faraki, Xiang Yu, Yi-Hsuan Tsai, Yumin Suh, and Manmohan Chandraker. Cross-domain similarity learning for face recognition in unseen domains. arXiv:2103.07503, 2021.   \n[19] Yang Fu, Sifei Liu, Umar Iqbal, Shalini De Mello, Humphrey Shi, and Jan Kautz. Learning to track instances without video annotations. In CVPR, 2021.   \n[20] Priya Goyal, Dhruv Mahajan, Abhinav Gupta, and Ishan Misra. Scaling and benchmarking self-supervised visual representation learning. arXiv:1905.01235, 2019.   \n[21] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv:2006.07733, 2020.   \n[22] Hengkai Guo, Tang Tang, Guozhong Luo, Riwei Chen, Yongchen Lu, and Linfu Wen. Multi-domain pose network for multi-person pose estimation and tracking. In ECCV, workshop, 2018.   \n[23] Shoudong Han, Piao Huang, Hongwei Wang, En Yu, Donghaisheng Liu, Xiaofeng Pan, and Jun Zhao. Mat: Motion-aware multi-object tracking. arXiv:2009.04794, 2020. visual representation learning. In CVPR, 2020.   \n[25] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   \n[26] Lingxiao He, Jian Liang, Haiqing Li, and Zhenan Sun. Deep spatial feature reconstruction for partial person re-identification: Alignment-free approach. In CVPR, 2018.   \n[27] Allan Jabri, Andrew Owens, and Alexei A Efros. Space-time correspondence as a contrastive random walk. In NeurIPS, 2020.   \n[28] Rudolph Emil Kalman. A new approach to linear filtering and prediction problems. 1960.   \n[29] Matej Kristan, Jiri Matas, Aleš Leonardis, Tomáš Vojíˇr, Roman Pflugfelder, Gustavo Fernandez, Georg Nebehay, Fatih Porikli, and Luka Cehovin. A novel performance evaluation methodology for single-target ˇ trackers. IEEE TPAMI, 2016.   \n[30] Harold W Kuhn. The hungarian method for the assignment problem. Naval research logistics quarterly, 2(1-2):83–97, 1955.   \n[31] Zihang Lai, Erika Lu, and Weidi Xie. Mast: A memory-augmented self-supervised tracker. In CVPR, 2020.   \n[32] Bo Li, Wei Wu, Qiang Wang, Fangyi Zhang, Junliang Xing, and Junjie Yan. Siamrpn $^ { + + }$ : Evolution of siamese visual tracking with very deep networks. In CVPR, 2019.   \n[33] Bo Li, Junjie Yan, Wei Wu, Zheng Zhu, and Xiaolin Hu. High performance visual tracking with siamese region proposal network. In CVPR, 2018.   \n[34] Junnan Li, Pan Zhou, Caiming Xiong, Richard Socher, and Steven CH Hoi. Prototypical contrastive learning of unsupervised representations. In ICLR, 2021.   \n[35] Xueting Li, Sifei Liu, Shalini De Mello, Xiaolong Wang, Jan Kautz, and Ming-Hsuan Yang. Joint-task self-supervised learning for temporal correspondence. In NeurIPS, 2019.   \n[36] Chao Liang, Zhipeng Zhang, Yi Lu, Xue Zhou, Bing Li, Xiyong Ye, and Jianxiao Zou. Rethinking the competition between detection and reid in multi-object tracking. arXiv:2010.12138, 2020.   \n[37] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ECCV, 2014.   \n[38] Songtao Liu, Zeming Li, and Jian Sun. Self-emd: Self-supervised object detection without imagenet. arXiv:2011.13677, 2020.   \n[39] Jonathan Long, Ning Zhang, and Trevor Darrell. Do convnets learn correspondence? In NeurIPS, 2014.   \n[40] Alan Lukezic, Jiri Matas, and Matej Kristan. D3s-a discriminative single shot segmentation tracker. In CVPR, 2020.   \n[41] Anton Milan, Laura Leal-Taixé, Ian Reid, Stefan Roth, and Konrad Schindler. Mot16: A benchmark for multi-object tracking. arXiv:1603.00831, 2016.   \n[42] Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In CVPR, 2020.   \n[43] Guanghan Ning and Heng Huang. Lighttrack: A generic framework for online top-down human pose tracking. In CVPR, workshop, 2020.   \n[44] Guanghan Ning, Ping Liu, Xiaochuan Fan, and Chi Zhang. A top-down approach to articulated human pose estimation and tracking. In ECCV, workshop, 2018.   \n[45] Seoung Wug Oh, Joon-Young Lee, Ning Xu, and Seon Joo Kim. Video object segmentation using space-time memory networks. In ICCV, 2019.   \n[46] Bo Pang, Yizhuo Li, Yifan Zhang, Muchen Li, and Cewu Lu. Tubetk: Adopting tubes to track multi-object in a one-step training model. In CVPR, 2020.   \n[47] Jinlong Peng, Changan Wang, Fangbin Wan, Yang Wu, Yabiao Wang, Ying Tai, Chengjie Wang, Jilin Li, Feiyue Huang, and Yanwei Fu. Chained-tracker: Chaining paired attentive regression results for end-to-end joint multiple-object detection and tracking. In ECCV, 2020.   \n[48] F. Perazzi, J. Pont-Tuset, B. McWilliams, L. Van Gool, M. Gross, and A. Sorkine-Hornung. A benchmark dataset and evaluation methodology for video object segmentation. In CVPR, 2016.   \n[49] Michael Snower, Asim Kadav, Farley Lai, and Hans Peter Graf. 15 keypoints is all you need. In CVPR, 2020.   \n[50] Young-min Song and Moongu Jeon. Online multi-object tracking and segmentation with gmphd filter and simple affinity fusion. arXiv:2009.00100, 2020.   \n[51] Yifan Sun, Qin Xu, Yali Li, Chi Zhang, Yikang Li, Shengjin Wang, and Jian Sun. Perceive where to focus: Learning visibility-aware part-level features for partial person re-identification. In CVPR, 2019.   \n[52] Yifan Sun, Liang Zheng, Yi Yang, Qi Tian, and Shengjin Wang. Beyond part models: Person retrieval with refined part pooling (and a strong convolutional baseline). In ECCV, 2018.   \n[53] Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning. In NeurIPS, 2020.   \n[54] Jack Valmadre, Luca Bertinetto, Joao Henriques, Andrea Vedaldi, and Philip HS Torr. End-to-end representation learning for correlation filter based tracking. In CVPR, 2017.   \n[55] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017.   \n[56] Paul Voigtlaender, Yuning Chai, Florian Schroff, Hartwig Adam, Bastian Leibe, and Liang-Chieh Chen. Feelvos: Fast end-to-end embedding learning for video object segmentation. In CVPR, 2019.   \n[57] Paul Voigtlaender, Michael Krause, Aljosa Osep, Jonathon Luiten, Berin Balachandar Gnana Sekar, Andreas Geiger, and Bastian Leibe. Mots: Multi-object tracking and segmentation. In CVPR, 2019.   \n[58] Carl Vondrick, Abhinav Shrivastava, Alireza Fathi, Sergio Guadarrama, and Kevin Murphy. Tracking emerges by colorizing videos. In ECCV, 2018.   \n[59] Ning Wang, Yibing Song, Chao Ma, Wengang Zhou, Wei Liu, and Houqiang Li. Unsupervised deep tracking. In CVPR, 2019.   \n[60] Ning Wang, Wengang Zhou, Yibing Song, Chao Ma, Wei Liu, and Houqiang Li. Unsupervised deep representation learning for real-time tracking. IJCV, 2020.   \n[61] Qiang Wang, Jin Gao, Junliang Xing, Mengdan Zhang, and Weiming Hu. Dcfnet: Discriminant correlation filters network for visual tracking. arXiv:1704.04057, 2017.   \n[62] Qiang Wang, Li Zhang, Luca Bertinetto, Weiming Hu, and Philip HS Torr. Fast online object tracking and segmentation: A unifying approach. In CVPR, 2019.   \n[63] Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In ICCV, 2015.   \n[64] Xiaolong Wang, Allan Jabri, and Alexei A Efros. Learning correspondence from the cycle-consistency of time. In CVPR, 2019.   \n[65] Zhongdao Wang, Liang Zheng, Yixuan Liu, and Shengjin Wang. Towards real-time multi-object tracking. In ECCV, 2020.   \n[66] Shih-En Wei, Varun Ramakrishna, Takeo Kanade, and Yaser Sheikh. Convolutional pose machines. In CVPR, 2016.   \n[67] Davis Wertheimer, Luming Tang, and Bharath Hariharan. Fine-grained few-shot classification with feature map reconstruction networks. CVPR, 2021.   \n[68] Nicolai Wojke, Alex Bewley, and Dietrich Paulus. Simple online and realtime tracking with a deep association metric. In ICIP, 2017.   \n[69] Jialian Wu, Jiale Cao, Liangchen Song, Yu Wang, Ming Yang, and Junsong Yuan. Track to detect and segment: An online multi-object tracker. In CVPR, 2021.   \n[70] Yi Wu, Jongwoo Lim, and Ming-Hsuan Yang. Online object tracking: A benchmark. In CVPR, 2013.   \n[71] Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via non-parametric instance discrimination. In CVPR, 2018.   \n[72] Enze Xie, Jian Ding, Wenhai Wang, Xiaohang Zhan, Hang Xu, Zhenguo Li, and Ping Luo. Detco: Unsupervised contrastive learning for object detection. arXiv:2102.04803, 2021.   \n[73] Zhenda Xie, Yutong Lin, Zheng Zhang, Yue Cao, Stephen Lin, and Han Hu. Propagate yourself: Exploring pixel-level consistency for unsupervised visual representation learning. In CVPR, 2021.   \n[74] Jiarui Xu and Xiaolong Wang. Rethinking self-supervised correspondence learning: A video frame-level similarity perspective. arXiv:2103.17263, 2021.   \n[75] Ning Xu, Linjie Yang, Yuchen Fan, Jianchao Yang, Dingcheng Yue, Yuchen Liang, Brian Price, Scott Cohen, and Thomas Huang. Youtube-vos: Sequence-to-sequence video object segmentation. In ECCV, 2018.   \n[76] Zhenbo Xu, Wei Zhang, Xiao Tan, Wei Yang, Huan Huang, Shilei Wen, Errui Ding, and Liusheng Huang. Segment as points for efficient online multi-object tracking and segmentation. In ECCV, 2020.   \n[77] Linjie Yang, Yuchen Fan, and Ning Xu. Video instance segmentation. In ICCV, 2019.   \n[78] Dongdong Yu, Kai Su, Jia Sun, and Changhu Wang. Multi-person pose estimation for pose tracking with enhanced cascaded pyramid network. In ECCV, workshop, 2018.   \n[79] Jure Zbontar, Li Jing, Ishan Misra, Yann LeCun, and Stéphane Deny. Barlow twins: Self-supervised learning via redundancy reduction. arXiv:2103.03230, 2021.   \n[80] Chi Zhang, Yujun Cai, Guosheng Lin, and Chunhua Shen. Deepemd: Few-shot image classification with differentiable earth mover’s distance and structured classifiers. In CVPR, 2020.   \n[81] Richard Zhang, Phillip Isola, and Alexei A Efros. Split-brain autoencoders: Unsupervised learning by cross-channel prediction. In CVPR, 2017.   \n[82] Yifu Zhang, Chunyu Wang, Xinggang Wang, Wenjun Zeng, and Wenyu Liu. Fairmot: On the fairness of detection and re-identification in multiple object tracking. arXiv:2004.01888, 2020.   \n[83] Zhipeng Zhang, Bing Li, Weiming Hu, and Houweng Peng. Towards accurate pixel-wise object tracking by attention retrieval. arXiv:2008.02745, 2020.   \n[84] Kuan Zhu, Haiyun Guo, Zhiwei Liu, Ming Tang, and Jinqiao Wang. Identity-guided human semantic parsing for person re-identification. In ECCV, 2020. ",
+        "bbox": [
+            173,
+            273,
+            826,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            106,
+            828,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            94,
+            828,
+            873
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HkfPSh05K7/HkfPSh05K7.md

@@ -0,0 +1,314 @@
+# MULTI-STEP RETRIEVER-READER INTERACTION FOR SCALABLE OPEN-DOMAIN QUESTION ANSWERING
+
+Rajarshi Das1, Shehzaad Dhuliawala2, Manzil Zaheer3 & Andrew McCallum1
+
+{rajarshi,mccallum}@cs.umass.edu   
+shehzaad.dhuliawala@microsoft.com, manzil@zaheer.ml   
+1 University of Massachusetts, Amherst, 2 Microsoft Research, Montreal ´   
+3 Google AI, Mountain View
+
+# ABSTRACT
+
+This paper introduces a new framework for open-domain question answering in which the retriever and the reader iteratively interact with each other. The framework is agnostic to the architecture of the machine reading model, only requiring access to the token-level hidden representations of the reader. The retriever uses fast nearest neighbor search to scale to corpora containing millions of paragraphs. A gated recurrent unit updates the query at each step conditioned on the state of the reader and the reformulated query is used to re-rank the paragraphs by the retriever. We conduct analysis and show that iterative interaction helps in retrieving informative paragraphs from the corpus. Finally, we show that our multistep-reasoning framework brings consistent improvement when applied to two widely used reader architectures (DR.QA and BIDAF) on various large open-domain datasets — TRIVIAQA-unfiltered, QUASAR-T, SEARCHQA, and SQUAD-open1.
+
+# 1 INTRODUCTION
+
+Open-domain question answering (QA) (Voorhees et al., 1999) involves a retriever for selecting relevant context from a large corpora of text (e.g. Wikipedia) and a machine reading comprehension (MRC) model for ‘reasoning’ on the retrieved context. A lot of effort has been put into designing sophisticated neural MRC architectures for reading short context (e.g. a single paragraph), with much success (Wang & Jiang, 2017; Seo et al., 2017; Xiong et al., 2017; Wang et al., 2018c; Yu et al., 2018, inter alia). However, the performance of such systems degrades significantly when combined with a retriever in open domain settings. For example, the exact match accuracy of $\mathrm { D r Q A }$ (Chen et al., 2017), on the SQUAD dataset (Rajpurkar et al., 2016) degrades from $6 9 . 5 \%$ to $2 8 . 4 \%$ in open-domain settings. The primary reason for this degradation in performance is due to the retriever’s failure to find the relevant paragraphs for the machine reading model (Htut et al., 2018).
+
+We propose the following two desiderata for a general purpose open-domain QA system - (a) The retriever model should be fast, since it has to find the relevant context from a very large text corpora and give it to the more sophisticated and computationally expensive MRC model (b) Secondly, the retriever and reader models should be interactive, i.e. if the reader model is unable to find the answer from the initial retrieved context, the retriever should be able to learn to provide more relevant context to the reader. Open-domain QA systems such as $\mathbb { R } ^ { 3 }$ (Wang et al., 2018a) and DS-QA (Lin et al., 2018) have sophisticated retriever models where the reader and retriever are jointly trained. However, their retriever computes question-dependent paragraph representation which is then encoded by running an expensive recurrent neural network over the tokens in the paragraph. Since the retriever has to rank a lot of paragraphs, this design does not scale to large corporas. One the other hand, the retriever model of QA systems such as DrQA (Chen et al., 2017) is based on a tf-idf retriever, but they lack trainable parameters and are consequently unable to recover from mistakes.
+
+This paper introduces an open domain architecture in which the retriever and reader iteratively interact with each other. Our model first pre-computes and caches representation of context (paragraph). These representations are independent of the query unlike recent architectures (Wang et al., 2018a;
+
+![](images/82d26f0dd95fab7f7d701a2a5b76857bd179a094a0d0730be65ce3c615dfc9d7.jpg)  
+Figure 1: Our framework unrolled for two steps. The initial query is encoded and the retriever sends the top- $k$ paragraphs to the reader. The multi-step-reasoner component of our model takes in the internal state of the reader model and the previous query vector and does a gated update to produce a reformulated query. This new query vector is used by the retriever to re-rank the paragraphs and send different paragraphs to the reader. Thus the multi-step-reasoner facilitates iterative interaction between the retriever (search engine) and the reader (QA model)
+
+Lin et al., 2018) and hence can be computed and stored offline. Given an input question, the retriever performs fast inner product search to find the most relevant contexts. The highest ranked contexts are then passed to the neural MRC model. Our architecture is agnostic to the choice of the reader architecture and we show that multi-step-reasoning increases performance of two state-of-the-art MRC architectures - DrQA (Chen et al., 2017) and BiDAF (Seo et al., 2017).
+
+It is possible that the answer might not exist in the initial retrieved paragraphs or that the model would need to combine information across multiple paragraphs (Wang et al., 2018b). We equip the reader with an additional gated recurrent unit (Cho et al., 2014) which takes in the state of the reader and the current query vector and generates a new query vector. This new query vector is then used by the retriever model to re-rank the context. This allows the model to read new paragraphs and combine evidence across multiple paragraphs. Since the retriever makes a ‘hard selection’ of paragraphs to send to the reader, we train the retriever and the reader jointly using reinforcement learning.
+
+Our architecture draws inspiration from how students are instructed to take reading comprehension tests (Cunningham & Shablak, 1975; Bishop et al., 2006; Duggan & Payne, 2009). Given a document containing multiple paragraphs and a set of questions which can be answered from the document, (a) the student quickly skims the paragraphs, (b) then for each question, she finds the most relevant paragraphs that she thinks will answer the question. (c) She then carefully reads the chosen paragraph to answer the question (d) However, if the chosen paragraph does not answer the question, then given the question and the knowledge of what she has read till now, she decides which paragraph to read next. Step (a) is akin to our model encoding and storing the question independent paragraph representations and step (b) corresponds to the inner product search to find the relevant context. The reading of the context by the sophisticated neural machine reader corresponds to step (c) and the last step corresponds to the iterative (multi-step) interaction between the retriever and the reader.
+
+To summarize, this paper makes the following contributions: (a) We introduce a new framework for open-domain QA in which the retriever and reader iteratively interact with each other via a novel multistep-reasoning component allowing it to retrieve and combine information from multiple paragraphs.
+
+(b) Our paragraph representations are independent of the query which makes our architecture highly scalable and we empirically demonstrate it by running large scale experiments over millions of paragraphs. (c) Lastly, our framework is agnostic to the architecture of the reader and we show improvements on two widely used neural reading comprehension models.
+
+# 2 BASIC COMPONENTS OF OUR MODEL
+
+The architecture of our model consists of three main components - (a) paragraph retriever - that computes a relevance score for each paragraph w.r.t a given query and ranks them according to the computed score. (b) reader - a more sophisticated neural machine reading model that receives few top-ranked paragraphs from the retriever and outputs a span of text as a possible answer to the query and (c) multi-step-reasoner - a gated recurrent unit that facilitates iterative interaction between the retriever and the reader.
+
+Formally, the input to our model is a natural language question $\mathrm { Q } = \mathrm { q } _ { 1 }$ , q2,. . . , ${ \bf q } _ { n }$ consisting of $n$ tokens and a set of paragraphs $\mathsf { P } = \{ \mathsf { p } _ { 1 } , \mathsf { p } _ { 2 } , . . . \mathsf { p } _ { K } \}$ . Our model extracts a span of text $a$ as the answer to the question from the paragraphs in P. Note that the set of paragraphs in P can be the paragraphs in a set of documents retrieved by a search engine or it could be all the paragraphs in a large text corpus such as Wikipedia. Next we describe each individual component of our model.
+
+# 2.1 PARAGRAPH RETRIEVER
+
+The paragraph retriever computes a score for how likely a paragraph is to contain an answer to a given question. The paragraph representations are computed independent of the query and once computed, they are not updated. This allows us to cache the representations and store them offline. The relevance score of a paragraph is computed as a inner product between the paragraph and the query vectors. The paragraph and query representations are computed as follows.
+
+Given a paragraph $\mathfrak { p } = \{ \mathfrak { p } _ { 1 } , \mathfrak { p } _ { 2 } , \dots , \mathfrak { p } _ { m } \}$ consisting of $m$ tokens, a multi-layer recurrent neural network encodes each tokens in the paragraph — $\left\{ \mathbf { p } _ { 1 } , \mathbf { p } _ { 2 } , \ldots , \mathbf { p } _ { m } \right\} = \mathbf { R N N } \left( \left\{ \mathbf { p } _ { 1 } , \mathbf { p } _ { 2 } , \ldots , \mathbf { p } _ { m } \right\} \right)$ , where $\mathbf { p } _ { j } \in \mathbb { R } ^ { 2 d }$ encodes useful contextual information around the $j$ -th token. Specifically we choose to use a multilayer bidirectional long-short term memory network (LSTM) (Hochreiter & Schmidhuber, 1997) and take $\mathbf { p } _ { j }$ as the hidden units in the last layer of the RNN. We concatenate the representation computed by the forward and the backward LSTM. To compute a single paragraph vector $ { \mathbf { p } } \in \mathbb { R } ^ { 2 d }$ from all the token representations, we combine them using weights $b _ { j } \in \mathbb { R }$
+
+$$
+b _ { j } = \frac { \exp ( \mathbf { w } \cdot \mathbf { p _ { j } } ) } { \sum _ { j ^ { \prime } } \exp ( \mathbf { w } \cdot \mathbf { p } _ { j ^ { \prime } } ) } \qquad \mathbf { p } = W _ { s } \sum _ { j ^ { \prime } } b _ { j ^ { \prime } } \cdot \mathbf { p _ { j ^ { \prime } } }
+$$
+
+Here $b _ { j }$ encodes the importance of each token and $\mathbf { w } \in \mathbb { R } ^ { 2 d } , \mathbf { W _ { s } } \in \mathbb { R } ^ { 2 d \times 2 d }$ are learned weights. The query ${ \dot { \mathbf { q } } } = \left\{ { \mathfrak { q } } _ { 1 } , { \mathfrak { q } } _ { 2 } , \dots , { \mathfrak { q } } _ { n } \right\}$ is encoded by another network with the same architecture to obtain a query vector $\mathbf { q } \in \mathbb { R } ^ { 2 d }$ . Next the relevance score of a paragraph w.r.t the query (score $( \mathbf { p } , \mathbf { q } ) \in \mathbb { R } )$ is computed by a simple inner product — score $( { \bf p } , { \bf q } ) = \langle { \bf p } , { \bf q } \rangle$ . The paragraph retriever then returns the top scoring $k$ paragraphs to the reader.
+
+Fast inner product search. Inner product can be efficiently computed on a GPU, however in our experiments with large corpus with over million paragraphs, (a) the paragraph vectors require more memory than available in a single commodity GPU (b) it is computationally wasteful to compute inner products with all paragraph vectors and we can do better by leveraging fast nearest neighbor (NN) search algorithms. Since the retriever has to find the $k$ paragraphs with the highest inner products w.r.t query, our problem essentially reduces to maximum inner product search (MIPS). There exists data structures for fast NN search in metric spaces such as Cover Trees (Beygelzimer et al., 2006). But we cannot use them directly, since triangle equality does not hold in inner product space. Borrowing ideas from Bachrach et al. (2014); Zaheer et al. (2019), we propose to use nearest neighbor (NN) search algorithms to perform the MIPS in sublinear time as follows.
+
+Let u be an upper bound for the L2 norm for all paragraphs, i.e. $\mathbf { u } \geq \| \mathbf { p } \|$ , $\forall \mathbf { p }$ . Next, we modify the original paragraph and query vectors such that searching for the $\mathbf { k }$ -nearest neighbor w.r.t L2 distance with the modified vectors is equivalent to finding the $k$ nearest (original) paragraph vectors in the inner-product space.
+
+Define the augmented paragraph vectors as $\tilde { \mathbf { p } } \mathbf { i } = [ \mathbf { p } \mathbf { i } ; \sqrt { \mathbf { u } ^ { 2 } - \| \mathbf { p } \mathbf { i } \| ^ { 2 } } ]$ and augmented query vector as $\widetilde { \mathbf { q } } = [ \mathbf { q } ; 0 ]$ , where $[ ; ]$ denotes concatenation. Note, with this transformation, $\langle \tilde { { \bf p } } _ { \bf i } , \tilde { { \bf q } } \rangle = \langle { \bf p _ { i } } , { \bf q } \rangle$ . Now,
+
+$$
+\begin{array} { r l } & { \mathrm { N N } ( \tilde { \bf p _ { i } } , \tilde { \bf q } ) = \underset { i } { \arg \operatorname* { m i n } } \left\| \tilde { \bf p _ { i } } - \tilde { \bf q } \right\| ^ { 2 } } \\ & { \quad \quad \quad \quad = \underset { i } { \arg \operatorname* { m i n } } \left\| \tilde { \bf p _ { i } } \right\| ^ { 2 } + \left\| \tilde { \bf q } \right\| ^ { 2 } - 2 \langle \tilde { \bf p _ { i } } , \tilde { \bf q } \rangle } \\ & { \quad \quad \quad \quad = \underset { i } { \arg \operatorname* { m i n } } ( { \bf u } ^ { 2 } - 2 \langle \tilde { \bf p _ { i } } , \tilde { \bf q } \rangle ) } \\ & { \quad \quad \quad \quad = \underset { i } { \arg \operatorname* { m a x } } \langle \tilde { \bf p _ { i } } , \tilde { \bf q } \rangle = \underset { i } { \arg \operatorname* { m a x } } \langle { \bf p _ { i } } , { \bf q } \rangle = \mathrm { M I P S } ( { \bf p _ { i } } , { \bf q } ) } \end{array}
+$$
+
+Many exact NN search algorithms can find $\mathbf { k }$ -NN in time (sublinear) logarithmic in number of paragraphs (Beygelzimer et al., 2006; Zaheer et al., 2019), after an one-time preprocessing. In our architecture, the preprocessing can be done because the set of all paragraphs is fixed for all the queries. We chose to use SGTree (Zaheer et al., 2019) to perform the NN/MIPS due to its fast construction time and competitive performance reducing the search to logarithmic time per query.
+
+Note that our paragraph representations are independent of the given query and are never updated once they are trained. After training is completed, we cache the $ { \mathbf { p } } \in  { \mathbb { R } } ^ { 2 d }$ vectors. This is unlike many recent work in open-domain QA. For example, in $\mathbb { R } ^ { 3 }$ (Wang et al., 2018a), the retriever uses Match-LSTM model (Wang & Jiang, 2017) to compute question-matching representations for each token in the passage. The paragraph representations are then obtained by running a bi-directional RNN over these matched representation. Although powerful, this architecture design will not scale in open-domain settings where the retriever has to re-compute new representations for possibly millions of paragraphs for every new question. In contrast, once training is over, we cache the paragraph representation and use it for every query at test time.
+
+Training - Following previous work (Htut et al., 2018; Lin et al., 2018; Wang et al., 2018a), we gather labels for paragraphs during training using distant supervision (Mintz et al., 2009). A paragraph that contains the exact ground truth answer string is labeled as an positive example. For a positive (negative) labeled paragraph, we maximize (minimize) the $\log ( \sigma ( \mathrm { s c o r e } ( \mathbf { p } , \mathbf { q } ) ) )$ . The number of layers of the bi-directional LSTM encoder is set to three and we use Adam (Kingma & Ba, 2014) for optimization. Once training is done, we pre-compute and cache the paragraph representation of each dataset in our experiments.
+
+# 2.2 MACHINE READER
+
+The reader is a sophisticated neural machine reading comprehension (MRC) model that takes in the top few paragraphs sent by the retriever and outputs a span of answer text. Our model is agnostic to the exact architecture of the reader and we perform experiments to show the efficacy of our model on two state-of-the-art neural machine reading models - DrQA and BiDAF.
+
+MRC models designed for SQUAD (Rajpurkar et al., 2016), NewsQA (Trischler et al., 2016), etc operate on a single paragraph. However it has been shown that reading and aggregating evidence across multiple paragraphs is important when doing QA over larger evidence set (e.g. full Wikipedia document) (Swayamdipta et al., 2018; Clark & Gardner, 2018) and in open domain settings (Wang et al., 2018b). Most MRC models compute a start and end scores for each token in the paragraph that represents how likely a token is the start/end of an answer span. To gather evidence across multiple paragraphs sent by the retriever, we normalize the start/end scores across the paragraphs. Furthermore a text span can appear multiple times in a paragraph. To give importance to all answer spans in the text, our objective aggregates (sums) the log-probability of the score for each answer position. Let $\mathcal { T } ( w , p )$ denote the token start positions where the answer span appears in the paragraph $p$ and let $w _ { S }$ be the starting word of the answer span. Our model maximizes the sum of the following objective for the start and end word of an answer spans as follows. (For brevity, we only show the objective for the starting word $( \mathbf { w } _ { s } )$ of the span.)
+
+$$
+\log \left( \frac { \sum _ { j \in \mathcal { P } } \sum _ { k \in \mathcal { Z } ( w _ { s } , p _ { j } ) } \exp ( \operatorname { s c o r e } _ { \mathrm { s t a r t } } ( k , j ) ) } { \sum _ { j \in \mathcal { P } } \sum _ { i = 1 } ^ { n _ { j } } \exp ( \operatorname { s c o r e } _ { \mathrm { s t a r t } } ( i , j ) ) } \right)
+$$
+
+Here, $\mathcal { P }$ denotes the set of all top-ranked paragraphs by the retriever, $n _ { j }$ denotes the number of tokens in paragraph $j$ and $\mathrm { s c o r e } _ { \mathrm { s t a r t } } \left( k , j \right)$ denotes the start score of the $k$ -th token in the $j$ -th paragraph.
+
+Score aggregation during inference. During inference, following Chen et al. (2017); Seo et al. (2017), the score of a span that starts at token position $i$ and ends at position $j$ of paragraph $p$ is given by the sum of the $\mathrm { \ s c o r e } _ { \mathrm { s t a r t } } ( i , p )$ and $\operatorname { s c o r e } _ { \mathrm { e n d } } ( j , p )$ . During inference, we score spans up to a pre-defined maximum length of 15. Further, we add the scores of spans across different paragraphs (even if they are retrieved at different steps), if they have the same surface form. That is, if the same span (e.g. “Barack Obama”) occurs multiple times in several paragraphs, we sum the individual span scores. However, to ensure tractability, we only consider the top 10 scoring spans in each paragraph for aggregation. It should be noted that the changes we made to aggregate evidence over multiple paragraphs and mentions of spans needs no change to the original MRC architecture.
+
+# 3 MULTI-STEP-REASONER
+
+A novel component of our open-domain architecture is the multi-step-reasoner which facilitates iterative interaction between the retriever and the machine reader. The multi-step-reasoner a module comprised of a gated recurrent unit (Cho et al., 2014) which takes in the current state of the reader and the current query vector and does a gated update to produce a reformulated query. The reformulated query is sent back to the retriever which uses it to re-rank the paragraphs in the corpus. Since the gated update of the multi-step-reasoner, conditions on the current state of the machine reader, this multi-step interaction provides a way for the search engine (retriever) and the QA model (reader) to communicate with each other. This can also be seen as an instance of two agents cooperating via communication to solve a task (Lazaridou et al., 2017; Lee et al., 2018; Cao et al., 2018).
+
+More formally, let $\mathbf { q } _ { \mathbf { t } } \in \mathbb { R } ^ { 2 d }$ be the current query representation which was most recently used by the paragraph retriever to score the paragraphs in the corpus. The multi-step-reasoner also has access to the reader state which is computed from the hidden memory vectors of the reader. The reader state captures the current information that the reader has encoded after reading the paragraphs that was sent by the retriever. Next we show how the reader state is computed.
+
+Span extractive machine reading architectures compute a hidden representation for each token in the paragraph. Our framework needs access to these hidden representations to compute the reader state.
+
+Let $\mathbf { m _ { j } } \in \mathbb { R } ^ { 2 p }$ be the hidden vector associated with the $j { \cdot }$ -th token in the paragraph. Let $\mathbf { L } \in \mathbb { R } ^ { 2 p }$ be the final query representation of the reader model. $\mathbf { L }$ is usually created by some pooling operation on the hidden representation of each question token. The reader state $\mathbf { S } \in \mathbb { R } ^ { \sum p }$ is computed from each of the hidden vectors $\mathbf { m } _ { \mathrm { j } }$ and $\mathbf { L }$ by first computing soft-attention weights between each paragraph token, followed by combining each $\mathbf { m _ { j } }$ with the soft attention weights.
+
+$$
+\alpha _ { \mathbf { j } } = \frac { \exp \left( \mathbf { m _ { j } } \cdot \mathbf { L } \right) } { \sum _ { j ^ { \prime } } \exp \left( \mathbf { m _ { j } ^ { \prime } } \cdot \mathbf { L } \right) } \qquad \mathbf { S } = \sum _ { j } \left( \alpha _ { \mathbf { j } } \cdot \mathbf { m _ { j } } \right)
+$$
+
+Finally, the new reformulated query $\mathbf { q } _ { \mathbf { t } + \mathbf { 1 } } \in \mathbb { R } ^ { 2 d }$ for the paragraph retriever is calculated by the multi-step-reasoner module as follows —
+
+$$
+\begin{array} { r } { \mathbf { q } _ { \mathbf { t } + 1 } ^ { ' } = \mathbf { G } \mathbf { R } \mathbf { U } \left( \mathbf { q } _ { \mathbf { t } } , \mathbf { S } \right) } \\ { \mathbf { q } _ { \mathbf { t } + 1 } = \mathrm { F F N } \left( \mathbf { q } _ { \mathbf { t } + 1 } ^ { ' } \right) } \end{array}
+$$
+
+In our architecture, we used a 3 layer GRU network, followed by a one layer feed forward network (FFN) with a ReLU non-linearity. The gated update ensures that relevant information from ${ \bf q _ { t } }$ is preserved and new and useful information from the reader state $\mathbf { s }$ is added to the reformulated query.
+
+# 3.1 TRAINING
+
+There exists no supervision for training the query reformulation of the multi-step-reasoner. Instead, we employ reinforcement learning (RL) and train it by how well the reader performs after reading the new set of paragraphs retrieved by the modified query. We define the problem as a deterministic finite horizon Partially Observed Markov decision process (POMDP). The components of POMDP are —
+
+States. A state in the state space consists of the entire text corpora, the query, the answer, and $k$ selected paragraphs. The reader is part of the environment and is fully described given the current state, i.e. selected paragraphs and the query.
+
+Observations. The agent only observes a function of the current state. In particular, to the agent only the query vector and the memory of the reader model is shown, which are a function of the current state. Intuitively, this represents the information encoded by the machine reader model after reading the top $k$ paragraphs sent by the retriever in current step.
+
+Actions. The set of all paragraphs in the text corpora forms the action space. The retriever scores all paragraphs w.r.t the current query and selects the top $k$ paragraphs to send to the reader model. We treat $k$ as a hyper-parameter in our experiments.
+
+Reward. At every step, the reward is measured by how well the answer extracted by the reader model matches to the ground-truth answer. We use the $\mathrm { F } _ { 1 }$ score (calculated by word overlap between prediction and ground-truth) as the reward at each step.
+
+Transition. The environment evolves deterministically after reading the paragraphs sent by the retriever.
+
+Our policy $\pi$ is parameterized by the GRU and the FFN of the multi-step-reasoner. Let $r _ { t }$ denote the reward $F _ { 1 }$ score) returned by the environment at time $t$ . We directly optimize the parameters to maximize the expected reward given by — $\begin{array} { r } { J ( \boldsymbol { \Theta } ) = \mathbb { E } _ { \underline { { \pi } } } \left[ \sum _ { t = 1 } ^ { T } r _ { t } \right] } \end{array}$ . Here $T$ denotes the number of steps of interactions between the retriever and the reader. We treat the reward at each step equally and do not apply any discounting. Motivated by the REINFORCE (Williams, 1992) algorithm, we compute the gradient of our objective as
+
+$$
+\nabla _ { \boldsymbol { \Theta } } J ( \boldsymbol { \Theta } ) = \mathbb { E } _ { \boldsymbol { \pi } } \left[ \sum _ { t = 1 } ^ { T } \boldsymbol { r } _ { t } \cdot \log ( \pi _ { \boldsymbol { \Theta } } ( p _ { t } \mid q ) ) \right]
+$$
+
+Here, $p _ { t }$ is the top-ranked paragraph returned by the retriever at time $t$ and the probability that the current policy assigns to $p _ { t }$ is computed by normalizing the scores with a softmax. It is usual practice to add a variance reduction baseline (e.g. average of rewards in the minibatch) for stable training, but we found this significantly degrades the final performance. We think this is because, in QA, a minibatch consists of questions of varying difficulty and hence the rewards in a batch itself have high variance. This is similar to findings by Shen et al. (2017) for closed domain-QA (e.g. SQUAD).
+
+Pretraining the multi-step-reasoner. We also find that pre-training the multi-step-reasoner before fine tuning with RL to be effective. We train to rank the similarity between the reformulated query vector and one of the distantly-supervised correct paragraph vectors higher than the score of a randomly sampled paragraph vector. Specifically, let q denote the query vector, $\mathbf { p } ^ { * } , \mathbf { p } ^ { \prime }$ denote the paragraph representation of paragraphs containing the correct answer string and a random sampled paragraph respectively. We follow the Bayesian Personalized Ranking approach of Rendle et al. (2009) and maximize $\log ( \sigma ( \mathbf { q } ^ { \top } \mathbf { p } ^ { * } - \mathbf { q } ^ { \top } \mathbf { p } ^ { ' } ) )$ . The paragraph representations $\mathbf { p } ^ { * } , \mathbf { p } ^ { \prime }$ are kept fixed and gradient only flows through $\mathbf { q }$ to the parameters of the multi-step-reasoner.
+
+# 3.2 PUTTING IT ALL TOGETHER
+
+Our open-domain architecture is summarized above in Algorithm 1. Given a large text corpora (as a list of paragraphs), the corresponding paragraph embeddings (which can be trained by the procedure in $( \ S 2 . 1 ) )$ and hyper-parameters $( \mathrm { T } , k )$ , our model $\mathcal { M }$ returns a text span $a$ as answer. The multi-step interaction between the retriever and reader can be best understood by the for loop in line 2 of algorithm 1. The initial query ${ \bf q 0 }$ is first used to rank all the paragraphs in the corpus (line 3), followed by which the top $k$ paragraphs are sent to the reader (line 4). The reader returns the answer span (with an associated score for the span) and also its internal state (line 5). The GRU network then takes in the current query and the reader state to produce the updated query which is then passed to the retriever (line 6). The retriever uses this updated query to again re-rank the paragraphs and the entire process is repeated for $\mathrm { T }$ steps. At the end of $\mathrm { T }$ steps, the model returns the span with the highest score returned by the reader model. The reader is trained using supervised learning (using the correct spans as supervision) and the parameters of the GRU network are trained using reinforcement learning. During training, we first pre-train the reader model by setting the number of multi-step reasoning steps $( \mathrm { T } = 1 )$ ). After the training converges, we freeze the parameters of the reader model and train the parameters of the GRU network using policy gradients. The output of the reader model is used to generate the reward which is used to train the policy network.
+
+<table><tr><td colspan="2">Algorithm 1 Multi-step reasoning for open-domain QA</td></tr><tr><td colspan="2">Input: Question text Qtext, Text corpus (as a list of paragraphs)T,Paragraph embeddings P (list of paragraph embeddings for each paragraph in T),Model M, Number of multi-steps T, number</td></tr><tr><td>of top-ranked paragraphs k Output: Answer span a</td><td></td></tr><tr><td>1: qo ← encode_query(Qtext) 2: for t in range(T) do</td><td>#(2.1)</td></tr><tr><td>3: {𝑝1,P2,...Pk} ←M.retriever.score_paras(qt,P,k) # 4:</td><td># each pi denotes a paragraph id # get text for the top paragraphs</td></tr><tr><td>5: at,St,St ← M.reader.read(Plexk,Qtext)</td><td># (§ 2.2); St denotes reader state</td></tr><tr><td></td><td># at denotes answer span</td></tr><tr><td>6:qt ← M.multi_step-reasoner.GRU(qt,St)</td><td># st denotes the score of the span</td></tr><tr><td></td><td># (§ 3); Query reformulation step</td></tr><tr><td>7: end for</td><td></td></tr><tr><td>8:return answer span a with highest score</td><td></td></tr></table>
+
+# 4 RELATED WORK
+
+Open domain QA is a well-established task that dates back to few decades of reasearch. For example the BASEBALL system (Green Jr et al., 1961) aimed at answering open domain question albeit for a specific domain. Open-domain QA has been popularized by the Trec-8 task (Voorhees et al., 1999) and has recently gained significant traction due to the introduction of various datasets (Dunn et al., 2017; Dhingra et al., 2017; Joshi et al., 2017). In many open-domain systems (Chen et al., 2017), the retriever is a simple IR based system (e.g. tfidf retriever) with no trainable parameters and hence the retriever cannot overcome from its mistakes. Recent work such as $\mathbb { R } ^ { 3 }$ (Wang et al., 2018a), DS-QA (Lin et al., 2018) use a trained retriever and have shown improvement in performance. However they form query dependent paragraph representation and such architectures will not scale to full open-domain settings where the retriever has to rank millions of paragraphs. and neither do they support iterative reasoning thereby failing to recover from any mistakes made by the ranker or where evidence needs to be aggregated across multiple paragraphs.
+
+Query Reformulation by augmenting the original query with terms from the top- $k$ retrieved document (Xu & Croft, 1996; Lavrenko & Croft, 2001) has proven to be very effective in information retrieval. Instead of using such automatic relevance feedback, Nogueira & Cho (2017) train a query reformulation model to maximize the recall of a IR system using RL and Pfeiffer et al. (2018) showed that query refinement is effective for IR in bio-medical domain. The main difference between this work and ours is that our model directly optimizes to improve the performance of a question answering system. However, as we show, we still see an improvement in the recall of our retriever $( \ S 5 . 1 )$ . Perhaps the most related to our work is Active Question Answering (AQA) (Buck et al., 2018), which use reformulation of the natural language query to improve the performance of a BiDAF reader model on SEARCHQA. The main difference between AQA is that we reformulate the query in vector space. We compare with AQA and show that our model achieves significantly better performance.
+
+Iterative Reasoning has shown significant improvements in models using memory networks (Sukhbaatar et al., 2015; Miller et al., 2016) for question answering in text and knowledge bases (Das et al., 2017; Yang et al., 2017; Das et al., 2018). Our model can be viewed as a type of controller update step of memory network type of inference. Recently, iterative reasoning has shown to be effective in reading comprehension in single paragraph setting, where the model reads the same paragraph iteratively (Shen et al., 2017; Liu et al., 2017). Our work can be seen as a strict generalization of these in a more realistic, open-domain setting.
+
+Nearest Neighbor Search - Computing fast nearest neighbor (NN) search is a fundamental requirement in many applications. We used exact k-NN search using SGTree (Zaheer et al., 2019) which has been shown to perform better than other exact k-NN strategies such as Cover Tree (Beygelzimer et al., 2006), P-DCI (Li & Malik, 2017) and other approximate NN search techniques such as RP-Tree (Dasgupta & Sinha, 2013), HNSW (Malkov & Yashunin, 2018). In general, our proposed multi-step-reasoner framework is not coupled to any particular kind of $\mathbf { k }$ -NN technique.
+
+Table 2: Performance on test sets for various datasets   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Quasar-T</td><td colspan="2">SearchQA</td><td colspan="2">TRIVIAQA-unfiltered</td><td colspan="2">SQUAD-open</td></tr><tr><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>GA (Dhingra et al., 2016)</td><td>26.4</td><td>26.4</td><td>-</td><td>-</td><td>-</td><td></td><td>=</td><td>-</td></tr><tr><td>BIDAF (Seo et al., 2017)</td><td>25.9</td><td>28.5</td><td>28.6</td><td>34.6</td><td></td><td></td><td></td><td></td></tr><tr><td>AQA (Buck et al.,2018)</td><td>-</td><td>-</td><td>40.5</td><td>47.4</td><td>=</td><td></td><td></td><td>1</td></tr><tr><td>R (Wang et al.,2018a)</td><td>35.3</td><td>41.7</td><td>49.0</td><td>55.3</td><td>47.3</td><td>53.7</td><td>29.1</td><td>37.5</td></tr><tr><td>DS-QA*(Lin et al., 2018)</td><td>37.27</td><td>43.63</td><td>58.5</td><td>64.5</td><td>48.7</td><td>56.3</td><td>28.7</td><td>36.6</td></tr><tr><td>MINIMAL (Min etal.,2018)</td><td>=</td><td>-</td><td>=</td><td>=</td><td>-</td><td>-</td><td>34.7</td><td>42.5</td></tr><tr><td>Dr.QA baseline</td><td>36.87</td><td>45.49</td><td>51.36</td><td>58.24</td><td>48.00</td><td>52.13</td><td>27.1</td><td>-</td></tr><tr><td>multi-step-reasoner (Dr.QA)</td><td>39.53</td><td>46.67</td><td>55.01</td><td>61.61</td><td>55.93</td><td>61.66</td><td>31.93</td><td>39.22</td></tr><tr><td>multi-step-reasoner (BiDAF)</td><td>40.63</td><td>46.97</td><td>56.26</td><td>61.36</td><td>55.91</td><td>61.65</td><td></td><td>-</td></tr><tr><td>DocumentQA**(Clark &amp; Gardner,2018)</td><td>-</td><td>-</td><td>-</td><td>=</td><td>61.56</td><td>68.03</td><td>=</td><td>1</td></tr></table>
+
+∗ Despite our best efforts, we could not reproduce the results of Ds-QA using their code and hyperparameter settings for Quasar-T. ∗∗ The results on the test set of TRIVIAQA-unfiltered were not reported in the original paper. Results obtained from authors via e-mail.
+
+<table><tr><td>Model</td><td>P@1</td><td>P@3</td><td>P@5</td></tr><tr><td>R³ (Wang et al., 2018a)</td><td>40.3</td><td>51.3</td><td>54.5</td></tr><tr><td>Our Retriever (initial)</td><td>35.7</td><td>49.6</td><td>56.3</td></tr><tr><td>+ multi-step (7 steps)</td><td>42.9</td><td>55.5</td><td>59.3</td></tr></table>
+
+Table 3: Retrieval performance on QUASAR-T. The match-LSTM based retriever of $\mathbb { R } ^ { 3 }$ is a more powerful model than our intial retrieval model. However, after few steps of multi-step-reasoner, the performance increases suggesting that re-ranking via query-reformulation is retrieving relevant evidence from the corpus. We report the $\mathrm { P @ } k$ on the last step.
+
+![](images/20da1449de003db223341121ee8d3b9b0b0267522e165d0e62478a9cbc668189.jpg)  
+Figure 2: Scalability of retriever.
+
+# 5 EXPERIMENTS
+
+We now present experiments to show the effectiveness of each component of our framework. We experiment on the following large open-domain QA datasets — (a) TRIVIAQA-unfiltered– a version of TRIVIAQA (Joshi et al., 2017) built for open-domain QA. It has much more number of paragraphs than the web/wiki setting of TRIVIAQA. Moreover, there is no guarantee that every document in the evidence will contain the answer making this setting more challenging. (b) TRIVIAQA-open– To test our framework for large scale setting, we combine all evidence for every question in the development set. This resulted in a corpus containing 1.68M paragraphs per question. (c)
+
+<table><tr><td>Datasets</td><td>#q(test)</td><td>#p/q(test)</td></tr><tr><td>SEARCHQA</td><td>27,247</td><td>49.6</td></tr><tr><td>QUASAR-T</td><td>3.000</td><td>99.8</td></tr><tr><td>SQUAD-open</td><td>10,570</td><td>115.6</td></tr><tr><td>TRIVIAQA-unfiltered</td><td>10,790</td><td>149</td></tr><tr><td>TRIVIAQA-open</td><td>11,274</td><td>1,684,193</td></tr></table>
+
+Table 1: Statistics of various dataset. The second column shows the number of paragraphs for each query.
+
+SEARCHQA (Dunn et al., 2017) – is another open-domain dataset which consists of question-answer pairs crawled from the J! archive. The paragraphs are obtained from 50 web snippets retrieved using the Google search API. (d) QUASAR-T (Dhingra et al., 2017) – consists of 43K open-domain questions where the paragraphs are obtained from the ClueWeb data source. (e) SQUAD-open– We also experimented on the open domain version of the SQUAD dataset. For fair comparison to baselines, our evidence corpus was created by retrieving the top-5 wikipedia documents as returned by the pipeline of Chen et al. (2017). The datasets are summarized in table 1.
+
+# 5.1 PERFORMANCE OF PARAGRAPH RETRIEVER
+
+We first investigate the performance of our paragraph retriever model $( \ S 2 . 1 )$ . Our retriever is based on inner product between the query and pre-computed paragraph vectors. This architecture, although more scalable, is less powerful than the retrievers of $\mathbb { R } ^ { 3 }$ and DS-QA which compute query-dependent passage representation via soft alignment (attention) before encoding with a bi-LSTM. Results in table 3 indeed show that retriever of $\mathbb { R } ^ { 3 }$ has better $\mathbf { P } @ k$ than our retriever. We also measure the performance of our retriever after few steps (#steps $= 7$ ) of interaction between the retriever and reader. As we can see from table 3, the query reformulation has resulted in better re-ranking and hence an overall improved performance of the retriever.
+
+To test for scalability in open-domain settings, we conduct a synthetic experiment. We plot the wall-clock time (in seconds) taken by the retriever to score and rank paragraphs with a query. To test for scalability, we increase the number of paragraphs ranging from 500 to 100 million and test on a single Titan-X GPU. For our baseline, we use the GPU implementation of the retriever of DS-QA (Lin et al., 2018). For our model, we test on three variants — (a) inner product on GPU, (b) inner-product on CPU and (c) inner-product using SG-Tree. Figure 2 shows the results. Our retriever model on GPU is faster than DS-QA, since the latter perform much more computation compared to just inner-product in our case. Moreover, DS-QA quickly uses up all the available memory and throws a memory error (OOM) by just 100K paragraphs. The inner product operation scales up to 1M paragraph before going OOM. SG-Tree shows very impressive performance even though it operates on CPU and consistently outperforms dot product operation on the CPU.
+
+# 5.2 EFFECTIVENESS OF MULTI-STEP-REASONER
+
+Next we investigate the improvements in QA performance due to multi-step-reasoner. We report the commonly used exact-match (EM) and F1 score on each dataset.
+
+Performance on benchmark datasets. Table 2 compares the performance of our model with various competitive baselines on four open-domain QA datasets. One of the main observation is that combining multi-step-reasoner with the base Dr.QA reader (Chen et al., 2017) always leads to improved performance. We also perform competitively to most baselines across all datasets.
+
+Figure 3 shows the relative improvements our models achieve on QUASAR-T, SEARCHQA and TRIVIAQA-unfiltered with varying number of steps of interaction between the retriever and the reader. The key takeaway of this experiment is that multiple steps of interaction uniformly increases performance over base model (with no interaction). Different datasets have varying level of difficulties, however, the performance reaches its peak around 5 to 7 steps and does not provide much benefit on further increasing the number of steps.
+
+![](images/2fa6baa6ba3590d2c2b4844ec161d26beda7b852b1e264151fcbd68b9dcbb19a.jpg)  
+Figure 3: F1 score w.r.t number of steps.
+
+# Large scale experiment on TRIVIAQA-open. The benchmark datasets for open-domain QA have
+
+on an average hundred paragraphs for each question (Table 1). In real open-domain settings, the size of the evidence corpus might be much bigger. To test our model for the same, we created the TRIVIAQA-open setting, in which for each query we combined all the paragraphs in the development set, resulting in 1.6M paragraphs per query. We want to emphasize that the baseline models such as $\mathbb { R } ^ { 3 }$ and DS-QA will not scale to this large setting. The baseline $\mathrm { D r Q A }$ . model with no interaction between the retriever and reader get a score of $\mathrm { E M } = 3 7 . 4 5$ and $\mathrm { F } 1 = 4 2 . 1 6$ . The same model with 3 steps of interaction achieves a score of $\mathrm { E M } = 3 9 . 7 6$ and $\mathbf { F } 1 = \mathbf { 4 4 . 3 0 }$ . The key takeaways from this experiment are — (a) our framework can scale to settings containing millions of paragraphs, (b) iterative interaction still increase performance even in large scale settings, (c) the overall performance has significantly decreased (from 61 to 44.3 F1), suggesting that large context in open-domain QA is very challenging and should be an active area of research with significant scope for improvement.
+
+# 5.3 ANALYSIS OF RESULTS
+
+This section does further analysis of the results of the model. Specifically we are interested in analyzing if our method is able to gather more relevant evidence as we increase the number of steps of interaction between the retriever and the reader. We conduct this analysis on the development set of SEARCHQA (containing 13,393 queries) and to simplify analysis, we make the retriever choose the top scored single paragraph to send to the reader, at each step. The results are noted in table 4. As we can see from row 1 of table 4, on increasing steps of interaction, the quality of retrieved paragraphs
+
+![](images/85cf4c84edc73749719a95a1cae7d89b0ec2a518947d78943f61a83ec19dda7e.jpg)  
+Figure 4: Examples of how multi-step-reasoner iteratively modifies the query by reading context to find more relevant paragraphs. Figure (left) shows an example where the initial retrieved context did not have the answer but the context provided enough hint to get more relevant paragraph in the next step. In figure (right), both the retrieved paragraph have the answer string leading to a boost in the score of the answer span because of score aggregation of spans (§2.2).
+
+<table><tr><td></td><td colspan="3"># steps of interaction</td></tr><tr><td></td><td>3</td><td>5</td><td>7</td></tr><tr><td>#queries where initial retrieved para was incor- rect but correct para was retrieved later</td><td>1047</td><td>1199</td><td>1270</td></tr><tr><td>#queries where correct para wasn&#x27;t retrieved at all</td><td>3783</td><td>3594</td><td>3505</td></tr><tr><td># queries where initial answer was incorrect but recoveredlater</td><td>490</td><td>612</td><td>586</td></tr><tr><td>Avg. number of unique paragraphs read across all steps</td><td>1.99</td><td>2.38</td><td>3.65</td></tr></table>
+
+Table 4: Analysis of results on the dev. set of SEARCHQA as we increase the number of steps of interaction between the retriever and reader. The retriever at each step sends top-1 paragraph to the reader. A paragraph is correct if it contains the correct answer string.
+
+becomes better, i.e. even though the correct paragraph (containing the answer string) was not retrieved in the first step, the retriever is able to fetch relevant paragraphs later. It is also unsurprising to see, that when correct paragraphs are retrieved, the performance of the reader also increases. To check if the our policy was exploring and retrieving different paragraphs, we counted the mean number of unique paragraphs retrieved across all steps and found that it is high (around 2) when #steps of interaction is small as 3, suggesting that the policy chooses to explore initially. As the number of steps is increased, it increases at slower rate suggesting that if the policy has already found good paragraphs for the reader, it chooses to exploit them rather than choosing to explore.
+
+Figure 4 shows two instances where iterative interaction is helpful. In figure to the left, the retriever is initially unable to find a paragraph that directly answers the question, however it finds a paragraph which gives a different name for the disease allowing it to find a more relevant paragraph that directly answers the query. In the figure to the right, after the query reformulation, both the retrieved paragraphs have the correct answer string. Since we aggregate (sum) the scores of spans, this leads to an increase in the score of the right answer span (Demeter) to be the maximum.
+
+# 6 CONCLUSION
+
+This paper introduces a new framework for open-domain question answering in which the retriever and the reader iteratively interact with each other. The resulting framework improved performance of machine reading over the base reader model uniformly across four open-domain QA datasets. We also show that our fast retrieval method can scale upto millions of paragraphs, much beyond the current capability of existing open-domain systems with a trained retriever module. Finally, we show that our method is agnostic to the architecture of the machine reading system provided we have access to the token level hidden representations of the reader. Our method brings an increase in performance to two popular and widely used neural machine reading architectures, Dr.QA and BiDAF.
+
+# ACKNOWLEDGEMENTS
+
+This work is funded in part by the Center for Data Science and the Center for Intelligent Information Retrieval, and in part by the National Science Foundation under Grant No. IIS-1514053 and in part by the International Business Machines Corporation Cognitive Horizons Network agreement number W1668553 and in part by the Chan Zuckerberg Initiative under the project Scientific Knowledge Base Construction. Any opinions, findings and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect those of the sponsor.
+
+# REFERENCES
+
+Yoram Bachrach, Yehuda Finkelstein, Ran Gilad-Bachrach, Liran Katzir, Noam Koenigstein, Nir Nice, and Ulrich Paquet. Speeding up the xbox recommender system using a euclidean transformation for inner-product spaces. In RecSys, 2014.
+
+Alina Beygelzimer, Sham Kakade, and John Langford. Cover trees for nearest neighbor. In ICML, 2006.
+
+Penny A Bishop, Cynthia Reyes, and Susanna W Pflaum. Read smarter, not harder: Global reading comprehension strategies. The Reading Teacher, 2006.
+
+Christian Buck, Jannis Bulian, Massimiliano Ciaramita, Andrea Gesmundo, Neil Houlsby, Wojciech Gajewski, and Wei Wang. Ask the right questions: Active question reformulation with reinforcement learning. In ICLR, 2018.
+
+Kris Cao, Angeliki Lazaridou, Marc Lanctot, Joel Z Leibo, Karl Tuyls, and Stephen Clark. Emergent communication through negotiation. arXiv preprint arXiv:1804.03980, 2018.
+
+Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. Reading wikipedia to answer opendomain questions. In ACL, 2017.
+
+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. arXiv preprint arXiv:1406.1078, 2014.
+
+Christopher Clark and Matt Gardner. Simple and effective multi-paragraph reading comprehension. In ACL, 2018.
+
+Dick Cunningham and Scott L Shablak. Selective reading guide-o-rama: The content teacher’s best friend. Journal of Reading, 1975.
+
+Rajarshi Das, Manzil Zaheer, Siva Reddy, and Andrew McCallum. Question answering on knowledge bases and text using universal schema and memory networks. In ACL, 2017.
+
+Rajarshi Das, Shehzaad Dhuliawala, Manzil Zaheer, Luke Vilnis, Ishan Durugkar, Akshay Krishnamurthy, Alex Smola, and Andrew McCallum. Go for a walk and arrive at the answer: Reasoning over paths in knowledge bases using reinforcement learning. In ICLR, 2018.
+
+Sanjoy Dasgupta and Kaushik Sinha. Randomized partition trees for exact nearest neighbor search. In COLT, 2013.
+
+Bhuwan Dhingra, Hanxiao Liu, Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Gatedattention readers for text comprehension. arXiv preprint arXiv:1606.01549, 2016.
+
+Bhuwan Dhingra, Kathryn Mazaitis, and William W Cohen. Quasar: Datasets for question answering by search and reading. arXiv preprint arXiv:1707.03904, 2017.
+
+Geoffrey B Duggan and Stephen J Payne. Text skimming: The process and effectiveness of foraging through text under time pressure. Journal of Experimental Psychology: Applied, 2009.
+
+Matthew Dunn, Levent Sagun, Mike Higgins, V Ugur Guney, Volkan Cirik, and Kyunghyun Cho. Searchqa: A new q&a dataset augmented with context from a search engine. arXiv preprint arXiv:1704.05179, 2017.
+
+Bert F Green Jr, Alice K Wolf, Carol Chomsky, and Kenneth Laughery. Baseball: an automatic question-answerer. In IRE-AIEE-ACM, 1961.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 1997.
+
+Phu Mon Htut, Samuel R Bowman, and Kyunghyun Cho. Training a ranking function for open-domain question answering. arXiv preprint arXiv:1804.04264, 2018.
+
+Mandar Joshi, Eunsol Choi, Daniel S Weld, and Luke Zettlemoyer. Triviaqa: A large scale distantly supervised challenge dataset for reading comprehension. In ACL, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Victor Lavrenko and W Bruce Croft. Relevance-based language models. In SIGIR, 2001.
+
+Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In ICLR, 2017.
+
+Jason Lee, Kyunghyun Cho, Jason Weston, and Douwe Kiela. Emergent translation in multi-agent communication. In ICLR, 2018.
+
+Ke Li and Jitendra Malik. Fast k-nearest neighbour search via prioritized dci. In ICML, 2017.
+
+Yankai Lin, Haozhe Ji, Zhiyuan Liu, and Maosong Sun. Denoising distantly supervised open-domain question answering. In ACL, 2018.
+
+Xiaodong Liu, Yelong Shen, Kevin Duh, and Jianfeng Gao. Stochastic answer networks for machine reading comprehension. arXiv preprint arXiv:1712.03556, 2017.
+
+Yury A Malkov and Dmitry A Yashunin. Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs. TPAMI, 2018.
+
+Alexander Miller, Adam Fisch, Jesse Dodge, Amir-Hossein Karimi, Antoine Bordes, and Jason Weston. Key-value memory networks for directly reading documents. arXiv preprint arXiv:1606.03126, 2016.
+
+Sewon Min, Victor Zhong, Richard Socher, and Caiming Xiong. Efficient and robust question answering from minimal context over documents. arXiv preprint arXiv:1805.08092, 2018.
+
+Mike Mintz, Steven Bills, Rion Snow, and Dan Jurafsky. Distant supervision for relation extraction without labeled data. In ACL, 2009.
+
+Rodrigo Nogueira and Kyunghyun Cho. Task-oriented query reformulation with reinforcement learning. In EMNLP, 2017.
+
+Jonas Pfeiffer, Samuel Broscheit, Rainer Gemulla, and Mathias Goschl. A neural autoencoder ¨ approach for document ranking and query refinement in pharmacogenomic information retrieval. In BioNLP workshop, ACL, 2018.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $^ { 1 0 0 , 0 0 0 + }$ questions for machine comprehension of text. In EMNLP, 2016.
+
+Steffen Rendle, Christoph Freudenthaler, Zeno Gantner, and Lars Schmidt-Thieme. Bpr: Bayesian personalized ranking from implicit feedback. In UAI, 2009.
+
+Minjoon Seo, Aniruddha Kembhavi, Ali Farhadi, and Hannaneh Hajishirzi. Bidirectional attention flow for machine comprehension. In ICLR, 2017.
+
+Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. In KDD, 2017.
+
+Sainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end memory networks. In NIPS, 2015.
+
+Swabha Swayamdipta, Ankur P Parikh, and Tom Kwiatkowski. Multi-mention learning for reading comprehension with neural cascades. In ICLR, 2018.
+
+Adam Trischler, Tong Wang, Xingdi Yuan, Justin Harris, Alessandro Sordoni, Philip Bachman, and Kaheer Suleman. Newsqa: A machine comprehension dataset. arXiv preprint arXiv:1611.09830, 2016.
+
+Ellen M Voorhees, others, et al. The trec-8 question answering track report. In Trec, 1999.
+
+Shuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. In ICLR, 2017.
+
+Shuohang Wang, Mo Yu, Xiaoxiao Guo, Zhiguo Wang, Tim Klinger, Wei Zhang, Shiyu Chang, Gerald Tesauro, Bowen Zhou, and Jing Jiang. R3: Reinforced ranker-reader for open-domain question answering. In AAAI, 2018a.
+
+Shuohang Wang, Mo Yu, Jing Jiang, Wei Zhang, Xiaoxiao Guo, Shiyu Chang, Zhiguo Wang, Tim Klinger, Gerald Tesauro, and Murray Campbell. Evidence aggregation for answer re-ranking in open-domain question answering. In ICLR, 2018b.
+
+Wei Wang, Ming Yan, and Chen Wu. Multi-granularity hierarchical attention fusion networks for reading comprehension and question answering. In ACL, 2018c.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 1992.
+
+Caiming Xiong, Victor Zhong, and Richard Socher. Dynamic coattention networks for question answering. In ICLR, 2017.
+
+Jinxi Xu and W Bruce Croft. Quary expansion using local and global document analysis. In SIGIR, 1996.
+
+Fan Yang, Zhilin Yang, and William W Cohen. Differentiable learning of logical rules for knowledge base reasoning. In NeurIPS, 2017.
+
+Adams Wei Yu, David Dohan, Minh-Thang Luong, Rui Zhao, Kai Chen, Mohammad Norouzi, and Quoc V Le. Qanet: Combining local convolution with global self-attention for reading comprehension. In ICLR, 2018.
+
+Manzil Zaheer, Guru Guruganesh, Golan Levin, and Alex Smola. Terrapattern: A nearest neighbor search service. In Arxiv, 2019.

parse/train/HkfPSh05K7/HkfPSh05K7_content_list.json

@@ -0,0 +1,1675 @@
+[
+    {
+        "type": "text",
+        "text": "MULTI-STEP RETRIEVER-READER INTERACTION FOR SCALABLE OPEN-DOMAIN QUESTION ANSWERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rajarshi Das1, Shehzaad Dhuliawala2, Manzil Zaheer3 & Andrew McCallum1 ",
+        "bbox": [
+            183,
+            171,
+            725,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{rajarshi,mccallum}@cs.umass.edu   \nshehzaad.dhuliawala@microsoft.com, manzil@zaheer.ml   \n1 University of Massachusetts, Amherst, 2 Microsoft Research, Montreal ´   \n3 Google AI, Mountain View ",
+        "bbox": [
+            184,
+            189,
+            658,
+            244
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            282,
+            544,
+            297
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces a new framework for open-domain question answering in which the retriever and the reader iteratively interact with each other. The framework is agnostic to the architecture of the machine reading model, only requiring access to the token-level hidden representations of the reader. The retriever uses fast nearest neighbor search to scale to corpora containing millions of paragraphs. A gated recurrent unit updates the query at each step conditioned on the state of the reader and the reformulated query is used to re-rank the paragraphs by the retriever. We conduct analysis and show that iterative interaction helps in retrieving informative paragraphs from the corpus. Finally, we show that our multistep-reasoning framework brings consistent improvement when applied to two widely used reader architectures (DR.QA and BIDAF) on various large open-domain datasets — TRIVIAQA-unfiltered, QUASAR-T, SEARCHQA, and SQUAD-open1. ",
+        "bbox": [
+            233,
+            313,
+            766,
+            479
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            506,
+            334,
+            522
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Open-domain question answering (QA) (Voorhees et al., 1999) involves a retriever for selecting relevant context from a large corpora of text (e.g. Wikipedia) and a machine reading comprehension (MRC) model for ‘reasoning’ on the retrieved context. A lot of effort has been put into designing sophisticated neural MRC architectures for reading short context (e.g. a single paragraph), with much success (Wang & Jiang, 2017; Seo et al., 2017; Xiong et al., 2017; Wang et al., 2018c; Yu et al., 2018, inter alia). However, the performance of such systems degrades significantly when combined with a retriever in open domain settings. For example, the exact match accuracy of $\\mathrm { D r Q A }$ (Chen et al., 2017), on the SQUAD dataset (Rajpurkar et al., 2016) degrades from $6 9 . 5 \\%$ to $2 8 . 4 \\%$ in open-domain settings. The primary reason for this degradation in performance is due to the retriever’s failure to find the relevant paragraphs for the machine reading model (Htut et al., 2018). ",
+        "bbox": [
+            174,
+            537,
+            825,
+            678
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose the following two desiderata for a general purpose open-domain QA system - (a) The retriever model should be fast, since it has to find the relevant context from a very large text corpora and give it to the more sophisticated and computationally expensive MRC model (b) Secondly, the retriever and reader models should be interactive, i.e. if the reader model is unable to find the answer from the initial retrieved context, the retriever should be able to learn to provide more relevant context to the reader. Open-domain QA systems such as $\\mathbb { R } ^ { 3 }$ (Wang et al., 2018a) and DS-QA (Lin et al., 2018) have sophisticated retriever models where the reader and retriever are jointly trained. However, their retriever computes question-dependent paragraph representation which is then encoded by running an expensive recurrent neural network over the tokens in the paragraph. Since the retriever has to rank a lot of paragraphs, this design does not scale to large corporas. One the other hand, the retriever model of QA systems such as DrQA (Chen et al., 2017) is based on a tf-idf retriever, but they lack trainable parameters and are consequently unable to recover from mistakes. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            851
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces an open domain architecture in which the retriever and reader iteratively interact with each other. Our model first pre-computes and caches representation of context (paragraph). These representations are independent of the query unlike recent architectures (Wang et al., 2018a; ",
+        "bbox": [
+            176,
+            858,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/82d26f0dd95fab7f7d701a2a5b76857bd179a094a0d0730be65ce3c615dfc9d7.jpg",
+        "image_caption": [
+            "Figure 1: Our framework unrolled for two steps. The initial query is encoded and the retriever sends the top- $k$ paragraphs to the reader. The multi-step-reasoner component of our model takes in the internal state of the reader model and the previous query vector and does a gated update to produce a reformulated query. This new query vector is used by the retriever to re-rank the paragraphs and send different paragraphs to the reader. Thus the multi-step-reasoner facilitates iterative interaction between the retriever (search engine) and the reader (QA model) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            65,
+            772,
+            402
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lin et al., 2018) and hence can be computed and stored offline. Given an input question, the retriever performs fast inner product search to find the most relevant contexts. The highest ranked contexts are then passed to the neural MRC model. Our architecture is agnostic to the choice of the reader architecture and we show that multi-step-reasoning increases performance of two state-of-the-art MRC architectures - DrQA (Chen et al., 2017) and BiDAF (Seo et al., 2017). ",
+        "bbox": [
+            174,
+            540,
+            825,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It is possible that the answer might not exist in the initial retrieved paragraphs or that the model would need to combine information across multiple paragraphs (Wang et al., 2018b). We equip the reader with an additional gated recurrent unit (Cho et al., 2014) which takes in the state of the reader and the current query vector and generates a new query vector. This new query vector is then used by the retriever model to re-rank the context. This allows the model to read new paragraphs and combine evidence across multiple paragraphs. Since the retriever makes a ‘hard selection’ of paragraphs to send to the reader, we train the retriever and the reader jointly using reinforcement learning. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            715
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our architecture draws inspiration from how students are instructed to take reading comprehension tests (Cunningham & Shablak, 1975; Bishop et al., 2006; Duggan & Payne, 2009). Given a document containing multiple paragraphs and a set of questions which can be answered from the document, (a) the student quickly skims the paragraphs, (b) then for each question, she finds the most relevant paragraphs that she thinks will answer the question. (c) She then carefully reads the chosen paragraph to answer the question (d) However, if the chosen paragraph does not answer the question, then given the question and the knowledge of what she has read till now, she decides which paragraph to read next. Step (a) is akin to our model encoding and storing the question independent paragraph representations and step (b) corresponds to the inner product search to find the relevant context. The reading of the context by the sophisticated neural machine reader corresponds to step (c) and the last step corresponds to the iterative (multi-step) interaction between the retriever and the reader. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, this paper makes the following contributions: (a) We introduce a new framework for open-domain QA in which the retriever and reader iteratively interact with each other via a novel multistep-reasoning component allowing it to retrieve and combine information from multiple paragraphs. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(b) Our paragraph representations are independent of the query which makes our architecture highly scalable and we empirically demonstrate it by running large scale experiments over millions of paragraphs. (c) Lastly, our framework is agnostic to the architecture of the reader and we show improvements on two widely used neural reading comprehension models. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 BASIC COMPONENTS OF OUR MODEL",
+        "text_level": 1,
+        "bbox": [
+            174,
+            179,
+            517,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The architecture of our model consists of three main components - (a) paragraph retriever - that computes a relevance score for each paragraph w.r.t a given query and ranks them according to the computed score. (b) reader - a more sophisticated neural machine reading model that receives few top-ranked paragraphs from the retriever and outputs a span of text as a possible answer to the query and (c) multi-step-reasoner - a gated recurrent unit that facilitates iterative interaction between the retriever and the reader. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            295
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, the input to our model is a natural language question $\\mathrm { Q } = \\mathrm { q } _ { 1 }$ , q2,. . . , ${ \\bf q } _ { n }$ consisting of $n$ tokens and a set of paragraphs $\\mathsf { P } = \\{ \\mathsf { p } _ { 1 } , \\mathsf { p } _ { 2 } , . . . \\mathsf { p } _ { K } \\}$ . Our model extracts a span of text $a$ as the answer to the question from the paragraphs in P. Note that the set of paragraphs in P can be the paragraphs in a set of documents retrieved by a search engine or it could be all the paragraphs in a large text corpus such as Wikipedia. Next we describe each individual component of our model. ",
+        "bbox": [
+            174,
+            301,
+            825,
+            371
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 PARAGRAPH RETRIEVER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            387,
+            385,
+            402
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The paragraph retriever computes a score for how likely a paragraph is to contain an answer to a given question. The paragraph representations are computed independent of the query and once computed, they are not updated. This allows us to cache the representations and store them offline. The relevance score of a paragraph is computed as a inner product between the paragraph and the query vectors. The paragraph and query representations are computed as follows. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a paragraph $\\mathfrak { p } = \\{ \\mathfrak { p } _ { 1 } , \\mathfrak { p } _ { 2 } , \\dots , \\mathfrak { p } _ { m } \\}$ consisting of $m$ tokens, a multi-layer recurrent neural network encodes each tokens in the paragraph — $\\left\\{ \\mathbf { p } _ { 1 } , \\mathbf { p } _ { 2 } , \\ldots , \\mathbf { p } _ { m } \\right\\} = \\mathbf { R N N } \\left( \\left\\{ \\mathbf { p } _ { 1 } , \\mathbf { p } _ { 2 } , \\ldots , \\mathbf { p } _ { m } \\right\\} \\right)$ , where $\\mathbf { p } _ { j } \\in \\mathbb { R } ^ { 2 d }$ encodes useful contextual information around the $j$ -th token. Specifically we choose to use a multilayer bidirectional long-short term memory network (LSTM) (Hochreiter & Schmidhuber, 1997) and take $\\mathbf { p } _ { j }$ as the hidden units in the last layer of the RNN. We concatenate the representation computed by the forward and the backward LSTM. To compute a single paragraph vector $ { \\mathbf { p } } \\in \\mathbb { R } ^ { 2 d }$ from all the token representations, we combine them using weights $b _ { j } \\in \\mathbb { R }$ ",
+        "bbox": [
+            174,
+            489,
+            826,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eed814d6ebddd1d91fbd45074ec383f8dbecd56462a711a7e365e46520df1cdd.jpg",
+        "text": "$$\nb _ { j } = \\frac { \\exp ( \\mathbf { w } \\cdot \\mathbf { p _ { j } } ) } { \\sum _ { j ^ { \\prime } } \\exp ( \\mathbf { w } \\cdot \\mathbf { p } _ { j ^ { \\prime } } ) } \\qquad \\mathbf { p } = W _ { s } \\sum _ { j ^ { \\prime } } b _ { j ^ { \\prime } } \\cdot \\mathbf { p _ { j ^ { \\prime } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            598,
+            691,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $b _ { j }$ encodes the importance of each token and $\\mathbf { w } \\in \\mathbb { R } ^ { 2 d } , \\mathbf { W _ { s } } \\in \\mathbb { R } ^ { 2 d \\times 2 d }$ are learned weights. The query ${ \\dot { \\mathbf { q } } } = \\left\\{ { \\mathfrak { q } } _ { 1 } , { \\mathfrak { q } } _ { 2 } , \\dots , { \\mathfrak { q } } _ { n } \\right\\}$ is encoded by another network with the same architecture to obtain a query vector $\\mathbf { q } \\in \\mathbb { R } ^ { 2 d }$ . Next the relevance score of a paragraph w.r.t the query (score $( \\mathbf { p } , \\mathbf { q } ) \\in \\mathbb { R } )$ is computed by a simple inner product — score $( { \\bf p } , { \\bf q } ) = \\langle { \\bf p } , { \\bf q } \\rangle$ . The paragraph retriever then returns the top scoring $k$ paragraphs to the reader. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fast inner product search. Inner product can be efficiently computed on a GPU, however in our experiments with large corpus with over million paragraphs, (a) the paragraph vectors require more memory than available in a single commodity GPU (b) it is computationally wasteful to compute inner products with all paragraph vectors and we can do better by leveraging fast nearest neighbor (NN) search algorithms. Since the retriever has to find the $k$ paragraphs with the highest inner products w.r.t query, our problem essentially reduces to maximum inner product search (MIPS). There exists data structures for fast NN search in metric spaces such as Cover Trees (Beygelzimer et al., 2006). But we cannot use them directly, since triangle equality does not hold in inner product space. Borrowing ideas from Bachrach et al. (2014); Zaheer et al. (2019), we propose to use nearest neighbor (NN) search algorithms to perform the MIPS in sublinear time as follows. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let u be an upper bound for the L2 norm for all paragraphs, i.e. $\\mathbf { u } \\geq \\| \\mathbf { p } \\|$ , $\\forall \\mathbf { p }$ . Next, we modify the original paragraph and query vectors such that searching for the $\\mathbf { k }$ -nearest neighbor w.r.t L2 distance with the modified vectors is equivalent to finding the $k$ nearest (original) paragraph vectors in the inner-product space. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Define the augmented paragraph vectors as $\\tilde { \\mathbf { p } } \\mathbf { i } = [ \\mathbf { p } \\mathbf { i } ; \\sqrt { \\mathbf { u } ^ { 2 } - \\| \\mathbf { p } \\mathbf { i } \\| ^ { 2 } } ]$ and augmented query vector as $\\widetilde { \\mathbf { q } } = [ \\mathbf { q } ; 0 ]$ , where $[ ; ]$ denotes concatenation. Note, with this transformation, $\\langle \\tilde { { \\bf p } } _ { \\bf i } , \\tilde { { \\bf q } } \\rangle = \\langle { \\bf p _ { i } } , { \\bf q } \\rangle$ . Now, ",
+        "bbox": [
+            169,
+            102,
+            823,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f30d7b271a8eec71f1981d79800c127fa779a46f2adf9b0b3a3ec85f6da97ae5.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { N N } ( \\tilde { \\bf p _ { i } } , \\tilde { \\bf q } ) = \\underset { i } { \\arg \\operatorname* { m i n } } \\left\\| \\tilde { \\bf p _ { i } } - \\tilde { \\bf q } \\right\\| ^ { 2 } } \\\\ & { \\quad \\quad \\quad \\quad = \\underset { i } { \\arg \\operatorname* { m i n } } \\left\\| \\tilde { \\bf p _ { i } } \\right\\| ^ { 2 } + \\left\\| \\tilde { \\bf q } \\right\\| ^ { 2 } - 2 \\langle \\tilde { \\bf p _ { i } } , \\tilde { \\bf q } \\rangle } \\\\ & { \\quad \\quad \\quad \\quad = \\underset { i } { \\arg \\operatorname* { m i n } } ( { \\bf u } ^ { 2 } - 2 \\langle \\tilde { \\bf p _ { i } } , \\tilde { \\bf q } \\rangle ) } \\\\ & { \\quad \\quad \\quad \\quad = \\underset { i } { \\arg \\operatorname* { m a x } } \\langle \\tilde { \\bf p _ { i } } , \\tilde { \\bf q } \\rangle = \\underset { i } { \\arg \\operatorname* { m a x } } \\langle { \\bf p _ { i } } , { \\bf q } \\rangle = \\mathrm { M I P S } ( { \\bf p _ { i } } , { \\bf q } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            155,
+            696,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Many exact NN search algorithms can find $\\mathbf { k }$ -NN in time (sublinear) logarithmic in number of paragraphs (Beygelzimer et al., 2006; Zaheer et al., 2019), after an one-time preprocessing. In our architecture, the preprocessing can be done because the set of all paragraphs is fixed for all the queries. We chose to use SGTree (Zaheer et al., 2019) to perform the NN/MIPS due to its fast construction time and competitive performance reducing the search to logarithmic time per query. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            352
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that our paragraph representations are independent of the given query and are never updated once they are trained. After training is completed, we cache the $ { \\mathbf { p } } \\in  { \\mathbb { R } } ^ { 2 d }$ vectors. This is unlike many recent work in open-domain QA. For example, in $\\mathbb { R } ^ { 3 }$ (Wang et al., 2018a), the retriever uses Match-LSTM model (Wang & Jiang, 2017) to compute question-matching representations for each token in the passage. The paragraph representations are then obtained by running a bi-directional RNN over these matched representation. Although powerful, this architecture design will not scale in open-domain settings where the retriever has to re-compute new representations for possibly millions of paragraphs for every new question. In contrast, once training is over, we cache the paragraph representation and use it for every query at test time. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Training - Following previous work (Htut et al., 2018; Lin et al., 2018; Wang et al., 2018a), we gather labels for paragraphs during training using distant supervision (Mintz et al., 2009). A paragraph that contains the exact ground truth answer string is labeled as an positive example. For a positive (negative) labeled paragraph, we maximize (minimize) the $\\log ( \\sigma ( \\mathrm { s c o r e } ( \\mathbf { p } , \\mathbf { q } ) ) )$ . The number of layers of the bi-directional LSTM encoder is set to three and we use Adam (Kingma & Ba, 2014) for optimization. Once training is done, we pre-compute and cache the paragraph representation of each dataset in our experiments. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 MACHINE READER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            604,
+            346,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The reader is a sophisticated neural machine reading comprehension (MRC) model that takes in the top few paragraphs sent by the retriever and outputs a span of answer text. Our model is agnostic to the exact architecture of the reader and we perform experiments to show the efficacy of our model on two state-of-the-art neural machine reading models - DrQA and BiDAF. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "MRC models designed for SQUAD (Rajpurkar et al., 2016), NewsQA (Trischler et al., 2016), etc operate on a single paragraph. However it has been shown that reading and aggregating evidence across multiple paragraphs is important when doing QA over larger evidence set (e.g. full Wikipedia document) (Swayamdipta et al., 2018; Clark & Gardner, 2018) and in open domain settings (Wang et al., 2018b). Most MRC models compute a start and end scores for each token in the paragraph that represents how likely a token is the start/end of an answer span. To gather evidence across multiple paragraphs sent by the retriever, we normalize the start/end scores across the paragraphs. Furthermore a text span can appear multiple times in a paragraph. To give importance to all answer spans in the text, our objective aggregates (sums) the log-probability of the score for each answer position. Let $\\mathcal { T } ( w , p )$ denote the token start positions where the answer span appears in the paragraph $p$ and let $w _ { S }$ be the starting word of the answer span. Our model maximizes the sum of the following objective for the start and end word of an answer spans as follows. (For brevity, we only show the objective for the starting word $( \\mathbf { w } _ { s } )$ of the span.) ",
+        "bbox": [
+            173,
+            694,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d49f9118a52d1d6c516c174e72da469ff6f200a653ddd975c7fbbf8cb8373463.jpg",
+        "text": "$$\n\\log \\left( \\frac { \\sum _ { j \\in \\mathcal { P } } \\sum _ { k \\in \\mathcal { Z } ( w _ { s } , p _ { j } ) } \\exp ( \\operatorname { s c o r e } _ { \\mathrm { s t a r t } } ( k , j ) ) } { \\sum _ { j \\in \\mathcal { P } } \\sum _ { i = 1 } ^ { n _ { j } } \\exp ( \\operatorname { s c o r e } _ { \\mathrm { s t a r t } } ( i , j ) ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            880,
+            643,
+            921
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\mathcal { P }$ denotes the set of all top-ranked paragraphs by the retriever, $n _ { j }$ denotes the number of tokens in paragraph $j$ and $\\mathrm { s c o r e } _ { \\mathrm { s t a r t } } \\left( k , j \\right)$ denotes the start score of the $k$ -th token in the $j$ -th paragraph. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Score aggregation during inference. During inference, following Chen et al. (2017); Seo et al. (2017), the score of a span that starts at token position $i$ and ends at position $j$ of paragraph $p$ is given by the sum of the $\\mathrm { \\ s c o r e } _ { \\mathrm { s t a r t } } ( i , p )$ and $\\operatorname { s c o r e } _ { \\mathrm { e n d } } ( j , p )$ . During inference, we score spans up to a pre-defined maximum length of 15. Further, we add the scores of spans across different paragraphs (even if they are retrieved at different steps), if they have the same surface form. That is, if the same span (e.g. “Barack Obama”) occurs multiple times in several paragraphs, we sum the individual span scores. However, to ensure tractability, we only consider the top 10 scoring spans in each paragraph for aggregation. It should be noted that the changes we made to aggregate evidence over multiple paragraphs and mentions of spans needs no change to the original MRC architecture. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 MULTI-STEP-REASONER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            284,
+            413,
+            300
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A novel component of our open-domain architecture is the multi-step-reasoner which facilitates iterative interaction between the retriever and the machine reader. The multi-step-reasoner a module comprised of a gated recurrent unit (Cho et al., 2014) which takes in the current state of the reader and the current query vector and does a gated update to produce a reformulated query. The reformulated query is sent back to the retriever which uses it to re-rank the paragraphs in the corpus. Since the gated update of the multi-step-reasoner, conditions on the current state of the machine reader, this multi-step interaction provides a way for the search engine (retriever) and the QA model (reader) to communicate with each other. This can also be seen as an instance of two agents cooperating via communication to solve a task (Lazaridou et al., 2017; Lee et al., 2018; Cao et al., 2018). ",
+        "bbox": [
+            174,
+            314,
+            825,
+            440
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More formally, let $\\mathbf { q } _ { \\mathbf { t } } \\in \\mathbb { R } ^ { 2 d }$ be the current query representation which was most recently used by the paragraph retriever to score the paragraphs in the corpus. The multi-step-reasoner also has access to the reader state which is computed from the hidden memory vectors of the reader. The reader state captures the current information that the reader has encoded after reading the paragraphs that was sent by the retriever. Next we show how the reader state is computed. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            517
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Span extractive machine reading architectures compute a hidden representation for each token in the paragraph. Our framework needs access to these hidden representations to compute the reader state. ",
+        "bbox": [
+            174,
+            523,
+            823,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathbf { m _ { j } } \\in \\mathbb { R } ^ { 2 p }$ be the hidden vector associated with the $j { \\cdot }$ -th token in the paragraph. Let $\\mathbf { L } \\in \\mathbb { R } ^ { 2 p }$ be the final query representation of the reader model. $\\mathbf { L }$ is usually created by some pooling operation on the hidden representation of each question token. The reader state $\\mathbf { S } \\in \\mathbb { R } ^ { \\sum p }$ is computed from each of the hidden vectors $\\mathbf { m } _ { \\mathrm { j } }$ and $\\mathbf { L }$ by first computing soft-attention weights between each paragraph token, followed by combining each $\\mathbf { m _ { j } }$ with the soft attention weights. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/676dd6a1a3737d451fb60fe1fe894d0b83bdb0c2d1d8597821e82edcb683ba3c.jpg",
+        "text": "$$\n\\alpha _ { \\mathbf { j } } = \\frac { \\exp \\left( \\mathbf { m _ { j } } \\cdot \\mathbf { L } \\right) } { \\sum _ { j ^ { \\prime } } \\exp \\left( \\mathbf { m _ { j } ^ { \\prime } } \\cdot \\mathbf { L } \\right) } \\qquad \\mathbf { S } = \\sum _ { j } \\left( \\alpha _ { \\mathbf { j } } \\cdot \\mathbf { m _ { j } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            635,
+            692,
+            681
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, the new reformulated query $\\mathbf { q } _ { \\mathbf { t } + \\mathbf { 1 } } \\in \\mathbb { R } ^ { 2 d }$ for the paragraph retriever is calculated by the multi-step-reasoner module as follows — ",
+        "bbox": [
+            171,
+            694,
+            823,
+            723
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cdd0f5a03614ede7947a0ccae926c4b6a25b897d29a82e2db82eca88322b5b30.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { q } _ { \\mathbf { t } + 1 } ^ { ' } = \\mathbf { G } \\mathbf { R } \\mathbf { U } \\left( \\mathbf { q } _ { \\mathbf { t } } , \\mathbf { S } \\right) } \\\\ { \\mathbf { q } _ { \\mathbf { t } + 1 } = \\mathrm { F F N } \\left( \\mathbf { q } _ { \\mathbf { t } + 1 } ^ { ' } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            727,
+            565,
+            773
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our architecture, we used a 3 layer GRU network, followed by a one layer feed forward network (FFN) with a ReLU non-linearity. The gated update ensures that relevant information from ${ \\bf q _ { t } }$ is preserved and new and useful information from the reader state $\\mathbf { s }$ is added to the reformulated query. ",
+        "bbox": [
+            174,
+            782,
+            825,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            287,
+            856
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There exists no supervision for training the query reformulation of the multi-step-reasoner. Instead, we employ reinforcement learning (RL) and train it by how well the reader performs after reading the new set of paragraphs retrieved by the modified query. We define the problem as a deterministic finite horizon Partially Observed Markov decision process (POMDP). The components of POMDP are — ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "States. A state in the state space consists of the entire text corpora, the query, the answer, and $k$ selected paragraphs. The reader is part of the environment and is fully described given the current state, i.e. selected paragraphs and the query. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Observations. The agent only observes a function of the current state. In particular, to the agent only the query vector and the memory of the reader model is shown, which are a function of the current state. Intuitively, this represents the information encoded by the machine reader model after reading the top $k$ paragraphs sent by the retriever in current step. ",
+        "bbox": [
+            174,
+            146,
+            825,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Actions. The set of all paragraphs in the text corpora forms the action space. The retriever scores all paragraphs w.r.t the current query and selects the top $k$ paragraphs to send to the reader model. We treat $k$ as a hyper-parameter in our experiments. ",
+        "bbox": [
+            176,
+            202,
+            820,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Reward. At every step, the reward is measured by how well the answer extracted by the reader model matches to the ground-truth answer. We use the $\\mathrm { F } _ { 1 }$ score (calculated by word overlap between prediction and ground-truth) as the reward at each step. ",
+        "bbox": [
+            176,
+            242,
+            821,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Transition. The environment evolves deterministically after reading the paragraphs sent by the retriever. ",
+        "bbox": [
+            174,
+            284,
+            820,
+            311
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our policy $\\pi$ is parameterized by the GRU and the FFN of the multi-step-reasoner. Let $r _ { t }$ denote the reward $F _ { 1 }$ score) returned by the environment at time $t$ . We directly optimize the parameters to maximize the expected reward given by — $\\begin{array} { r } { J ( \\boldsymbol { \\Theta } ) = \\mathbb { E } _ { \\underline { { \\pi } } } \\left[ \\sum _ { t = 1 } ^ { T } r _ { t } \\right] } \\end{array}$ . Here $T$ denotes the number of steps of interactions between the retriever and the reader. We treat the reward at each step equally and do not apply any discounting. Motivated by the REINFORCE (Williams, 1992) algorithm, we compute the gradient of our objective as ",
+        "bbox": [
+            174,
+            318,
+            825,
+            402
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/56c50fd3f62ee2b42b508bfb7580fe23aacf5f30085fd65962bb46d0f2a5a56e.jpg",
+        "text": "$$\n\\nabla _ { \\boldsymbol { \\Theta } } J ( \\boldsymbol { \\Theta } ) = \\mathbb { E } _ { \\boldsymbol { \\pi } } \\left[ \\sum _ { t = 1 } ^ { T } \\boldsymbol { r } _ { t } \\cdot \\log ( \\pi _ { \\boldsymbol { \\Theta } } ( p _ { t } \\mid q ) ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            402,
+            622,
+            465
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, $p _ { t }$ is the top-ranked paragraph returned by the retriever at time $t$ and the probability that the current policy assigns to $p _ { t }$ is computed by normalizing the scores with a softmax. It is usual practice to add a variance reduction baseline (e.g. average of rewards in the minibatch) for stable training, but we found this significantly degrades the final performance. We think this is because, in QA, a minibatch consists of questions of varying difficulty and hence the rewards in a batch itself have high variance. This is similar to findings by Shen et al. (2017) for closed domain-QA (e.g. SQUAD). ",
+        "bbox": [
+            173,
+            464,
+            825,
+            547
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Pretraining the multi-step-reasoner. We also find that pre-training the multi-step-reasoner before fine tuning with RL to be effective. We train to rank the similarity between the reformulated query vector and one of the distantly-supervised correct paragraph vectors higher than the score of a randomly sampled paragraph vector. Specifically, let q denote the query vector, $\\mathbf { p } ^ { * } , \\mathbf { p } ^ { \\prime }$ denote the paragraph representation of paragraphs containing the correct answer string and a random sampled paragraph respectively. We follow the Bayesian Personalized Ranking approach of Rendle et al. (2009) and maximize $\\log ( \\sigma ( \\mathbf { q } ^ { \\top } \\mathbf { p } ^ { * } - \\mathbf { q } ^ { \\top } \\mathbf { p } ^ { ' } ) )$ . The paragraph representations $\\mathbf { p } ^ { * } , \\mathbf { p } ^ { \\prime }$ are kept fixed and gradient only flows through $\\mathbf { q }$ to the parameters of the multi-step-reasoner. ",
+        "bbox": [
+            173,
+            554,
+            825,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 PUTTING IT ALL TOGETHER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            676,
+            406,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our open-domain architecture is summarized above in Algorithm 1. Given a large text corpora (as a list of paragraphs), the corresponding paragraph embeddings (which can be trained by the procedure in $( \\ S 2 . 1 ) )$ and hyper-parameters $( \\mathrm { T } , k )$ , our model $\\mathcal { M }$ returns a text span $a$ as answer. The multi-step interaction between the retriever and reader can be best understood by the for loop in line 2 of algorithm 1. The initial query ${ \\bf q 0 }$ is first used to rank all the paragraphs in the corpus (line 3), followed by which the top $k$ paragraphs are sent to the reader (line 4). The reader returns the answer span (with an associated score for the span) and also its internal state (line 5). The GRU network then takes in the current query and the reader state to produce the updated query which is then passed to the retriever (line 6). The retriever uses this updated query to again re-rank the paragraphs and the entire process is repeated for $\\mathrm { T }$ steps. At the end of $\\mathrm { T }$ steps, the model returns the span with the highest score returned by the reader model. The reader is trained using supervised learning (using the correct spans as supervision) and the parameters of the GRU network are trained using reinforcement learning. During training, we first pre-train the reader model by setting the number of multi-step reasoning steps $( \\mathrm { T } = 1 )$ ). After the training converges, we freeze the parameters of the reader model and train the parameters of the GRU network using policy gradients. The output of the reader model is used to generate the reward which is used to train the policy network. ",
+        "bbox": [
+            173,
+            702,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/ba712ea5d9df26691019c393cce0fb33590b21ee5e7450b86e3a49bb485047be.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Algorithm 1 Multi-step reasoning for open-domain QA</td></tr><tr><td colspan=\"2\">Input: Question text Qtext, Text corpus (as a list of paragraphs)T,Paragraph embeddings P (list of paragraph embeddings for each paragraph in T),Model M, Number of multi-steps T, number</td></tr><tr><td>of top-ranked paragraphs k Output: Answer span a</td><td></td></tr><tr><td>1: qo ← encode_query(Qtext) 2: for t in range(T) do</td><td>#(2.1)</td></tr><tr><td>3: {𝑝1,P2,...Pk} ←M.retriever.score_paras(qt,P,k) # 4:</td><td># each pi denotes a paragraph id # get text for the top paragraphs</td></tr><tr><td>5: at,St,St ← M.reader.read(Plexk,Qtext)</td><td># (§ 2.2); St denotes reader state</td></tr><tr><td></td><td># at denotes answer span</td></tr><tr><td>6:qt ← M.multi_step-reasoner.GRU(qt,St)</td><td># st denotes the score of the span</td></tr><tr><td></td><td># (§ 3); Query reformulation step</td></tr><tr><td>7: end for</td><td></td></tr><tr><td>8:return answer span a with highest score</td><td></td></tr></table>",
+        "bbox": [
+            173,
+            103,
+            826,
+            338
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            367,
+            344,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Open domain QA is a well-established task that dates back to few decades of reasearch. For example the BASEBALL system (Green Jr et al., 1961) aimed at answering open domain question albeit for a specific domain. Open-domain QA has been popularized by the Trec-8 task (Voorhees et al., 1999) and has recently gained significant traction due to the introduction of various datasets (Dunn et al., 2017; Dhingra et al., 2017; Joshi et al., 2017). In many open-domain systems (Chen et al., 2017), the retriever is a simple IR based system (e.g. tfidf retriever) with no trainable parameters and hence the retriever cannot overcome from its mistakes. Recent work such as $\\mathbb { R } ^ { 3 }$ (Wang et al., 2018a), DS-QA (Lin et al., 2018) use a trained retriever and have shown improvement in performance. However they form query dependent paragraph representation and such architectures will not scale to full open-domain settings where the retriever has to rank millions of paragraphs. and neither do they support iterative reasoning thereby failing to recover from any mistakes made by the ranker or where evidence needs to be aggregated across multiple paragraphs. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Query Reformulation by augmenting the original query with terms from the top- $k$ retrieved document (Xu & Croft, 1996; Lavrenko & Croft, 2001) has proven to be very effective in information retrieval. Instead of using such automatic relevance feedback, Nogueira & Cho (2017) train a query reformulation model to maximize the recall of a IR system using RL and Pfeiffer et al. (2018) showed that query refinement is effective for IR in bio-medical domain. The main difference between this work and ours is that our model directly optimizes to improve the performance of a question answering system. However, as we show, we still see an improvement in the recall of our retriever $( \\ S 5 . 1 )$ . Perhaps the most related to our work is Active Question Answering (AQA) (Buck et al., 2018), which use reformulation of the natural language query to improve the performance of a BiDAF reader model on SEARCHQA. The main difference between AQA is that we reformulate the query in vector space. We compare with AQA and show that our model achieves significantly better performance. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Iterative Reasoning has shown significant improvements in models using memory networks (Sukhbaatar et al., 2015; Miller et al., 2016) for question answering in text and knowledge bases (Das et al., 2017; Yang et al., 2017; Das et al., 2018). Our model can be viewed as a type of controller update step of memory network type of inference. Recently, iterative reasoning has shown to be effective in reading comprehension in single paragraph setting, where the model reads the same paragraph iteratively (Shen et al., 2017; Liu et al., 2017). Our work can be seen as a strict generalization of these in a more realistic, open-domain setting. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Nearest Neighbor Search - Computing fast nearest neighbor (NN) search is a fundamental requirement in many applications. We used exact k-NN search using SGTree (Zaheer et al., 2019) which has been shown to perform better than other exact k-NN strategies such as Cover Tree (Beygelzimer et al., 2006), P-DCI (Li & Malik, 2017) and other approximate NN search techniques such as RP-Tree (Dasgupta & Sinha, 2013), HNSW (Malkov & Yashunin, 2018). In general, our proposed multi-step-reasoner framework is not coupled to any particular kind of $\\mathbf { k }$ -NN technique. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/358849668e93779b7d062af6b951b012a3a4e47e7cc04b0cab49603821b035d1.jpg",
+        "table_caption": [
+            "Table 2: Performance on test sets for various datasets "
+        ],
+        "table_footnote": [
+            "∗ Despite our best efforts, we could not reproduce the results of Ds-QA using their code and hyperparameter settings for Quasar-T. ∗∗ The results on the test set of TRIVIAQA-unfiltered were not reported in the original paper. Results obtained from authors via e-mail. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Quasar-T</td><td colspan=\"2\">SearchQA</td><td colspan=\"2\">TRIVIAQA-unfiltered</td><td colspan=\"2\">SQUAD-open</td></tr><tr><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>GA (Dhingra et al., 2016)</td><td>26.4</td><td>26.4</td><td>-</td><td>-</td><td>-</td><td></td><td>=</td><td>-</td></tr><tr><td>BIDAF (Seo et al., 2017)</td><td>25.9</td><td>28.5</td><td>28.6</td><td>34.6</td><td></td><td></td><td></td><td></td></tr><tr><td>AQA (Buck et al.,2018)</td><td>-</td><td>-</td><td>40.5</td><td>47.4</td><td>=</td><td></td><td></td><td>1</td></tr><tr><td>R (Wang et al.,2018a)</td><td>35.3</td><td>41.7</td><td>49.0</td><td>55.3</td><td>47.3</td><td>53.7</td><td>29.1</td><td>37.5</td></tr><tr><td>DS-QA*(Lin et al., 2018)</td><td>37.27</td><td>43.63</td><td>58.5</td><td>64.5</td><td>48.7</td><td>56.3</td><td>28.7</td><td>36.6</td></tr><tr><td>MINIMAL (Min etal.,2018)</td><td>=</td><td>-</td><td>=</td><td>=</td><td>-</td><td>-</td><td>34.7</td><td>42.5</td></tr><tr><td>Dr.QA baseline</td><td>36.87</td><td>45.49</td><td>51.36</td><td>58.24</td><td>48.00</td><td>52.13</td><td>27.1</td><td>-</td></tr><tr><td>multi-step-reasoner (Dr.QA)</td><td>39.53</td><td>46.67</td><td>55.01</td><td>61.61</td><td>55.93</td><td>61.66</td><td>31.93</td><td>39.22</td></tr><tr><td>multi-step-reasoner (BiDAF)</td><td>40.63</td><td>46.97</td><td>56.26</td><td>61.36</td><td>55.91</td><td>61.65</td><td></td><td>-</td></tr><tr><td>DocumentQA**(Clark &amp; Gardner,2018)</td><td>-</td><td>-</td><td>-</td><td>=</td><td>61.56</td><td>68.03</td><td>=</td><td>1</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            849,
+            261
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/97acfba38d17983b57d9a92482a06bb05304649168fbc3f43d83da6ce2fa5be8.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>P@1</td><td>P@3</td><td>P@5</td></tr><tr><td>R³ (Wang et al., 2018a)</td><td>40.3</td><td>51.3</td><td>54.5</td></tr><tr><td>Our Retriever (initial)</td><td>35.7</td><td>49.6</td><td>56.3</td></tr><tr><td>+ multi-step (7 steps)</td><td>42.9</td><td>55.5</td><td>59.3</td></tr></table>",
+        "bbox": [
+            176,
+            320,
+            511,
+            393
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Retrieval performance on QUASAR-T. The match-LSTM based retriever of $\\mathbb { R } ^ { 3 }$ is a more powerful model than our intial retrieval model. However, after few steps of multi-step-reasoner, the performance increases suggesting that re-ranking via query-reformulation is retrieving relevant evidence from the corpus. We report the $\\mathrm { P @ } k$ on the last step. ",
+        "bbox": [
+            173,
+            404,
+            514,
+            502
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/20da1449de003db223341121ee8d3b9b0b0267522e165d0e62478a9cbc668189.jpg",
+        "image_caption": [
+            "Figure 2: Scalability of retriever. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            555,
+            333,
+            807,
+            477
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            326,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now present experiments to show the effectiveness of each component of our framework. We experiment on the following large open-domain QA datasets — (a) TRIVIAQA-unfiltered– a version of TRIVIAQA (Joshi et al., 2017) built for open-domain QA. It has much more number of paragraphs than the web/wiki setting of TRIVIAQA. Moreover, there is no guarantee that every document in the evidence will contain the answer making this setting more challenging. (b) TRIVIAQA-open– To test our framework for large scale setting, we combine all evidence for every question in the development set. This resulted in a corpus containing 1.68M paragraphs per question. (c) ",
+        "bbox": [
+            174,
+            547,
+            517,
+            727
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/466077e329890f85e3779525918b550a0f57c336aca44aa2d8d193bad8d1ba8d.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Statistics of various dataset. The second column shows the number of paragraphs for each query. "
+        ],
+        "table_body": "<table><tr><td>Datasets</td><td>#q(test)</td><td>#p/q(test)</td></tr><tr><td>SEARCHQA</td><td>27,247</td><td>49.6</td></tr><tr><td>QUASAR-T</td><td>3.000</td><td>99.8</td></tr><tr><td>SQUAD-open</td><td>10,570</td><td>115.6</td></tr><tr><td>TRIVIAQA-unfiltered</td><td>10,790</td><td>149</td></tr><tr><td>TRIVIAQA-open</td><td>11,274</td><td>1,684,193</td></tr></table>",
+        "bbox": [
+            537,
+            564,
+            813,
+            657
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "SEARCHQA (Dunn et al., 2017) – is another open-domain dataset which consists of question-answer pairs crawled from the J! archive. The paragraphs are obtained from 50 web snippets retrieved using the Google search API. (d) QUASAR-T (Dhingra et al., 2017) – consists of 43K open-domain questions where the paragraphs are obtained from the ClueWeb data source. (e) SQUAD-open– We also experimented on the open domain version of the SQUAD dataset. For fair comparison to baselines, our evidence corpus was created by retrieving the top-5 wikipedia documents as returned by the pipeline of Chen et al. (2017). The datasets are summarized in table 1. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 PERFORMANCE OF PARAGRAPH RETRIEVER ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            842,
+            516,
+            856
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first investigate the performance of our paragraph retriever model $( \\ S 2 . 1 )$ . Our retriever is based on inner product between the query and pre-computed paragraph vectors. This architecture, although more scalable, is less powerful than the retrievers of $\\mathbb { R } ^ { 3 }$ and DS-QA which compute query-dependent passage representation via soft alignment (attention) before encoding with a bi-LSTM. Results in table 3 indeed show that retriever of $\\mathbb { R } ^ { 3 }$ has better $\\mathbf { P } @ k$ than our retriever. We also measure the performance of our retriever after few steps (#steps $= 7$ ) of interaction between the retriever and reader. As we can see from table 3, the query reformulation has resulted in better re-ranking and hence an overall improved performance of the retriever. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            102,
+            823,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To test for scalability in open-domain settings, we conduct a synthetic experiment. We plot the wall-clock time (in seconds) taken by the retriever to score and rank paragraphs with a query. To test for scalability, we increase the number of paragraphs ranging from 500 to 100 million and test on a single Titan-X GPU. For our baseline, we use the GPU implementation of the retriever of DS-QA (Lin et al., 2018). For our model, we test on three variants — (a) inner product on GPU, (b) inner-product on CPU and (c) inner-product using SG-Tree. Figure 2 shows the results. Our retriever model on GPU is faster than DS-QA, since the latter perform much more computation compared to just inner-product in our case. Moreover, DS-QA quickly uses up all the available memory and throws a memory error (OOM) by just 100K paragraphs. The inner product operation scales up to 1M paragraph before going OOM. SG-Tree shows very impressive performance even though it operates on CPU and consistently outperforms dot product operation on the CPU. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            319
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 EFFECTIVENESS OF MULTI-STEP-REASONER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            338,
+            517,
+            352
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next we investigate the improvements in QA performance due to multi-step-reasoner. We report the commonly used exact-match (EM) and F1 score on each dataset. ",
+        "bbox": [
+            171,
+            364,
+            823,
+            392
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Performance on benchmark datasets. Table 2 compares the performance of our model with various competitive baselines on four open-domain QA datasets. One of the main observation is that combining multi-step-reasoner with the base Dr.QA reader (Chen et al., 2017) always leads to improved performance. We also perform competitively to most baselines across all datasets. ",
+        "bbox": [
+            173,
+            400,
+            825,
+            455
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the relative improvements our models achieve on QUASAR-T, SEARCHQA and TRIVIAQA-unfiltered with varying number of steps of interaction between the retriever and the reader. The key takeaway of this experiment is that multiple steps of interaction uniformly increases performance over base model (with no interaction). Different datasets have varying level of difficulties, however, the performance reaches its peak around 5 to 7 steps and does not provide much benefit on further increasing the number of steps. ",
+        "bbox": [
+            174,
+            457,
+            496,
+            607
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/2fa6baa6ba3590d2c2b4844ec161d26beda7b852b1e264151fcbd68b9dcbb19a.jpg",
+        "image_caption": [
+            "Figure 3: F1 score w.r.t number of steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            531,
+            463,
+            802,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Large scale experiment on TRIVIAQA-open. The benchmark datasets for open-domain QA have ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            614,
+            500,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "on an average hundred paragraphs for each question (Table 1). In real open-domain settings, the size of the evidence corpus might be much bigger. To test our model for the same, we created the TRIVIAQA-open setting, in which for each query we combined all the paragraphs in the development set, resulting in 1.6M paragraphs per query. We want to emphasize that the baseline models such as $\\mathbb { R } ^ { 3 }$ and DS-QA will not scale to this large setting. The baseline $\\mathrm { D r Q A }$ . model with no interaction between the retriever and reader get a score of $\\mathrm { E M } = 3 7 . 4 5$ and $\\mathrm { F } 1 = 4 2 . 1 6$ . The same model with 3 steps of interaction achieves a score of $\\mathrm { E M } = 3 9 . 7 6$ and $\\mathbf { F } 1 = \\mathbf { 4 4 . 3 0 }$ . The key takeaways from this experiment are — (a) our framework can scale to settings containing millions of paragraphs, (b) iterative interaction still increase performance even in large scale settings, (c) the overall performance has significantly decreased (from 61 to 44.3 F1), suggesting that large context in open-domain QA is very challenging and should be an active area of research with significant scope for improvement. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 ANALYSIS OF RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            375,
+            827
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This section does further analysis of the results of the model. Specifically we are interested in analyzing if our method is able to gather more relevant evidence as we increase the number of steps of interaction between the retriever and the reader. We conduct this analysis on the development set of SEARCHQA (containing 13,393 queries) and to simplify analysis, we make the retriever choose the top scored single paragraph to send to the reader, at each step. The results are noted in table 4. As we can see from row 1 of table 4, on increasing steps of interaction, the quality of retrieved paragraphs ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/85cf4c84edc73749719a95a1cae7d89b0ec2a518947d78943f61a83ec19dda7e.jpg",
+        "image_caption": [
+            "Figure 4: Examples of how multi-step-reasoner iteratively modifies the query by reading context to find more relevant paragraphs. Figure (left) shows an example where the initial retrieved context did not have the answer but the context provided enough hint to get more relevant paragraph in the next step. In figure (right), both the retrieved paragraph have the answer string leading to a boost in the score of the answer span because of score aggregation of spans (§2.2). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            108,
+            799,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/3e413c701845d21a54c4824f8fdf375a2d9dae1cbf3e968c7ae8d43e502582ca.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\"># steps of interaction</td></tr><tr><td></td><td>3</td><td>5</td><td>7</td></tr><tr><td>#queries where initial retrieved para was incor- rect but correct para was retrieved later</td><td>1047</td><td>1199</td><td>1270</td></tr><tr><td>#queries where correct para wasn&#x27;t retrieved at all</td><td>3783</td><td>3594</td><td>3505</td></tr><tr><td># queries where initial answer was incorrect but recoveredlater</td><td>490</td><td>612</td><td>586</td></tr><tr><td>Avg. number of unique paragraphs read across all steps</td><td>1.99</td><td>2.38</td><td>3.65</td></tr></table>",
+        "bbox": [
+            269,
+            351,
+            727,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Analysis of results on the dev. set of SEARCHQA as we increase the number of steps of interaction between the retriever and reader. The retriever at each step sends top-1 paragraph to the reader. A paragraph is correct if it contains the correct answer string. ",
+        "bbox": [
+            174,
+            510,
+            823,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "becomes better, i.e. even though the correct paragraph (containing the answer string) was not retrieved in the first step, the retriever is able to fetch relevant paragraphs later. It is also unsurprising to see, that when correct paragraphs are retrieved, the performance of the reader also increases. To check if the our policy was exploring and retrieving different paragraphs, we counted the mean number of unique paragraphs retrieved across all steps and found that it is high (around 2) when #steps of interaction is small as 3, suggesting that the policy chooses to explore initially. As the number of steps is increased, it increases at slower rate suggesting that if the policy has already found good paragraphs for the reader, it chooses to exploit them rather than choosing to explore. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows two instances where iterative interaction is helpful. In figure to the left, the retriever is initially unable to find a paragraph that directly answers the question, however it finds a paragraph which gives a different name for the disease allowing it to find a more relevant paragraph that directly answers the query. In the figure to the right, after the query reformulation, both the retrieved paragraphs have the correct answer string. Since we aggregate (sum) the scores of spans, this leads to an increase in the score of the right answer span (Demeter) to be the maximum. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            766
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            318,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces a new framework for open-domain question answering in which the retriever and the reader iteratively interact with each other. The resulting framework improved performance of machine reading over the base reader model uniformly across four open-domain QA datasets. We also show that our fast retrieval method can scale upto millions of paragraphs, much beyond the current capability of existing open-domain systems with a trained retriever module. Finally, we show that our method is agnostic to the architecture of the machine reading system provided we have access to the token level hidden representations of the reader. Our method brings an increase in performance to two popular and widely used neural machine reading architectures, Dr.QA and BiDAF. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            367,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work is funded in part by the Center for Data Science and the Center for Intelligent Information Retrieval, and in part by the National Science Foundation under Grant No. IIS-1514053 and in part by the International Business Machines Corporation Cognitive Horizons Network agreement number W1668553 and in part by the Chan Zuckerberg Initiative under the project Scientific Knowledge Base Construction. Any opinions, findings and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect those of the sponsor. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            217
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            285,
+            253
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoram Bachrach, Yehuda Finkelstein, Ran Gilad-Bachrach, Liran Katzir, Noam Koenigstein, Nir Nice, and Ulrich Paquet. Speeding up the xbox recommender system using a euclidean transformation for inner-product spaces. In RecSys, 2014. ",
+        "bbox": [
+            174,
+            261,
+            826,
+            304
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alina Beygelzimer, Sham Kakade, and John Langford. Cover trees for nearest neighbor. In ICML, 2006. ",
+        "bbox": [
+            174,
+            313,
+            823,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Penny A Bishop, Cynthia Reyes, and Susanna W Pflaum. Read smarter, not harder: Global reading comprehension strategies. The Reading Teacher, 2006. ",
+        "bbox": [
+            173,
+            349,
+            823,
+            380
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Buck, Jannis Bulian, Massimiliano Ciaramita, Andrea Gesmundo, Neil Houlsby, Wojciech Gajewski, and Wei Wang. Ask the right questions: Active question reformulation with reinforcement learning. In ICLR, 2018. ",
+        "bbox": [
+            176,
+            387,
+            825,
+            430
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kris Cao, Angeliki Lazaridou, Marc Lanctot, Joel Z Leibo, Karl Tuyls, and Stephen Clark. Emergent communication through negotiation. arXiv preprint arXiv:1804.03980, 2018. ",
+        "bbox": [
+            171,
+            439,
+            823,
+            468
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. Reading wikipedia to answer opendomain questions. In ACL, 2017. ",
+        "bbox": [
+            173,
+            477,
+            823,
+            506
+        ],
+        "page_idx": 10
+    },
+    {
+        "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. arXiv preprint arXiv:1406.1078, 2014. ",
+        "bbox": [
+            176,
+            513,
+            823,
+            558
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher Clark and Matt Gardner. Simple and effective multi-paragraph reading comprehension. In ACL, 2018. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dick Cunningham and Scott L Shablak. Selective reading guide-o-rama: The content teacher’s best friend. Journal of Reading, 1975. ",
+        "bbox": [
+            174,
+            603,
+            823,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rajarshi Das, Manzil Zaheer, Siva Reddy, and Andrew McCallum. Question answering on knowledge bases and text using universal schema and memory networks. In ACL, 2017. ",
+        "bbox": [
+            173,
+            641,
+            823,
+            670
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rajarshi Das, Shehzaad Dhuliawala, Manzil Zaheer, Luke Vilnis, Ishan Durugkar, Akshay Krishnamurthy, Alex Smola, and Andrew McCallum. Go for a walk and arrive at the answer: Reasoning over paths in knowledge bases using reinforcement learning. In ICLR, 2018. ",
+        "bbox": [
+            178,
+            679,
+            821,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sanjoy Dasgupta and Kaushik Sinha. Randomized partition trees for exact nearest neighbor search. In COLT, 2013. ",
+        "bbox": [
+            173,
+            731,
+            825,
+            758
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bhuwan Dhingra, Hanxiao Liu, Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Gatedattention readers for text comprehension. arXiv preprint arXiv:1606.01549, 2016. ",
+        "bbox": [
+            173,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bhuwan Dhingra, Kathryn Mazaitis, and William W Cohen. Quasar: Datasets for question answering by search and reading. arXiv preprint arXiv:1707.03904, 2017. ",
+        "bbox": [
+            173,
+            805,
+            823,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey B Duggan and Stephen J Payne. Text skimming: The process and effectiveness of foraging through text under time pressure. Journal of Experimental Psychology: Applied, 2009. ",
+        "bbox": [
+            171,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew Dunn, Levent Sagun, Mike Higgins, V Ugur Guney, Volkan Cirik, and Kyunghyun Cho. Searchqa: A new q&a dataset augmented with context from a search engine. arXiv preprint arXiv:1704.05179, 2017. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bert F Green Jr, Alice K Wolf, Carol Chomsky, and Kenneth Laughery. Baseball: an automatic question-answerer. In IRE-AIEE-ACM, 1961. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 1997. ",
+        "bbox": [
+            174,
+            140,
+            808,
+            157
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Phu Mon Htut, Samuel R Bowman, and Kyunghyun Cho. Training a ranking function for open-domain question answering. arXiv preprint arXiv:1804.04264, 2018. ",
+        "bbox": [
+            173,
+            165,
+            823,
+            195
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mandar Joshi, Eunsol Choi, Daniel S Weld, and Luke Zettlemoyer. Triviaqa: A large scale distantly supervised challenge dataset for reading comprehension. In ACL, 2017. ",
+        "bbox": [
+            173,
+            204,
+            823,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Victor Lavrenko and W Bruce Croft. Relevance-based language models. In SIGIR, 2001. ",
+        "bbox": [
+            171,
+            281,
+            759,
+            297
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            305,
+            823,
+            335
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jason Lee, Kyunghyun Cho, Jason Weston, and Douwe Kiela. Emergent translation in multi-agent communication. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            373
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ke Li and Jitendra Malik. Fast k-nearest neighbour search via prioritized dci. In ICML, 2017. ",
+        "bbox": [
+            174,
+            382,
+            789,
+            398
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yankai Lin, Haozhe Ji, Zhiyuan Liu, and Maosong Sun. Denoising distantly supervised open-domain question answering. In ACL, 2018. ",
+        "bbox": [
+            174,
+            406,
+            820,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaodong Liu, Yelong Shen, Kevin Duh, and Jianfeng Gao. Stochastic answer networks for machine reading comprehension. arXiv preprint arXiv:1712.03556, 2017. ",
+        "bbox": [
+            173,
+            445,
+            823,
+            474
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yury A Malkov and Dmitry A Yashunin. Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs. TPAMI, 2018. ",
+        "bbox": [
+            173,
+            483,
+            821,
+            513
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander Miller, Adam Fisch, Jesse Dodge, Amir-Hossein Karimi, Antoine Bordes, and Jason Weston. Key-value memory networks for directly reading documents. arXiv preprint arXiv:1606.03126, 2016. ",
+        "bbox": [
+            173,
+            521,
+            826,
+            565
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sewon Min, Victor Zhong, Richard Socher, and Caiming Xiong. Efficient and robust question answering from minimal context over documents. arXiv preprint arXiv:1805.08092, 2018. ",
+        "bbox": [
+            173,
+            574,
+            823,
+            604
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mike Mintz, Steven Bills, Rion Snow, and Dan Jurafsky. Distant supervision for relation extraction without labeled data. In ACL, 2009. ",
+        "bbox": [
+            173,
+            612,
+            823,
+            642
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rodrigo Nogueira and Kyunghyun Cho. Task-oriented query reformulation with reinforcement learning. In EMNLP, 2017. ",
+        "bbox": [
+            173,
+            650,
+            823,
+            681
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonas Pfeiffer, Samuel Broscheit, Rainer Gemulla, and Mathias Goschl. A neural autoencoder ¨ approach for document ranking and query refinement in pharmacogenomic information retrieval. In BioNLP workshop, ACL, 2018. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            732
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $^ { 1 0 0 , 0 0 0 + }$ questions for machine comprehension of text. In EMNLP, 2016. ",
+        "bbox": [
+            169,
+            741,
+            825,
+            771
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Steffen Rendle, Christoph Freudenthaler, Zeno Gantner, and Lars Schmidt-Thieme. Bpr: Bayesian personalized ranking from implicit feedback. In UAI, 2009. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Minjoon Seo, Aniruddha Kembhavi, Ali Farhadi, and Hannaneh Hajishirzi. Bidirectional attention flow for machine comprehension. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. In KDD, 2017. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end memory networks. In NIPS, 2015. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Swabha Swayamdipta, Ankur P Parikh, and Tom Kwiatkowski. Multi-mention learning for reading comprehension with neural cascades. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Adam Trischler, Tong Wang, Xingdi Yuan, Justin Harris, Alessandro Sordoni, Philip Bachman, and Kaheer Suleman. Newsqa: A machine comprehension dataset. arXiv preprint arXiv:1611.09830, 2016. ",
+        "bbox": [
+            176,
+            140,
+            825,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ellen M Voorhees, others, et al. The trec-8 question answering track report. In Trec, 1999. ",
+        "bbox": [
+            173,
+            193,
+            766,
+            208
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            215,
+            823,
+            246
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang, Mo Yu, Xiaoxiao Guo, Zhiguo Wang, Tim Klinger, Wei Zhang, Shiyu Chang, Gerald Tesauro, Bowen Zhou, and Jing Jiang. R3: Reinforced ranker-reader for open-domain question answering. In AAAI, 2018a. ",
+        "bbox": [
+            176,
+            253,
+            825,
+            296
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang, Mo Yu, Jing Jiang, Wei Zhang, Xiaoxiao Guo, Shiyu Chang, Zhiguo Wang, Tim Klinger, Gerald Tesauro, and Murray Campbell. Evidence aggregation for answer re-ranking in open-domain question answering. In ICLR, 2018b. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            348
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Wei Wang, Ming Yan, and Chen Wu. Multi-granularity hierarchical attention fusion networks for reading comprehension and question answering. In ACL, 2018c. ",
+        "bbox": [
+            176,
+            357,
+            821,
+            387
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 1992. ",
+        "bbox": [
+            173,
+            395,
+            823,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Caiming Xiong, Victor Zhong, and Richard Socher. Dynamic coattention networks for question answering. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jinxi Xu and W Bruce Croft. Quary expansion using local and global document analysis. In SIGIR, 1996. ",
+        "bbox": [
+            173,
+            470,
+            823,
+            500
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Fan Yang, Zhilin Yang, and William W Cohen. Differentiable learning of logical rules for knowledge base reasoning. In NeurIPS, 2017. ",
+        "bbox": [
+            171,
+            507,
+            821,
+            537
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Adams Wei Yu, David Dohan, Minh-Thang Luong, Rui Zhao, Kai Chen, Mohammad Norouzi, and Quoc V Le. Qanet: Combining local convolution with global self-attention for reading comprehension. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            545,
+            826,
+            589
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Manzil Zaheer, Guru Guruganesh, Golan Levin, and Alex Smola. Terrapattern: A nearest neighbor search service. In Arxiv, 2019. ",
+        "bbox": [
+            171,
+            598,
+            823,
+            627
+        ],
+        "page_idx": 12
+    }
+]