Add files using upload-large-folder tool

parse/train/ByZvfijeg/ByZvfijeg.md

@@ -0,0 +1,209 @@
+# HIGHER ORDER RECURRENT NEURAL NETWORKS
+
+Rohollah Soltani & Hui Jiang   
+Department of Computer Science and Engineering   
+York University   
+Toronto, CA   
+{rsoltani,hj}@cse.yorku.ca
+
+# ABSTRACT
+
+In this paper, we study novel neural network structures to better model long term dependency in sequential data. We propose to use more memory units to keep track of more preceding states in recurrent neural networks (RNNs), which are all recurrently fed to the hidden layers as feedback through different weighted paths. By extending the popular recurrent structure in RNNs, we provide the models with better short-term memory mechanism to learn long term dependency in sequences. Analogous to digital filters in signal processing, we call these structures as higher order RNNs (HORNNs). Similar to RNNs, HORNNs can also be learned using the back-propagation through time method. HORNNs are generally applicable to a variety of sequence modelling tasks. In this work, we have examined HORNNs for the language modeling task using two popular data sets, namely the Penn Treebank (PTB) and English text8. Experimental results have shown that the proposed HORNNs yield the state-of-the-art performance on both data sets, significantly outperforming the regular RNNs as well as the popular LSTMs.
+
+# 1 INTRODUCTION
+
+In the recent resurgence of neural networks in deep learning, deep neural networks have achieved successes in various real-world applications, such as speech recognition, computer vision and natural language processing. Deep neural networks (DNNs) with a deep architecture of multiple nonlinear layers are an expressive model that can learn complex features and patterns in data. Each layer of DNNs learns a representation and transfers them to the next layer and the next layer may continue to extract more complicated features, and finally the last layer generates the desirable output. From early theoretical work, it is well known that neural networks may be used as the universal approximators to map from any fixed-size input to another fixed-size output. Recently, more and more empirical results have demonstrated that the deep structure in DNNs is not just powerful in theory but also can be reliably learned in practice from a large amount of training data.
+
+Sequential modeling is a challenging problem in machine learning, which has been extensively studied in the past. Recently, many deep neural network based models have been successful in this area, as shown in various tasks such as language modeling Mikolov (2012), sequence generation Graves (2013); Sutskever et al. (2011), machine translation Sutskever et al. (2014) and speech recognition Graves et al. (2013). Among various neural network models, recurrent neural networks (RNNs) are appealing for modeling sequential data because they can capture long term dependency in sequential data using a simple mechanism of recurrent feedback. RNNs can learn to model sequential data over an extended period of time, then carry out rather complicated transformations on the sequential data. RNNs have been theoretically proved to be a turing complete machine Siegelmann & Sontag (1995). RNNs in principle can learn to map from one variable-length sequence to another. When unfolded in time, RNNs are equivalent to very deep neural networks that share model parameters and receive the input at each time step. The recursion in the hidden layer of RNNs can act as an excellent memory mechanism for the networks. In each time step, the learned recursion weights may decide what information to discard and what information to keep in order to relay onwards along time. While RNNs are theoretically powerful, the learning of RNNs needs to use the back-propagation through time (BPTT) method Werbos (1990) due to the internal recurrent cycles. Unfortunately, in practice, it turns out to be rather difficult to train RNNs to capture long-term dependency due to the fact that the gradients in BPTT tend to either vanish or explode Bengio et al. (1994). Many heuristic methods have been proposed to solve these problems. For example, a simple method, called gradient clipping, is used to avoid gradient explosion Mikolov (2012). However, RNNs still suffer from the vanishing gradient problem since the gradients decay gradually as they are back-propagated through time. As a result, some new recurrent structures are proposed, such as long short-term memory (LSTM) Hochreiter & Schmidhuber (1997) and gated recurrent unit (GRU) Cho et al. (2014). These models use some learnable gates to implement rather complicated feedback structures, which ensure that some feedback paths can allow the gradients to flow back in time effectively. These models have given promising results in many practical applications, such as sequence modeling Graves (2013), language modeling Sundermeyer et al. (2012), hand-written character recognition Liwicki et al. (2012), machine translation Cho et al. (2014), speech recognition Graves et al. (2013).
+
+In this paper, we explore an alternative method to learn recurrent neural networks (RNNs) to model long term dependency in sequential data. We propose to use more memory units to keep track of more preceding RNN states, which are all recurrently fed to the hidden layers as feedback through different weighted paths. Analogous to digital filters in signal processing, we call these new recurrent structures as higher order recurrent neural networks (HORNNs). At each time step, the proposed HORNNs directly combine multiple preceding hidden states from various history time steps, weighted by different matrices, to generate the feedback signal to each hidden layer. By aggregating more history information of the RNN states, HORNNs are provided with better short-term memory mechanism than the regular RNNs. Moreover, those direct connections to more previous RNN states allow the gradients to flow back smoothly in the BPTT learning stage. All of these ensure that HORNNs can be more effectively learned to capture long term dependency. Similar to RNNs and LSTMs, the proposed HORNNs are general enough for variety of sequential modeling tasks. In this work, we have evaluated HORNNs for the language modeling task on two popular data sets, namely the Penn Treebank (PTB) and English text8 sets. Experimental results have shown that HORNNs yield the state-of-the-art performance on both data sets, significantly outperforming the regular RNNs as well as the popular LSTMs.
+
+# 2 RELATED WORK
+
+Hierarchical recurrent neural network proposed in Hihi & Bengio (1996) is one of the earliest papers that attempt to improve RNNs to capture long term dependency in a better way. It proposes to add linear time delayed connections to RNNs to improve the gradient descent learning algorithm to find a better solution, eventually solving the gradient vanishing problem. However, in this early work, the idea of multi-resolution recurrent architectures has only been preliminarily examined for some simple small-scale tasks. This work is somehow relevant to our work in this paper but the higher order RNNs proposed here differs in several aspects. Firstly, we propose to use weighted connections in the structure, instead of simple multi-resolution short-cut paths. This makes our models fall into the category of higher order models. Secondly, we have proposed to use various pooling functions in generating the feedback signals, which is critical in normalizing the dynamic ranges of gradients flowing from various paths. Our experiments have shown that the success of our models is largely attributed to this technique.
+
+The most successful approach to deal with vanishing gradients so far is to use long short term memory (LSTM) model Hochreiter & Schmidhuber (1997). LSTM relies on a fairly sophisticated structure made of gates to control flow of information to the hidden neurons. The drawback of the LSTM is that it is complicated and slow to learn. The complexity of this model makes the learning very time consuming, and hard to scale for larger tasks. Another approach to address this issue is to add a hidden layer to RNNs Mikolov et al. (2014). This layer is responsible for capturing longer term dependencies in input data by making its weight matrix close to identity. Recently, clockwork RNNs Koutnik et al. (2014) are proposed to address this problem as well, which splits each hidden layer into several modules running at different clocks. Each module receives signals from input and computes its output at a predefined clock rate. Gated feedback recurrent neural networks Chung et al. (2015) attempt to implement a generalized version using the gated feedback connection between layers of stacked RNNs, allowing the model to adaptively adjust the connection between consecutive hidden layers.
+
+Besides, short-cut skipping connections were considered earlier in Wermter (1992), and more recently have been found useful in learning very deep feed-forward neural networks as well, such as Lee et al. (2014); He et al. (2015). These skipping connections between various layers of neural networks can improve the flow of information in both forward and backward passes. Among them, highway networks Srivastava et al. (2015) introduce rather sophisticated skipping connections between layers, controlled by some gated functions.
+
+# 3 HIGHER ORDER RECURRENT NEURAL NETWORKS
+
+A recurrent neural network (RNN) is a type of neural network suitable for modeling a sequence of arbitrary length. At each time step $t$ , an RNN receives an input $\mathbf { x } _ { t }$ , the state of the RNN is updated recursively as follows (as shown in the left part of Figure 1):
+
+$$
+\mathbf { h } _ { t } = f ( W _ { i n } \mathbf { x } _ { t } + W _ { h } \mathbf { h } _ { t - 1 } )
+$$
+
+where $f ( \cdot )$ is an nonlinear activation function, such as sigmoid or rectified linear (ReLU), and $W _ { i n }$ is the weight matrix in the input layer and $W _ { h }$ is the state to state recurrent weight matrix. Due to the recursion, this hidden layer may act as a short-term memory of all previous input data.
+
+Given the state of the RNN, i.e., the current activation signals in the hidden layer $\mathbf { h } _ { t }$ , the RNN generates the output according to the following equation:
+
+$$
+\mathbf { y } _ { t } = g ( W _ { o u t } \mathbf { h } _ { t } )
+$$
+
+where $g ( \cdot )$ denotes the softmax function and $W _ { o u t }$ is the weight matrix in the output layer. In principle, this model can be trained using the back-propagation through time (BPTT) algorithm Werbos (1990). This model has been used widely in sequence modeling tasks like language modeling Mikolov (2012).
+
+![](images/eef5d9d6882329e33cc9b7b5a9e677cd38fe6a6a1d8d8e14eb5d83fad18a1562.jpg)  
+Figure 1: Comparison of model structures between an RNN (1st order) and a higher order RNN (3rd order). The symbol $z ^ { - 1 }$ denotes a time-delay unit (equivalent to a memory unit).
+
+# 3.1 HIGHER ORDER RNNS (HORNNS)
+
+RNNs are very deep in time and the hidden layer at each time step represents the entire input history, which acts as a short-term memory mechanism. However, due to the gradient vanishing problem in back-propagation, it turns out to be very difficult to learn RNNs to model long-term dependency in sequential data.
+
+In this paper, we extend the standard RNN structure to better model long-term dependency in sequential data. As shown in the right part of Figure 1, instead of using only the previous RNN state as the feedback signal, we propose to employ multiple memory units to generate the feedback signal at each time step by directly combining multiple preceding RNN states in the past, where these timedelayed RNN states go through separate feedback paths with different weight matrices. Analogous to the filter structures used in signal processing, we call this new recurrent structure as higher order RNNs, HORNNs in short. The order of HORNNs depends on the number of memory units used for feedback. For example, the model used in the right of Figure 1 is a 3rd-order HORNN. On the other hand, regular RNNs may be viewed as 1st-order HORNNs.
+
+In HORNNs, the feedback signal is generated by combining multiple preceding RNN states. Therefore, the state of an $N$ -th order HORNN is recursively updated as follows:
+
+$$
+\mathbf { h } _ { t } = f \left( W _ { i n } \mathbf { x } _ { t } + \sum _ { n = 1 } ^ { N } W _ { h n } \mathbf { h } _ { t - n } \right)
+$$
+
+where $\{ W _ { h n } \mid n = 1 , \cdot \cdot \cdot N \}$ denotes the weight matrices used for various feedback paths. Similar to
+
+![](images/6368fde81995a0ba60118b25389441f28b00ad4cb11cb2499cf81064e9d38e2c.jpg)
+
+![](images/52d881f96694f6d31a418b4cb135fd2b8d8c0302f055452615a0628faddb3fe9.jpg)  
+Figure 2: Unfolding a 3rd-order HORNN   
+Figure 3: Illustration of all back-propagation paths in BPTT for a 3rd-order HORNN.
+
+RNNs, HORNNs can also be unfolded in time to get rid of the recurrent cycles. As shown in Figure 2, we unfold a 3rd-order HORNN in time, which clearly shows that each HORNN state is explicitly decided by the current input $\mathbf { x } _ { t }$ and all previous 3 states in the past. This structure looks similar to the skipping short-cut paths in deep neural networks but each path in HORNNs maintains a learnable weight matrix. The new structure in HORNNs can significantly improve the model capacity to capture long-term dependency in sequential data. At each time step, by explicitly aggregating multiple preceding hidden activities, HORNNs may derive a good representation of the history information in sequences, leading to a significantly enhanced short-term memory mechanism.
+
+During the backprop learning procedure, these skipping paths directly connected to more previous hidden states of HORNNs may allow the gradients to flow more easily back in time, which eventually leads to a more effective learning of models to capture long term dependency in sequences. Therefore, this structure may help to largely alleviate the notorious problem of vanishing gradients in the RNN learning.
+
+Obviously, HORNNs can be learned using the same BPTT algorithm as regular RNNs, except that the error signals at each time step need to be back-propagated to multiple feedback paths in the network. As shown in Figure 3, for a 3rd-order HORNN, at each time step $t$ , the error signal from the hidden layer $\mathbf { h } _ { t }$ will have to be back-propagated into four different paths: i) the first one back to the input layer, $\mathbf { x } _ { t }$ ; ii) three more feedback paths leading to three different histories in time scales, namely $\mathbf { h } _ { t - 1 } , \mathbf { h } _ { t - 2 }$ and $\mathbf { h } _ { t - 3 }$ .
+
+Interestingly enough, if we use a fully-unfolded implementation for HORNNs as in Figure 2, the overall computation complexity is comparable with regular RNNs. Given a whole sequence, we may first simultaneously compute all hidden activities (from $\mathbf { x } _ { t }$ to $\mathbf { h } _ { t }$ for all $t$ ). Secondly, we recursively update $\mathbf { h } _ { t }$ for all $t$ using eq.(3). Finally, we use GPUs to compute all outputs together from the updated hidden states (from $\mathbf { h } _ { t }$ to $\mathbf { y } _ { t }$ for all $t$ ) based on eq.(2). The backward pass in learning can also be implemented in the same three-step procedure. Except the recursive updates in the second step (this issue remains the same in regular RNNs), all remaining computation steps can be formulated as large matrix multiplications. As a result, the computation of HORNNs can be implemented fairly efficiently using GPUs.
+
+# 3.2 POOLING FUNCTIONS FOR HORNNS
+
+As discussed above, the shortcut paths in HORNNs may help the models to capture long-term dependency in sequential data. On the other hand, they may also complicate the learning in a different way. Due to different numbers of hidden layers along various paths, the signals flowing from different paths may vary dramatically in the dynamic range. For example, in the forward pass in Figure 2, three different feedback signals from different time scales, e.g. $\mathbf { h } _ { t - 1 }$ , $\mathbf { h } _ { t - 2 }$ and $\mathbf { h } _ { t - 3 }$ , flow into the hidden layer to compute the new hidden state $\mathbf { h } _ { t }$ . The dynamic range of these signals may vary dramatically from case to case. The situation may get even worse in the backward pass during the BPTT learning. For example, in a 3rd-order HORNN in Figure 2, the node $\mathbf { h } _ { t - 3 }$ may directly receive an error signal from the node $\mathbf { h } _ { t }$ . In some cases, it may get so strong as to overshadow other error signals coming from closer neighbours of $\mathbf { h } _ { t - 1 }$ and $\mathbf { h } _ { t - 2 }$ . This may impede the learning of HORNNs, yielding slow convergence or even poor performance.
+
+Here, we have proposed to use some pooling functions to calibrate the signals from different feedback paths before they are used to recursively generate a new hidden state, as shown in Figure 4. In the following, we will investigate three different choices for the pooling function in Figure 4, including max-based pooling, FOFE-based pooling and gated pooling.
+
+# 3.2.1 MAX-BASED POOLING
+
+Max-based pooling is a simple strategy that chooses the most responsive unit (exhibiting the largest activation value) among various paths to transfer to the hidden layer to generate the new hidden state. Many biological experiments have shown that biological neuron networks tend to use a similar strategy in learning and firing.
+
+In this case, instead of using eq.(3), we use the following formula to update the hidden state of HORNNs:
+
+$$
+\mathbf { h } _ { t } = f { \Big ( } W _ { i n } \mathbf { x } _ { t } + \operatorname* { m a x } _ { n = 1 } ^ { N } \left( W _ { h n } \mathbf { h } _ { t - n } \right) { \Big ) }
+$$
+
+where maximization is performed element-wisely to choose the maximum value in each dimension to feed to the hidden layer to generate the new hidden state. The aim here is to capture the most relevant feature and map it to a fixed predefined size.
+
+The max pooling function is simple and biologically inspired. However, the max pooling strategy also has some serious disadvantages. For example, it has no forgetting mechanism and the signals may get stronger and stronger. Furthermore, it loses the order information of the preceding histories since it only choose the maximum values but it does not know where the maximum comes from.
+
+![](images/1f37df70d286c8f8010ea413f291e10793b708491ea623a780fd375858817e9e.jpg)  
+Figure 4: A pooling function is used to calibrate various feedback paths in HORNNs.
+
+![](images/6d0b847bd990b281709b3a2200858a66ca529fab620367f21aee8143e9976fa9.jpg)  
+Figure 5: Gated HORNNs use learnable gates to combine various feedback signals.
+
+# 3.2.2 FOFE-BASED POOLING
+
+The fixed-size ordinally-forgetting encoding (FOFE) method was proposed in Zhang et al. (2015) to encode any variable-length sequence of data into a fixed-size representation. In FOFE, a single forgetting factor $\alpha$ （ $0 \textless \alpha \textless 1$ ) is used to encode the position information in sequences based on the idea of exponential forgetting to derive invertible fixed-size representations. In this work, we borrow this simple idea of exponential forgetting to calibrate all preceding histories using a pre-selected forgetting factor as follows:
+
+$$
+\mathbf { h } _ { t } = f \left( W _ { i n } \mathbf { x } _ { t } + \sum _ { n = 1 } ^ { N } \mathbf { \sigma } \alpha ^ { n } \cdot W _ { h n } \mathbf { h } _ { t - n } \right)
+$$
+
+where the forgetting factor $\alpha$ is manually pre-selected between $0 \textless \alpha \textless 1$ . The above constant coefficients related to $\alpha$ play an important role in calibrating signals from different paths in both
+
+forward and backward passes of HORNNs since they slightly underweight the older history over the recent one in an explicit way.
+
+# 3.2.3 GATED HORNNS
+
+In this section, we follow the ideas of the learnable gates in LSTMs Hochreiter & Schmidhuber (1997) and GRUs Cho et al. (2014) as well as the recent soft-attention in Bahdanau et al. (2014). Instead of using constant coefficients derived from a forgetting factor, we may let the network automatically determine the combination weights based on the current state and input. In this case, we may use sigmoid gates to compute combination weights to regulate the information flowing from various feedback paths. The sigmoid gates take the current data and previous hidden state as input to decide how to weight all of the precede hidden states. The gate function weights how the current hidden state is generated based on all the previous time-steps of the hidden layer. This allows the network to potentially remember information for a longer period of time. In a gated HORNN, the hidden state is recursively computed as follows:
+
+$$
+\mathbf { h } _ { t } = f \left( W _ { i n } \mathbf { x } _ { t } + \sum _ { n = 1 } ^ { N } \mathbf { r } _ { n } \odot \left( W _ { h n } \mathbf { h } _ { t - n } \right) \right)
+$$
+
+where $\odot$ denotes element-wise multiplication of two equally-sized vectors, and the gate signal ${ \bf r } _ { n }$ is calculated as
+
+$$
+{ \bf r } _ { n } = \sigma \left( W _ { 1 n } ^ { g } { \bf x } _ { t } + W _ { 2 n } ^ { g } { \bf h } _ { t - n } \right)
+$$
+
+where each g $\sigma ( \cdot )$ is the sigmoid function, and $W _ { 1 n } ^ { g }$ and $W _ { 2 n } ^ { g }$ denote two weight matrices introduced for
+
+Note that the computation complexity of gated HORNNs is comparable with LSTMs and GRUs, significantly exceeding the other HORNN structures because of the overhead from the gate functions in eq. (7).
+
+# 4 EXPERIMENTS
+
+In this section, we evaluate the proposed higher order RNNs (HORNNs) on several language modeling tasks. A statistical language model (LM) is a probability distribution over sequences of words in natural languages. Recently, neural networks have been successfully applied to language modeling Bengio et al. (2003); Mikolov et al. (2011), yielding the state-of-the-art performance. In language modeling tasks, it is quite important to take advantage of the long-term dependency of natural languages. Therefore, it is widely reported that RNN based LMs can outperform feedforward neural networks in language modeling tasks. We have chosen two popular LM data sets, namely the Penn Treebank (PTB) and English text8 sets, to compare our proposed HORNNs with traditional n-gram LMs, RNN-based LMs and the state-of-the-art performance obtained by LSTMs Graves (2013); Mikolov et al. (2014), FOFE based feedforward NNs Zhang et al. (2015) and memory networks Sukhbaatar et al. (2015).
+
+In our experiments, we use the mini-batch stochastic gradient decent (SGD) algorithm to train all neural networks. The number of back-propagation through time (BPTT) steps is set to 30 for all recurrent models. Each model update is conducted using a mini-batch of 20 subsequences, each of which is of 30 in length. All model parameters (weight matrices in all layers) are randomly initialized based on a Gaussian distribution with zero mean and standard deviation of 0.1. A hard clipping is set to 5.0 to avoid gradient explosion during the BPTT learning. The initial learning rate is set to 0.5 and we halve the learning rate at the end of each epoch if the cross entropy function on the validation set does not decrease. We have used the weight decay, momentum and column normalization Pachitariu & Sahani (2013) in our experiments to improve model generalization. In the FOFE-based pooling function for HORNNs, we set the forgetting factor, $\alpha$ , to 0.6. We have used 400 nodes in each hidden layer for the PTB data set and 500 nodes per hidden layer for the English text8 set. In our experiments, we do not use the dropout regularization Zaremba et al. (2014) in all experiments since it significantly slows down the training speed, not applicable to any larger corpora.
+
+Table 1: Perplexities on the PTB test set for various HORNNs are shown as a function of order (2, 3, 4). Note the perplexity of a regular RNN (1st order) is 123, as reported in Mikolov et al. (2011).   
+
+<table><tr><td>Models</td><td>2nd order</td><td>3rd order</td><td>4th order</td></tr><tr><td>HORNN</td><td>111</td><td>108</td><td>109</td></tr><tr><td>MaxHORNN</td><td>110</td><td>109</td><td>108</td></tr><tr><td>FOFEHORNN</td><td>103</td><td>101</td><td>100</td></tr><tr><td>GatedHORNN</td><td>102</td><td>100</td><td>100</td></tr></table>
+
+# 4.1 LANGUAGE MODELING ON PTB
+
+The standard Penn Treebank (PTB) corpus consists of about 1M words. The vocabulary size is limited to 10k. The preprocessing method and the way to split data into training/validation/test sets are the same as Mikolov et al. (2011). PTB is a relatively small text corpus. We first investigate various model configurations for the HORNNs based on PTB and then compare the best performance with other results reported on this task.
+
+# 4.1.1 EFFECT OF ORDERS IN HORNNS
+
+In the first experiment, we first investigate how the used orders in HORNNs may affect the performance of language models (as measured by perplexity). We have examined all different higher order model structures proposed in this paper, including HORNNs and various pooling functions in HORNNs. The orders of these examined models varies among 2, 3 and 4. We have listed the performance of different models on PTB in Table 1. As we may see, we are able to achieve a significant improvement in perplexity when using higher order RNNs for language models on PTB, roughly 10-20 reduction in PPL over regular RNNs. We can see that performance may improve slightly when the order is increased from 2 to 3 but no significant gain is observed when the order is further increased to 4. As a result, we choose the 3rd-order HORNN structure for the following experiments. Among all different HORNN structures, we can see that FOFE-based pooling and gated structures yield the best performance on PTB.
+
+In language modeling, both input and output layers account for the major portion of model parameters. Therefore, we do not significantly increase model size when we go to higher order structures. For example, in Table 1, a regular RNN contains about 8.3 millions of weights while a 3rd-order HORNN (the same for max or FOFE pooling structures) has about 8.6 millions of weights. In comparison, an LSTM model has about 9.3 millions of weights and a 3rd-order gated HORNN has about 9.6 millions of weights.
+
+As for the training speed, most HORNN models are only slightly slower than regular RNNs. For example, one epoch of training on PTB running in one NVIDIA’s TITAN X GPU takes about 80 seconds for an RNN, about 120 seconds for a 3rd-order HORNN (the same for max or FOFE pooling structures). Similarly, training of gated HORNNs is also slightly slower than LSTMs. For example, one epoch on PTB takes about 200 seconds for an LSTM, and about 225 seconds for a 3rd-order gates HORNN.
+
+# 4.1.2 MODEL COMPARISON ON PENN TREEBANK
+
+At last, we report the best performance of various HORNNs on the PTB test set in Table 2. We compare our 3rd-order HORNNs with all other models reported on this task, including RNN Mikolov et al. (2011), stack RNN Pascanu et al. (2014), deep RNN Pascanu et al. (2014), FOFE-FNN Zhang et al. (2015) and LSTM Graves (2013). 2 From the results in Table 2, we can see that our proposed higher order RNN architectures significantly outperform all other baseline models reported on this task. Both FOFE-based pooling and gated HORNNs have achieved the state-of-the-art performance, i.e., 100 in perplexity on this task. To the best of our knowledge, this is the best reported performance on PTB under the same training condition.
+
+Table 2: Perplexities on the PTB test set for various examined models.   
+Table 3: Perplexities on the text8 test set for various models.   
+
+<table><tr><td>Models KN 5-gram Mikolov et al. (2011)</td><td>Test 141</td></tr><tr><td>RNN Mikolov et al. (2011) CSLM5Aransa et al. (2015) LSTM Graves (2013) genCNN Wang et al. (2015) Gated word&amp;charMiyamoto &amp; Cho (2016) E2E Mem Net Sukhbaatar et al. (2015) Stack RNN Pascanu et al. (2014) Deep RNN Pascanu et al. (2014) FOFE-FNN Zhang et al. (2015)</td><td>123 118.08 117 116.4 113.52 111 110 107 108</td></tr><tr><td>HORNN (3rd order) Max HORNN (3rd order) FOFE HORNN (3rd order) Gated HORNN (3rd order)</td><td>108 109 101 100</td></tr></table>
+
+<table><tr><td>Models</td><td>Test</td></tr><tr><td>RNN Mikolov et al. (2014) LSTM Mikolov et al. (2014) SCRNN Mikolov et al. (2014) E2E Mem Net Sukhbaatar et al. (2015)</td><td>184 156 161 147</td></tr><tr><td>HORNN (3rd order) Max HORNN (3rd order) FOFE HORNN (3rd order) Gated HORNN (3rd</td><td>172 163 154</td></tr></table>
+
+# 4.2 LANGUAGE MODELING ON ENGLISH TEXT8
+
+In this experiment, we will evaluate our proposed HORNNs on a much larger text corpus, namely the English text8 data set. The text8 data set contains a preprocessed version of the first 100 million characters downloaded from the Wikipedia website. We have used the same preprocessing method as Mikolov et al. (2014) to process the data set to generate the training and test sets. We have limited the vocabulary size to about $4 4 \mathrm { k }$ by replacing all words occurring less than 10 times in the training set with an ${ \bf \mathrm { < U N K > } }$ token. The text8 set is about 20 times larger than PTB in corpus size. The model training on text8 takes longer to finish. We have not tuned hyperparameters in this data set. We simply follow the best setting used in PTB to train all HORNNs for the text8 data set. Meanwhile, we also follow the same learning schedule used in Mikolov et al. (2014): We first initialize the learning rate to 0.5 and run 5 epochs using this learning rate; After that, the learning rate is halved at the end of every epoch.
+
+Because the training is time-consuming, we have only evaluated 3rd-order HORNNs on the text8 data set. The perplexities of various HORNNs are summarized in Table 3. We have compared our HORNNs with all other baseline models reported on this task, including RNN Mikolov et al. (2014), LSTM Mikolov et al. (2014), SCRNN Mikolov et al. (2014) and end-to-end memory networks Sukhbaatar et al. (2015). Results have shown that all HORNN models work pretty well in this data set except the normal HORNN significantly underperforms the other three models. Among them, the gated HORNN model has achieved the best performance, i.e., 144 in perplexity on this task, which is slightly better than the recent result obtained by end-to-end memory networks (using a rather complicated structure). To the best of our knowledge, this is the best performance reported on this task.
+
+# 5 CONCLUSIONS
+
+In this paper, we have proposed some new structures for recurrent neural networks, called as higher order RNNs (HORNNs). In these structures, we use more memory units to keep track of more preceding RNN states, which are all fed along various feedback paths to the hidden layer to generate the feedback signals. In this way, we may enhance the model to capture long term dependency in sequential data. Moreover, we have proposed to use several types of pooling functions to calibrate multiple feedback paths. Experiments have shown that the pooling technique plays a critical role in learning higher order RNNs effectively. In this work, we have examined HORNNs for the language modeling task using two popular data sets, namely the Penn Treebank (PTB) and text8 sets. Experimental results have shown that the proposed higher order RNNs yield the state-of-the-art performance on both data sets, significantly outperforming the regular RNNs as well as the popular LSTMs. As the future work, we are going to continue to explore HORNNs for other sequential modeling tasks, such as speech recognition, sequence-to-sequence modelling and so on.
+
+REFERENCES   
+Walid Aransa, Holger Schwenk, and Lo¨ıc Barrault. Improving continuous space language models using auxiliary features. In Proceedings of the 12th International Workshop on Spoken Language Translation, pp. 151–158, 2015.   
+D. Bahdanau, K. Cho, and Y. Bengio. Neural machine translation by jointly learning to align and translate. In arXiv:1409.0473, 2014.   
+Y. Bengio, P. Simard, and P. Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 5(2):157–166, 1994.   
+Y. Bengio, R. Ducharme, P. Vincent, and C. Janvin. A neural probabilistic language model. Journal of Machine Learning Research, 3:1137–1155, 2003.   
+K. Cho, B. Van Merrienboer, C. Gulcehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio. ¨ Learning phrase representations using RNN encoder-decoder for statistical machine translation. In Proceedings of EMNLP, 2014.   
+J. Chung, C. Gulcehre, K. Cho, and Y. Bengio. Gated feedback recurrent neural networks. In Proceedings of International Conference on Machine Learning (ICML), 2015.   
+A. Graves. Generating sequences with recurrent neural networks. In arXiv:1308.0850, 2013.   
+A. Graves, A. Mohamed, and G Hinton. Speech recognition with deep recurrent neural. In Proceedings of ICASSP, 2013.   
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In arXiv:1512.03385, 2015.   
+Salah Hihi and Yoshua Bengio. Hierarchical recurrent neural networks for long-term dependencies. In Proceedings of Neural Information Processing Systems (NIPS), 1996.   
+S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.   
+Y. Kim, Y. Jernite, D. Sontag, and A. M. Rush. Character-aware neural language models. In arXiv:1508.06615, 2015.   
+J. Koutnik, K. Greff, F. Gomez, and J. Schmidhuber. A clockwork rnn. In Proceedings of International Conference on Machine Learning (ICML), 2014.   
+C. Y. Lee, S. Xie, P. Gallagher, Z. Zhang, and Z. Tu. Deeply supervised nets. In arXiv:1409.5185, 2014.   
+M. Liwicki, A. Graves, and H. Bunke. Neural networks for handwriting recognition, Book Chapter, Computational intelligence paradigms in advanced pattern classification. Springer Berlin Heidelberg, 2012.   
+T. Mikolov. Statistical Language Models based on Neural Networks. PhD thesis, Brno University of Technology, 2012.   
+T. Mikolov, S. Kombrink, L. Burget, J.H. Cernock ˇ y, and S. Khudanpur. Extensions of recurrent \` neural network language model. In Proceedings ICASSP, pp. 5528–5531, 2011.   
+T. Mikolov, A. Joulin, S. Chopra, M. Mathieu, and M. Ranzato. Learning longer memory in recurrent neural networks. In arXiv 1412.7753, 2014.   
+Yasumasa Miyamoto and Kyunghyun Cho. Gated word-character recurrent language model. arXiv preprint arXiv:1606.01700, 2016.   
+M. Pachitariu and M. Sahani. Regularization and nonlinearities for neural language models: when are they needed? In arXiv:1301.5650, 2013.   
+R. Pascanu, C. Gulcehre, K. Cho, and Y. Bengio. How to construct deep recurrent neural networks. In Proceedings of ICLR, 2014.   
+H. T. Siegelmann and E. D. Sontag. On the computational power of neural nets. Journal of computer and system sciences, 50.(1):132–150, 1995.   
+R. K. Srivastava, K. Greff, and J. Schmidhuber. Highway networks. In Proceedings of Neural Information Processing Systems (NIPS), 2015.   
+S. Sukhbaatar, A. Szlam, J. Weston, and R. Fergus. End-to-end memory networks. In Proceedings of Neural Information Processing Systems (NIPS), 2015.   
+M. Sundermeyer, R. Schlter, and H. Ne. LSTM neural networks for language modeling. In Proceedings of Interspeech, 2012.   
+I. Sutskever, J. Martens, and G Hinton. Generating text with recurrent neural networks. In Proceedings of International Conference on Machine Learning (ICML), 2011.   
+I. Sutskever, O. Vinyals, and Q. Le. Sequence to sequence learning with neural networks. In Proceedings of Neural Information Processing Systems (NIPS), 2014.   
+Mingxuan Wang, Zhengdong Lu, Hang Li, Wenbin Jiang, and Qun Liu. gen cnn: A convolutional architecture for word sequence prediction. arXiv preprint arXiv:1503.05034, 2015.   
+P. J. Werbos. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10):1550–1560, 1990.   
+Stefan Wermter. A hybrid and connectionist architecture for a scanning understanding. In Proceedings of the 10th European conference on Artificial intelligence, 1992.   
+W. Zaremba, I. Sutskever, and O.l Vinyals. Recurrent neural network regularization. In arXiv:1409.2329, 2014.   
+S. Zhang, H. Jiang, M. Xu, J. Hou, and L. Dai. The fixed-size ordinally-forgetting encoding method for neural network language models. In Proceedings of ACL, pp. 495–500, 2015.

parse/train/ByZvfijeg/ByZvfijeg_content_list.json

@@ -0,0 +1,945 @@
+[
+    {
+        "type": "text",
+        "text": "HIGHER ORDER RECURRENT NEURAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            781,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rohollah Soltani & Hui Jiang   \nDepartment of Computer Science and Engineering   \nYork University   \nToronto, CA   \n{rsoltani,hj}@cse.yorku.ca ",
+        "bbox": [
+            184,
+            143,
+            516,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            252,
+            544,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we study novel neural network structures to better model long term dependency in sequential data. We propose to use more memory units to keep track of more preceding states in recurrent neural networks (RNNs), which are all recurrently fed to the hidden layers as feedback through different weighted paths. By extending the popular recurrent structure in RNNs, we provide the models with better short-term memory mechanism to learn long term dependency in sequences. Analogous to digital filters in signal processing, we call these structures as higher order RNNs (HORNNs). Similar to RNNs, HORNNs can also be learned using the back-propagation through time method. HORNNs are generally applicable to a variety of sequence modelling tasks. In this work, we have examined HORNNs for the language modeling task using two popular data sets, namely the Penn Treebank (PTB) and English text8. Experimental results have shown that the proposed HORNNs yield the state-of-the-art performance on both data sets, significantly outperforming the regular RNNs as well as the popular LSTMs. ",
+        "bbox": [
+            233,
+            285,
+            764,
+            478
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            336,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the recent resurgence of neural networks in deep learning, deep neural networks have achieved successes in various real-world applications, such as speech recognition, computer vision and natural language processing. Deep neural networks (DNNs) with a deep architecture of multiple nonlinear layers are an expressive model that can learn complex features and patterns in data. Each layer of DNNs learns a representation and transfers them to the next layer and the next layer may continue to extract more complicated features, and finally the last layer generates the desirable output. From early theoretical work, it is well known that neural networks may be used as the universal approximators to map from any fixed-size input to another fixed-size output. Recently, more and more empirical results have demonstrated that the deep structure in DNNs is not just powerful in theory but also can be reliably learned in practice from a large amount of training data. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            681
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sequential modeling is a challenging problem in machine learning, which has been extensively studied in the past. Recently, many deep neural network based models have been successful in this area, as shown in various tasks such as language modeling Mikolov (2012), sequence generation Graves (2013); Sutskever et al. (2011), machine translation Sutskever et al. (2014) and speech recognition Graves et al. (2013). Among various neural network models, recurrent neural networks (RNNs) are appealing for modeling sequential data because they can capture long term dependency in sequential data using a simple mechanism of recurrent feedback. RNNs can learn to model sequential data over an extended period of time, then carry out rather complicated transformations on the sequential data. RNNs have been theoretically proved to be a turing complete machine Siegelmann & Sontag (1995). RNNs in principle can learn to map from one variable-length sequence to another. When unfolded in time, RNNs are equivalent to very deep neural networks that share model parameters and receive the input at each time step. The recursion in the hidden layer of RNNs can act as an excellent memory mechanism for the networks. In each time step, the learned recursion weights may decide what information to discard and what information to keep in order to relay onwards along time. While RNNs are theoretically powerful, the learning of RNNs needs to use the back-propagation through time (BPTT) method Werbos (1990) due to the internal recurrent cycles. Unfortunately, in practice, it turns out to be rather difficult to train RNNs to capture long-term dependency due to the fact that the gradients in BPTT tend to either vanish or explode Bengio et al. (1994). Many heuristic methods have been proposed to solve these problems. For example, a simple method, called gradient clipping, is used to avoid gradient explosion Mikolov (2012). However, RNNs still suffer from the vanishing gradient problem since the gradients decay gradually as they are back-propagated through time. As a result, some new recurrent structures are proposed, such as long short-term memory (LSTM) Hochreiter & Schmidhuber (1997) and gated recurrent unit (GRU) Cho et al. (2014). These models use some learnable gates to implement rather complicated feedback structures, which ensure that some feedback paths can allow the gradients to flow back in time effectively. These models have given promising results in many practical applications, such as sequence modeling Graves (2013), language modeling Sundermeyer et al. (2012), hand-written character recognition Liwicki et al. (2012), machine translation Cho et al. (2014), speech recognition Graves et al. (2013). ",
+        "bbox": [
+            174,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we explore an alternative method to learn recurrent neural networks (RNNs) to model long term dependency in sequential data. We propose to use more memory units to keep track of more preceding RNN states, which are all recurrently fed to the hidden layers as feedback through different weighted paths. Analogous to digital filters in signal processing, we call these new recurrent structures as higher order recurrent neural networks (HORNNs). At each time step, the proposed HORNNs directly combine multiple preceding hidden states from various history time steps, weighted by different matrices, to generate the feedback signal to each hidden layer. By aggregating more history information of the RNN states, HORNNs are provided with better short-term memory mechanism than the regular RNNs. Moreover, those direct connections to more previous RNN states allow the gradients to flow back smoothly in the BPTT learning stage. All of these ensure that HORNNs can be more effectively learned to capture long term dependency. Similar to RNNs and LSTMs, the proposed HORNNs are general enough for variety of sequential modeling tasks. In this work, we have evaluated HORNNs for the language modeling task on two popular data sets, namely the Penn Treebank (PTB) and English text8 sets. Experimental results have shown that HORNNs yield the state-of-the-art performance on both data sets, significantly outperforming the regular RNNs as well as the popular LSTMs. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            525,
+            343,
+            541
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical recurrent neural network proposed in Hihi & Bengio (1996) is one of the earliest papers that attempt to improve RNNs to capture long term dependency in a better way. It proposes to add linear time delayed connections to RNNs to improve the gradient descent learning algorithm to find a better solution, eventually solving the gradient vanishing problem. However, in this early work, the idea of multi-resolution recurrent architectures has only been preliminarily examined for some simple small-scale tasks. This work is somehow relevant to our work in this paper but the higher order RNNs proposed here differs in several aspects. Firstly, we propose to use weighted connections in the structure, instead of simple multi-resolution short-cut paths. This makes our models fall into the category of higher order models. Secondly, we have proposed to use various pooling functions in generating the feedback signals, which is critical in normalizing the dynamic ranges of gradients flowing from various paths. Our experiments have shown that the success of our models is largely attributed to this technique. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            736
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The most successful approach to deal with vanishing gradients so far is to use long short term memory (LSTM) model Hochreiter & Schmidhuber (1997). LSTM relies on a fairly sophisticated structure made of gates to control flow of information to the hidden neurons. The drawback of the LSTM is that it is complicated and slow to learn. The complexity of this model makes the learning very time consuming, and hard to scale for larger tasks. Another approach to address this issue is to add a hidden layer to RNNs Mikolov et al. (2014). This layer is responsible for capturing longer term dependencies in input data by making its weight matrix close to identity. Recently, clockwork RNNs Koutnik et al. (2014) are proposed to address this problem as well, which splits each hidden layer into several modules running at different clocks. Each module receives signals from input and computes its output at a predefined clock rate. Gated feedback recurrent neural networks Chung et al. (2015) attempt to implement a generalized version using the gated feedback connection between layers of stacked RNNs, allowing the model to adaptively adjust the connection between consecutive hidden layers. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Besides, short-cut skipping connections were considered earlier in Wermter (1992), and more recently have been found useful in learning very deep feed-forward neural networks as well, such as Lee et al. (2014); He et al. (2015). These skipping connections between various layers of neural networks can improve the flow of information in both forward and backward passes. Among them, highway networks Srivastava et al. (2015) introduce rather sophisticated skipping connections between layers, controlled by some gated functions. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 HIGHER ORDER RECURRENT NEURAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            207,
+            627,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A recurrent neural network (RNN) is a type of neural network suitable for modeling a sequence of arbitrary length. At each time step $t$ , an RNN receives an input $\\mathbf { x } _ { t }$ , the state of the RNN is updated recursively as follows (as shown in the left part of Figure 1): ",
+        "bbox": [
+            174,
+            238,
+            825,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/413b8b2afb9de0fd050df2b540a8f45d6e32a011c2f83b02487270de0c36e994.jpg",
+        "text": "$$\n\\mathbf { h } _ { t } = f ( W _ { i n } \\mathbf { x } _ { t } + W _ { h } \\mathbf { h } _ { t - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            285,
+            591,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f ( \\cdot )$ is an nonlinear activation function, such as sigmoid or rectified linear (ReLU), and $W _ { i n }$ is the weight matrix in the input layer and $W _ { h }$ is the state to state recurrent weight matrix. Due to the recursion, this hidden layer may act as a short-term memory of all previous input data. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given the state of the RNN, i.e., the current activation signals in the hidden layer $\\mathbf { h } _ { t }$ , the RNN generates the output according to the following equation: ",
+        "bbox": [
+            171,
+            356,
+            821,
+            385
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e142963aebc9c5efcac8791b92e9d28f0f3c54f6f5561e9e899742d780ae510f.jpg",
+        "text": "$$\n\\mathbf { y } _ { t } = g ( W _ { o u t } \\mathbf { h } _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            390,
+            555,
+            407
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $g ( \\cdot )$ denotes the softmax function and $W _ { o u t }$ is the weight matrix in the output layer. In principle, this model can be trained using the back-propagation through time (BPTT) algorithm Werbos (1990). This model has been used widely in sequence modeling tasks like language modeling Mikolov (2012). ",
+        "bbox": [
+            174,
+            411,
+            825,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/eef5d9d6882329e33cc9b7b5a9e677cd38fe6a6a1d8d8e14eb5d83fad18a1562.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of model structures between an RNN (1st order) and a higher order RNN (3rd order). The symbol $z ^ { - 1 }$ denotes a time-delay unit (equivalent to a memory unit). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            478,
+            728,
+            618
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 HIGHER ORDER RNNS (HORNNS) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            709,
+            460,
+            723
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RNNs are very deep in time and the hidden layer at each time step represents the entire input history, which acts as a short-term memory mechanism. However, due to the gradient vanishing problem in back-propagation, it turns out to be very difficult to learn RNNs to model long-term dependency in sequential data. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            791
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we extend the standard RNN structure to better model long-term dependency in sequential data. As shown in the right part of Figure 1, instead of using only the previous RNN state as the feedback signal, we propose to employ multiple memory units to generate the feedback signal at each time step by directly combining multiple preceding RNN states in the past, where these timedelayed RNN states go through separate feedback paths with different weight matrices. Analogous to the filter structures used in signal processing, we call this new recurrent structure as higher order RNNs, HORNNs in short. The order of HORNNs depends on the number of memory units used for feedback. For example, the model used in the right of Figure 1 is a 3rd-order HORNN. On the other hand, regular RNNs may be viewed as 1st-order HORNNs. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In HORNNs, the feedback signal is generated by combining multiple preceding RNN states. Therefore, the state of an $N$ -th order HORNN is recursively updated as follows: ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee2877e75e09eeb756afbcb27743b96101e1b5139946869d469f7cc14b7831eb.jpg",
+        "text": "$$\n\\mathbf { h } _ { t } = f \\left( W _ { i n } \\mathbf { x } _ { t } + \\sum _ { n = 1 } ^ { N } W _ { h n } \\mathbf { h } _ { t - n } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            136,
+            617,
+            180
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\{ W _ { h n } \\mid n = 1 , \\cdot \\cdot \\cdot N \\}$ denotes the weight matrices used for various feedback paths. Similar to ",
+        "bbox": [
+            171,
+            184,
+            823,
+            199
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/6368fde81995a0ba60118b25389441f28b00ad4cb11cb2499cf81064e9d38e2c.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            531,
+            212,
+            795,
+            334
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/52d881f96694f6d31a418b4cb135fd2b8d8c0302f055452615a0628faddb3fe9.jpg",
+        "image_caption": [
+            "Figure 2: Unfolding a 3rd-order HORNN ",
+            "Figure 3: Illustration of all back-propagation paths in BPTT for a 3rd-order HORNN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            219,
+            498,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "RNNs, HORNNs can also be unfolded in time to get rid of the recurrent cycles. As shown in Figure 2, we unfold a 3rd-order HORNN in time, which clearly shows that each HORNN state is explicitly decided by the current input $\\mathbf { x } _ { t }$ and all previous 3 states in the past. This structure looks similar to the skipping short-cut paths in deep neural networks but each path in HORNNs maintains a learnable weight matrix. The new structure in HORNNs can significantly improve the model capacity to capture long-term dependency in sequential data. At each time step, by explicitly aggregating multiple preceding hidden activities, HORNNs may derive a good representation of the history information in sequences, leading to a significantly enhanced short-term memory mechanism. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            512
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "During the backprop learning procedure, these skipping paths directly connected to more previous hidden states of HORNNs may allow the gradients to flow more easily back in time, which eventually leads to a more effective learning of models to capture long term dependency in sequences. Therefore, this structure may help to largely alleviate the notorious problem of vanishing gradients in the RNN learning. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Obviously, HORNNs can be learned using the same BPTT algorithm as regular RNNs, except that the error signals at each time step need to be back-propagated to multiple feedback paths in the network. As shown in Figure 3, for a 3rd-order HORNN, at each time step $t$ , the error signal from the hidden layer $\\mathbf { h } _ { t }$ will have to be back-propagated into four different paths: i) the first one back to the input layer, $\\mathbf { x } _ { t }$ ; ii) three more feedback paths leading to three different histories in time scales, namely $\\mathbf { h } _ { t - 1 } , \\mathbf { h } _ { t - 2 }$ and $\\mathbf { h } _ { t - 3 }$ . ",
+        "bbox": [
+            173,
+            595,
+            825,
+            679
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Interestingly enough, if we use a fully-unfolded implementation for HORNNs as in Figure 2, the overall computation complexity is comparable with regular RNNs. Given a whole sequence, we may first simultaneously compute all hidden activities (from $\\mathbf { x } _ { t }$ to $\\mathbf { h } _ { t }$ for all $t$ ). Secondly, we recursively update $\\mathbf { h } _ { t }$ for all $t$ using eq.(3). Finally, we use GPUs to compute all outputs together from the updated hidden states (from $\\mathbf { h } _ { t }$ to $\\mathbf { y } _ { t }$ for all $t$ ) based on eq.(2). The backward pass in learning can also be implemented in the same three-step procedure. Except the recursive updates in the second step (this issue remains the same in regular RNNs), all remaining computation steps can be formulated as large matrix multiplications. As a result, the computation of HORNNs can be implemented fairly efficiently using GPUs. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 POOLING FUNCTIONS FOR HORNNS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            472,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As discussed above, the shortcut paths in HORNNs may help the models to capture long-term dependency in sequential data. On the other hand, they may also complicate the learning in a different way. Due to different numbers of hidden layers along various paths, the signals flowing from different paths may vary dramatically in the dynamic range. For example, in the forward pass in Figure 2, three different feedback signals from different time scales, e.g. $\\mathbf { h } _ { t - 1 }$ , $\\mathbf { h } _ { t - 2 }$ and $\\mathbf { h } _ { t - 3 }$ , flow into the hidden layer to compute the new hidden state $\\mathbf { h } _ { t }$ . The dynamic range of these signals may vary dramatically from case to case. The situation may get even worse in the backward pass during the BPTT learning. For example, in a 3rd-order HORNN in Figure 2, the node $\\mathbf { h } _ { t - 3 }$ may directly receive an error signal from the node $\\mathbf { h } _ { t }$ . In some cases, it may get so strong as to overshadow other error signals coming from closer neighbours of $\\mathbf { h } _ { t - 1 }$ and $\\mathbf { h } _ { t - 2 }$ . This may impede the learning of HORNNs, yielding slow convergence or even poor performance. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, we have proposed to use some pooling functions to calibrate the signals from different feedback paths before they are used to recursively generate a new hidden state, as shown in Figure 4. In the following, we will investigate three different choices for the pooling function in Figure 4, including max-based pooling, FOFE-based pooling and gated pooling. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 MAX-BASED POOLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            387,
+            280
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Max-based pooling is a simple strategy that chooses the most responsive unit (exhibiting the largest activation value) among various paths to transfer to the hidden layer to generate the new hidden state. Many biological experiments have shown that biological neuron networks tend to use a similar strategy in learning and firing. ",
+        "bbox": [
+            174,
+            289,
+            825,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this case, instead of using eq.(3), we use the following formula to update the hidden state of HORNNs: ",
+        "bbox": [
+            173,
+            352,
+            823,
+            378
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7222bda5f7fd04ede3109e705f687b9553dfa39620d469fc34f3c36172f60342.jpg",
+        "text": "$$\n\\mathbf { h } _ { t } = f { \\Big ( } W _ { i n } \\mathbf { x } _ { t } + \\operatorname* { m a x } _ { n = 1 } ^ { N } \\left( W _ { h n } \\mathbf { h } _ { t - n } \\right) { \\Big ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            376,
+            635,
+            404
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where maximization is performed element-wisely to choose the maximum value in each dimension to feed to the hidden layer to generate the new hidden state. The aim here is to capture the most relevant feature and map it to a fixed predefined size. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            448
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The max pooling function is simple and biologically inspired. However, the max pooling strategy also has some serious disadvantages. For example, it has no forgetting mechanism and the signals may get stronger and stronger. Furthermore, it loses the order information of the preceding histories since it only choose the maximum values but it does not know where the maximum comes from. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/1f37df70d286c8f8010ea413f291e10793b708491ea623a780fd375858817e9e.jpg",
+        "image_caption": [
+            "Figure 4: A pooling function is used to calibrate various feedback paths in HORNNs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            522,
+            472,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6d0b847bd990b281709b3a2200858a66ca529fab620367f21aee8143e9976fa9.jpg",
+        "image_caption": [
+            "Figure 5: Gated HORNNs use learnable gates to combine various feedback signals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            522,
+            805,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 FOFE-BASED POOLING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            732,
+            393,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The fixed-size ordinally-forgetting encoding (FOFE) method was proposed in Zhang et al. (2015) to encode any variable-length sequence of data into a fixed-size representation. In FOFE, a single forgetting factor $\\alpha$ （ $0 \\textless \\alpha \\textless 1$ ) is used to encode the position information in sequences based on the idea of exponential forgetting to derive invertible fixed-size representations. In this work, we borrow this simple idea of exponential forgetting to calibrate all preceding histories using a pre-selected forgetting factor as follows: ",
+        "bbox": [
+            173,
+            756,
+            825,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/23459599f717e405e0dce0893e58fbac9bd445359c31b68467ec3ffd1e2ae747.jpg",
+        "text": "$$\n\\mathbf { h } _ { t } = f \\left( W _ { i n } \\mathbf { x } _ { t } + \\sum _ { n = 1 } ^ { N } \\mathbf { \\sigma } \\alpha ^ { n } \\cdot W _ { h n } \\mathbf { h } _ { t - n } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            847,
+            635,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the forgetting factor $\\alpha$ is manually pre-selected between $0 \\textless \\alpha \\textless 1$ . The above constant coefficients related to $\\alpha$ play an important role in calibrating signals from different paths in both ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "forward and backward passes of HORNNs since they slightly underweight the older history over the recent one in an explicit way. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 GATED HORNNS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            147,
+            352,
+            162
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we follow the ideas of the learnable gates in LSTMs Hochreiter & Schmidhuber (1997) and GRUs Cho et al. (2014) as well as the recent soft-attention in Bahdanau et al. (2014). Instead of using constant coefficients derived from a forgetting factor, we may let the network automatically determine the combination weights based on the current state and input. In this case, we may use sigmoid gates to compute combination weights to regulate the information flowing from various feedback paths. The sigmoid gates take the current data and previous hidden state as input to decide how to weight all of the precede hidden states. The gate function weights how the current hidden state is generated based on all the previous time-steps of the hidden layer. This allows the network to potentially remember information for a longer period of time. In a gated HORNN, the hidden state is recursively computed as follows: ",
+        "bbox": [
+            174,
+            171,
+            825,
+            311
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c618fc44ccc87ebc5b2b1088c0e188dbdf5429382550eafe89b2557cbae8960c.jpg",
+        "text": "$$\n\\mathbf { h } _ { t } = f \\left( W _ { i n } \\mathbf { x } _ { t } + \\sum _ { n = 1 } ^ { N } \\mathbf { r } _ { n } \\odot \\left( W _ { h n } \\mathbf { h } _ { t - n } \\right) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            318,
+            648,
+            362
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ denotes element-wise multiplication of two equally-sized vectors, and the gate signal ${ \\bf r } _ { n }$ is calculated as ",
+        "bbox": [
+            173,
+            367,
+            821,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/01468c3525a7b0dabd9c99844588297b7d275365cd5580d2b78fd08decd93ad7.jpg",
+        "text": "$$\n{ \\bf r } _ { n } = \\sigma \\left( W _ { 1 n } ^ { g } { \\bf x } _ { t } + W _ { 2 n } ^ { g } { \\bf h } _ { t - n } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            393,
+            598,
+            412
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where each g $\\sigma ( \\cdot )$ is the sigmoid function, and $W _ { 1 n } ^ { g }$ and $W _ { 2 n } ^ { g }$ denote two weight matrices introduced for ",
+        "bbox": [
+            174,
+            415,
+            823,
+            444
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that the computation complexity of gated HORNNs is comparable with LSTMs and GRUs, significantly exceeding the other HORNN structures because of the overhead from the gate functions in eq. (7). ",
+        "bbox": [
+            174,
+            450,
+            825,
+            493
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            326,
+            529
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the proposed higher order RNNs (HORNNs) on several language modeling tasks. A statistical language model (LM) is a probability distribution over sequences of words in natural languages. Recently, neural networks have been successfully applied to language modeling Bengio et al. (2003); Mikolov et al. (2011), yielding the state-of-the-art performance. In language modeling tasks, it is quite important to take advantage of the long-term dependency of natural languages. Therefore, it is widely reported that RNN based LMs can outperform feedforward neural networks in language modeling tasks. We have chosen two popular LM data sets, namely the Penn Treebank (PTB) and English text8 sets, to compare our proposed HORNNs with traditional n-gram LMs, RNN-based LMs and the state-of-the-art performance obtained by LSTMs Graves (2013); Mikolov et al. (2014), FOFE based feedforward NNs Zhang et al. (2015) and memory networks Sukhbaatar et al. (2015). ",
+        "bbox": [
+            173,
+            545,
+            825,
+            698
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we use the mini-batch stochastic gradient decent (SGD) algorithm to train all neural networks. The number of back-propagation through time (BPTT) steps is set to 30 for all recurrent models. Each model update is conducted using a mini-batch of 20 subsequences, each of which is of 30 in length. All model parameters (weight matrices in all layers) are randomly initialized based on a Gaussian distribution with zero mean and standard deviation of 0.1. A hard clipping is set to 5.0 to avoid gradient explosion during the BPTT learning. The initial learning rate is set to 0.5 and we halve the learning rate at the end of each epoch if the cross entropy function on the validation set does not decrease. We have used the weight decay, momentum and column normalization Pachitariu & Sahani (2013) in our experiments to improve model generalization. In the FOFE-based pooling function for HORNNs, we set the forgetting factor, $\\alpha$ , to 0.6. We have used 400 nodes in each hidden layer for the PTB data set and 500 nodes per hidden layer for the English text8 set. In our experiments, we do not use the dropout regularization Zaremba et al. (2014) in all experiments since it significantly slows down the training speed, not applicable to any larger corpora. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            898
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/b12855ffb34efe1f4679877359369ba7c66791e3291f5f8da48d674c6b83edcc.jpg",
+        "table_caption": [
+            "Table 1: Perplexities on the PTB test set for various HORNNs are shown as a function of order (2, 3, 4). Note the perplexity of a regular RNN (1st order) is 123, as reported in Mikolov et al. (2011). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>2nd order</td><td>3rd order</td><td>4th order</td></tr><tr><td>HORNN</td><td>111</td><td>108</td><td>109</td></tr><tr><td>MaxHORNN</td><td>110</td><td>109</td><td>108</td></tr><tr><td>FOFEHORNN</td><td>103</td><td>101</td><td>100</td></tr><tr><td>GatedHORNN</td><td>102</td><td>100</td><td>100</td></tr></table>",
+        "bbox": [
+            315,
+            145,
+            681,
+            220
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 LANGUAGE MODELING ON PTB ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            253,
+            437,
+            268
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The standard Penn Treebank (PTB) corpus consists of about 1M words. The vocabulary size is limited to 10k. The preprocessing method and the way to split data into training/validation/test sets are the same as Mikolov et al. (2011). PTB is a relatively small text corpus. We first investigate various model configurations for the HORNNs based on PTB and then compare the best performance with other results reported on this task. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            352
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 EFFECT OF ORDERS IN HORNNS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            369,
+            460,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the first experiment, we first investigate how the used orders in HORNNs may affect the performance of language models (as measured by perplexity). We have examined all different higher order model structures proposed in this paper, including HORNNs and various pooling functions in HORNNs. The orders of these examined models varies among 2, 3 and 4. We have listed the performance of different models on PTB in Table 1. As we may see, we are able to achieve a significant improvement in perplexity when using higher order RNNs for language models on PTB, roughly 10-20 reduction in PPL over regular RNNs. We can see that performance may improve slightly when the order is increased from 2 to 3 but no significant gain is observed when the order is further increased to 4. As a result, we choose the 3rd-order HORNN structure for the following experiments. Among all different HORNN structures, we can see that FOFE-based pooling and gated structures yield the best performance on PTB. ",
+        "bbox": [
+            173,
+            395,
+            825,
+            547
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In language modeling, both input and output layers account for the major portion of model parameters. Therefore, we do not significantly increase model size when we go to higher order structures. For example, in Table 1, a regular RNN contains about 8.3 millions of weights while a 3rd-order HORNN (the same for max or FOFE pooling structures) has about 8.6 millions of weights. In comparison, an LSTM model has about 9.3 millions of weights and a 3rd-order gated HORNN has about 9.6 millions of weights. ",
+        "bbox": [
+            173,
+            555,
+            825,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As for the training speed, most HORNN models are only slightly slower than regular RNNs. For example, one epoch of training on PTB running in one NVIDIA’s TITAN X GPU takes about 80 seconds for an RNN, about 120 seconds for a 3rd-order HORNN (the same for max or FOFE pooling structures). Similarly, training of gated HORNNs is also slightly slower than LSTMs. For example, one epoch on PTB takes about 200 seconds for an LSTM, and about 225 seconds for a 3rd-order gates HORNN. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 MODEL COMPARISON ON PENN TREEBANK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            747,
+            532,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "At last, we report the best performance of various HORNNs on the PTB test set in Table 2. We compare our 3rd-order HORNNs with all other models reported on this task, including RNN Mikolov et al. (2011), stack RNN Pascanu et al. (2014), deep RNN Pascanu et al. (2014), FOFE-FNN Zhang et al. (2015) and LSTM Graves (2013). 2 From the results in Table 2, we can see that our proposed higher order RNN architectures significantly outperform all other baseline models reported on this task. Both FOFE-based pooling and gated HORNNs have achieved the state-of-the-art performance, i.e., 100 in perplexity on this task. To the best of our knowledge, this is the best reported performance on PTB under the same training condition. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            857
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ac3ad7dfeb010ce18eae4040301a30d9098380e2f8971d0eea5c220c2321536c.jpg",
+        "table_caption": [
+            "Table 2: Perplexities on the PTB test set for various examined models. ",
+            "Table 3: Perplexities on the text8 test set for various models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models KN 5-gram Mikolov et al. (2011)</td><td>Test 141</td></tr><tr><td>RNN Mikolov et al. (2011) CSLM5Aransa et al. (2015) LSTM Graves (2013) genCNN Wang et al. (2015) Gated word&amp;charMiyamoto &amp; Cho (2016) E2E Mem Net Sukhbaatar et al. (2015) Stack RNN Pascanu et al. (2014) Deep RNN Pascanu et al. (2014) FOFE-FNN Zhang et al. (2015)</td><td>123 118.08 117 116.4 113.52 111 110 107 108</td></tr><tr><td>HORNN (3rd order) Max HORNN (3rd order) FOFE HORNN (3rd order) Gated HORNN (3rd order)</td><td>108 109 101 100</td></tr></table>",
+        "bbox": [
+            173,
+            138,
+            537,
+            353
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6350ccb462311f18145fa5fc4765577637f3c36c2934d0e18ee025557be34e6a.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Test</td></tr><tr><td>RNN Mikolov et al. (2014) LSTM Mikolov et al. (2014) SCRNN Mikolov et al. (2014) E2E Mem Net Sukhbaatar et al. (2015)</td><td>184 156 161 147</td></tr><tr><td>HORNN (3rd order) Max HORNN (3rd order) FOFE HORNN (3rd order) Gated HORNN (3rd</td><td>172 163 154</td></tr></table>",
+        "bbox": [
+            534,
+            138,
+            852,
+            268
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            377,
+            823,
+            405
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 LANGUAGE MODELING ON ENGLISH TEXT8 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            422,
+            521,
+            438
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we will evaluate our proposed HORNNs on a much larger text corpus, namely the English text8 data set. The text8 data set contains a preprocessed version of the first 100 million characters downloaded from the Wikipedia website. We have used the same preprocessing method as Mikolov et al. (2014) to process the data set to generate the training and test sets. We have limited the vocabulary size to about $4 4 \\mathrm { k }$ by replacing all words occurring less than 10 times in the training set with an ${ \\bf \\mathrm { < U N K > } }$ token. The text8 set is about 20 times larger than PTB in corpus size. The model training on text8 takes longer to finish. We have not tuned hyperparameters in this data set. We simply follow the best setting used in PTB to train all HORNNs for the text8 data set. Meanwhile, we also follow the same learning schedule used in Mikolov et al. (2014): We first initialize the learning rate to 0.5 and run 5 epochs using this learning rate; After that, the learning rate is halved at the end of every epoch. ",
+        "bbox": [
+            173,
+            448,
+            825,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Because the training is time-consuming, we have only evaluated 3rd-order HORNNs on the text8 data set. The perplexities of various HORNNs are summarized in Table 3. We have compared our HORNNs with all other baseline models reported on this task, including RNN Mikolov et al. (2014), LSTM Mikolov et al. (2014), SCRNN Mikolov et al. (2014) and end-to-end memory networks Sukhbaatar et al. (2015). Results have shown that all HORNN models work pretty well in this data set except the normal HORNN significantly underperforms the other three models. Among them, the gated HORNN model has achieved the best performance, i.e., 144 in perplexity on this task, which is slightly better than the recent result obtained by end-to-end memory networks (using a rather complicated structure). To the best of our knowledge, this is the best performance reported on this task. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            747
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            767,
+            328,
+            784
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have proposed some new structures for recurrent neural networks, called as higher order RNNs (HORNNs). In these structures, we use more memory units to keep track of more preceding RNN states, which are all fed along various feedback paths to the hidden layer to generate the feedback signals. In this way, we may enhance the model to capture long term dependency in sequential data. Moreover, we have proposed to use several types of pooling functions to calibrate multiple feedback paths. Experiments have shown that the pooling technique plays a critical role in learning higher order RNNs effectively. In this work, we have examined HORNNs for the language modeling task using two popular data sets, namely the Penn Treebank (PTB) and text8 sets. Experimental results have shown that the proposed higher order RNNs yield the state-of-the-art performance on both data sets, significantly outperforming the regular RNNs as well as the popular LSTMs. As the future work, we are going to continue to explore HORNNs for other sequential modeling tasks, such as speech recognition, sequence-to-sequence modelling and so on. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nWalid Aransa, Holger Schwenk, and Lo¨ıc Barrault. Improving continuous space language models using auxiliary features. In Proceedings of the 12th International Workshop on Spoken Language Translation, pp. 151–158, 2015.   \nD. Bahdanau, K. Cho, and Y. Bengio. Neural machine translation by jointly learning to align and translate. In arXiv:1409.0473, 2014.   \nY. Bengio, P. Simard, and P. Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 5(2):157–166, 1994.   \nY. Bengio, R. Ducharme, P. Vincent, and C. Janvin. A neural probabilistic language model. Journal of Machine Learning Research, 3:1137–1155, 2003.   \nK. Cho, B. Van Merrienboer, C. Gulcehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio. ¨ Learning phrase representations using RNN encoder-decoder for statistical machine translation. In Proceedings of EMNLP, 2014.   \nJ. Chung, C. Gulcehre, K. Cho, and Y. Bengio. Gated feedback recurrent neural networks. In Proceedings of International Conference on Machine Learning (ICML), 2015.   \nA. Graves. Generating sequences with recurrent neural networks. In arXiv:1308.0850, 2013.   \nA. Graves, A. Mohamed, and G Hinton. Speech recognition with deep recurrent neural. In Proceedings of ICASSP, 2013.   \nK. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In arXiv:1512.03385, 2015.   \nSalah Hihi and Yoshua Bengio. Hierarchical recurrent neural networks for long-term dependencies. In Proceedings of Neural Information Processing Systems (NIPS), 1996.   \nS. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.   \nY. Kim, Y. Jernite, D. Sontag, and A. M. Rush. Character-aware neural language models. In arXiv:1508.06615, 2015.   \nJ. Koutnik, K. Greff, F. Gomez, and J. Schmidhuber. A clockwork rnn. In Proceedings of International Conference on Machine Learning (ICML), 2014.   \nC. Y. Lee, S. Xie, P. Gallagher, Z. Zhang, and Z. Tu. Deeply supervised nets. In arXiv:1409.5185, 2014.   \nM. Liwicki, A. Graves, and H. Bunke. Neural networks for handwriting recognition, Book Chapter, Computational intelligence paradigms in advanced pattern classification. Springer Berlin Heidelberg, 2012.   \nT. Mikolov. Statistical Language Models based on Neural Networks. PhD thesis, Brno University of Technology, 2012.   \nT. Mikolov, S. Kombrink, L. Burget, J.H. Cernock ˇ y, and S. Khudanpur. Extensions of recurrent \\` neural network language model. In Proceedings ICASSP, pp. 5528–5531, 2011.   \nT. Mikolov, A. Joulin, S. Chopra, M. Mathieu, and M. Ranzato. Learning longer memory in recurrent neural networks. In arXiv 1412.7753, 2014.   \nYasumasa Miyamoto and Kyunghyun Cho. Gated word-character recurrent language model. arXiv preprint arXiv:1606.01700, 2016.   \nM. Pachitariu and M. Sahani. Regularization and nonlinearities for neural language models: when are they needed? In arXiv:1301.5650, 2013.   \nR. Pascanu, C. Gulcehre, K. Cho, and Y. Bengio. How to construct deep recurrent neural networks. In Proceedings of ICLR, 2014.   \nH. T. Siegelmann and E. D. Sontag. On the computational power of neural nets. Journal of computer and system sciences, 50.(1):132–150, 1995.   \nR. K. Srivastava, K. Greff, and J. Schmidhuber. Highway networks. In Proceedings of Neural Information Processing Systems (NIPS), 2015.   \nS. Sukhbaatar, A. Szlam, J. Weston, and R. Fergus. End-to-end memory networks. In Proceedings of Neural Information Processing Systems (NIPS), 2015.   \nM. Sundermeyer, R. Schlter, and H. Ne. LSTM neural networks for language modeling. In Proceedings of Interspeech, 2012.   \nI. Sutskever, J. Martens, and G Hinton. Generating text with recurrent neural networks. In Proceedings of International Conference on Machine Learning (ICML), 2011.   \nI. Sutskever, O. Vinyals, and Q. Le. Sequence to sequence learning with neural networks. In Proceedings of Neural Information Processing Systems (NIPS), 2014.   \nMingxuan Wang, Zhengdong Lu, Hang Li, Wenbin Jiang, and Qun Liu. gen cnn: A convolutional architecture for word sequence prediction. arXiv preprint arXiv:1503.05034, 2015.   \nP. J. Werbos. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10):1550–1560, 1990.   \nStefan Wermter. A hybrid and connectionist architecture for a scanning understanding. In Proceedings of the 10th European conference on Artificial intelligence, 1992.   \nW. Zaremba, I. Sutskever, and O.l Vinyals. Recurrent neural network regularization. In arXiv:1409.2329, 2014.   \nS. Zhang, H. Jiang, M. Xu, J. Hou, and L. Dai. The fixed-size ordinally-forgetting encoding method for neural network language models. In Proceedings of ACL, pp. 495–500, 2015. ",
+        "bbox": [
+            171,
+            116,
+            826,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            166,
+            97,
+            828,
+            590
+        ],
+        "page_idx": 9
+    }
+]

parse/train/HJTzHtqee/HJTzHtqee.md

@@ -0,0 +1,281 @@
+# A COMPARE-AGGREGATE MODEL FOR MATCHING TEXT SEQUENCES
+
+Shuohang Wang School of Information Systems Singapore Management University shwang.2014@phdis.smu.edu.sg
+
+Jing Jiang School of Information Systems Singapore Management University jingjiang@smu.edu.sg
+
+# ABSTRACT
+
+Many NLP tasks including machine comprehension, answer selection and text entailment require the comparison between sequences. Matching the important units between sequences is a key to solve these problems. In this paper, we present a general “compare-aggregate” framework that performs word-level matching followed by aggregation using Convolutional Neural Networks. We particularly focus on the different comparison functions we can use to match two vectors. We use four different datasets to evaluate the model. We find that some simple comparison functions based on element-wise operations can work better than standard neural network and neural tensor network.
+
+# 1 INTRODUCTION
+
+Many natural language processing problems involve matching two or more sequences to make a decision. For example, in textual entailment, one needs to determine whether a hypothesis sentence can be inferred from a premise sentence (Bowman et al., 2015). In machine comprehension, given a passage, a question needs to be matched against it in order to find the correct answer (Richardson et al., 2013; Tapaswi et al., 2016). Table 1 gives two example sequence matching problems. In the first example, a passage, a question and four candidate answers are given. We can see that to get the correct answer, we need to match the question against the passage and identify the last sentence to be the answer-bearing sentence. In the second example, given a question and a set of candidate answers, we need to find the answer that best matches the question. Because of the fundamental importance of comparing two sequences of text to judge their semantic similarity or relatedness, sequence matching has been well studied in natural language processing.
+
+With recent advances of neural network models in natural language processing, a standard practice for sequence modeling now is to encode a sequence of text as an embedding vector using models such as RNN and CNN. To match two sequences, a straightforward approach is to encode each sequence as a vector and then to combine the two vectors to make a decision (Bowman et al., 2015; Feng et al., 2015). However, it has been found that using a single vector to encode an entire sequence is not sufficient to capture all the important information from the sequence, and therefore advanced techniques such as attention mechanisms and memory networks have been applied to sequence matching problems (Hermann et al., 2015; Hill et al., 2016; Rocktaschel et al., 2015). ¨
+
+A common trait of a number of these recent studies on sequence matching problems is the use of a “compare-aggregate” framework (Wang & Jiang, 2016b; He & Lin, 2016; Parikh et al., 2016). In such a framework, comparison of two sequences is not done by comparing two vectors each representing an entire sequence. Instead, these models first compare vector representations of smaller units such as words from these sequences and then aggregate these comparison results to make the final decision. For example, the match-LSTM model proposed by Wang & Jiang (2016b) for textual entailment first compares each word in the hypothesis with an attention-weighted version of the premise. The comparison results are then aggregated through an LSTM. He & Lin (2016) proposed a pairwise word interaction model that first takes each pair of words from two sequences and applies a comparison unit on the two words. It then combines the results of these word interactions using a similarity focus layer followed by a multi-layer CNN. Parikh et al. (2016) proposed a decomposable attention model for textual entailment, in which words from each sequence are compared with an attention-weighted version of the other sequence to produce a series of comparison vectors. The comparison vectors are then aggregated and fed into a feed forward network for final classification.
+
+Table 1: The example on the left is a machine comprehension problem from MovieQA, where the correct answer here is The Shire. The example on the right is an answer selection problem from InsuranceQA.   
+
+<table><tr><td>Plot:... Aragorn is crowned King of Gon- dor and taking Arwen as his queen before all present at his coronation bowing before Frodo and the other Hobbits．The Hobbits return to the Shire where Sam marries Rosie Cotton ....</td></tr><tr><td>Qustion: Where does Sam marry Rosie?</td></tr><tr><td>Candidate answers: O) Grey Havens.1) Gon- dor.2) The Shire.3) Erebor.4) Mordor.</td></tr></table>
+
+<table><tr><td>Question: can i have auto insurance without a car</td></tr><tr><td>Ground-truth answer: yes,it be possible have auto insurance without own a vehicle.you will purchase what be call a name ..</td></tr><tr><td>Another candidate answer: insurance not be a tax or merely a legal obligation because auto insurance follow a car...</td></tr></table>
+
+Although these studies have shown the effectiveness of such a “compare-aggregate” framework for sequence matching, there are at least two limitations with these previous studies: (1) Each of the models proposed in these studies is tested on one or two tasks only, but we hypothesize that this general framework is effective on many sequence matching problems. There has not been any study that empirically verifies this. (2) More importantly, these studies did not pay much attention to the comparison function that is used to compare two small textual units. Usually a standard feedforward network is used (Hu et al., 2014; Wang & Jiang, 2016b) to combine two vectors representing two units that need to be compared, e.g., two words. However, based on the nature of these sequence matching problems, we essentially need to measure how semantically similar the two sequences are. Presumably, this property of these sequence matching problems should guide us in choosing more appropriate comparison functions. Indeed He & Lin (2016) used cosine similarity, Euclidean distance and dot product to define the comparison function, which seem to be better justifiable. But they did not systematically evaluate these similarity or distance functions or compare them with a standard feedforward network.
+
+In this paper, we argue that the general “compare-aggregate” framework is effective for a wide range of sequence matching problems. We present a model that follows this general framework and test it on four different datasets, namely, MovieQA, InsuranceQA, WikiQA and SNLI. The first three datasets are for Question Answering, but the setups of the tasks are quite different. The last dataset is for textual entailment. More importantly, we systematically present and test six different comparison functions. We find that overall a comparison function based on element-wise subtraction and multiplication works the best on the four datasets.
+
+The contributions of this work are twofold: (1) Using four different datasets, we show that our model following the “compare-aggregate” framework is very effective when compared with the state-ofthe-art performance on these datasets. (2) We conduct systematic evaluation of different comparison functions and show that a comparison function based on element-wise operations, which is not widely used for word-level matching, works the best across the different datasets. We believe that these findings will be useful for future research on sequence matching problems. We have also made our code available online.1
+
+# 2 METHOD
+
+In this section, we propose a general model following the “compare-aggregate” framework for matching two sequences. This general model can be applied to different tasks. We focus our discussion on six different comparison functions that can be plugged into this general “compare-aggregate” model. In particular, we hypothesize that two comparison functions based on element-wise operations, SUB and MULT, are good middle ground between highly flexible functions using standard neural network models and highly restrictive functions based on cosine similarity and/or Euclidean distance. As we will show in the experiment section, these comparison functions based on elementwise operations can indeed perform very well on a number of sequence matching problems.
+
+![](images/bd9a255fdaa82548a427cb5a4a44ace17f1c92aeebb388009fa7221b6faef7c6.jpg)  
+Figure 1: The left hand side is an overview of the model. The right hand side shows the details about the different comparison functions. The rectangles in dark represent parameters to be learned. $\times$ represents matrix multiplication.
+
+# 2.1 PROBLEM DEFINITION AND MODEL OVERVIEW
+
+The general setup of the sequence matching problem we consider is the following. We assume there are two sequences to be matched. We use two matrices $\mathbf { Q } \in \mathbb { R } ^ { d \times Q }$ and $\mathbf { A } \in \mathbf { \mathbb { R } } ^ { d \times A }$ to represent the word embeddings of the two sequences, where $Q$ and $A$ are the lengths of the two sequences, respectively, and $d$ is the dimensionality of the word embeddings. In other words, each column vector of $\mathbf { Q }$ or $\mathbf { A }$ is an embedding vector representing a single word. Given a pair of $\mathbf { Q }$ and $\mathbf { A }$ , the goal is to predict a label $y$ . For example, in textual entailment, $\mathbf { Q }$ may represent a premise and $\mathbf { A }$ a hypothesis, and $y$ indicates whether $\mathbf { Q }$ entails $\mathbf { A }$ or contradicts A. In question answering, $\mathbf { Q }$ may be a question and A a candidate answer, and $y$ indicates whether A is the correct answer to $\mathbf { Q }$ .
+
+We treat the problem as a supervised learning task. We assume that a set of training examples in the form of $( \mathbf { Q } , \mathbf { A } , y )$ is given and we aim to learn a model that maps any pair of $( \mathbf { Q } , \mathbf { A } )$ to a $y$ .
+
+An overview of our model is shown in Figure 1. The model can be divided into the following four layers:
+
+1. Preprocessing: We use a preprocessing layer (not shown in the figure) to process $\mathbf { Q }$ and A to obtain two new matrices $\mathbf { \bar { Q } } \in \mathbb { R } ^ { l \times \mathbf { \bar { Q } } }$ and $\overline { { \mathbf { A } } } \in \mathbb { R } ^ { l \times A }$ . The purpose here is to use some gate values to control the importance of different words in making the predictions on the sequence pair. For example, $\overline { { \mathbf { q } } } _ { i } \in \mathbb { R } ^ { l }$ , which is the $i ^ { \mathrm { { t h } } }$ column vector of $\overline { { \mathbf { Q } } }$ , encodes the $i ^ { \mathrm { { t h } } }$ word in $\mathbf { Q }$ .
+
+2. Attention: We apply a standard attention mechanism on $\overline { { \mathbf { Q } } }$ and $\overline { { \mathbf A } }$ to obtain attention weights over the column vectors in $\overline { { \mathbf { Q } } }$ for each column vector in $\overline { { \bf A } }$ . With these attention weights, for each column vector $\overline { { \mathbf { a } } } _ { j }$ in $\overline { { \mathbf A } }$ , we obtain a corresponding vector $\mathbf { h } _ { j }$ , which is an attention-weighted sum of the column vectors of $\overline { { \mathbf { Q } } }$ .
+
+3. Comparison: We use a comparison function $f$ to combine each pair of $\overline { { \mathbf { a } } } _ { j }$ and $\mathbf { h } _ { j }$ into a vector $\mathbf { t } _ { j }$ .
+
+4. Aggregation: We use a CNN layer to aggregate the sequence of vectors $\mathbf { t } _ { j }$ for the final classification.
+
+Although this model follows more or less the same framework as the model proposed by Parikh et al. (2016), our work has some notable differences. First, we will pay much attention to the comparison function $f$ and compare a number of options, including some uncommon ones based on elementwise operations. Second, we apply our model to four different datasets representing four different tasks to evaluate its general effectiveness for sequence matching problems. There are also some other differences from the work by Parikh et al. (2016). For example, we use a CNN layer instead of summation and concatenation for aggregation. Our attention mechanism is one-directional instead of two-directional.
+
+In the rest of this section we will present the model in detail. We will focus mostly on the comparison functions we consider.
+
+# 2.2 PREPROCESSING AND ATTENTION
+
+Inspired by the use of gates in LSTM and GRU, we preprocess $\mathbf { Q }$ and A with the following formulas:
+
+$$
+\begin{array} { r l r } { \overline { { \mathbf { Q } } } } & { = } & { \sigma ( \mathbf { W } ^ { \mathrm { i } } \mathbf { Q } + \mathbf { b } ^ { \mathrm { i } } \otimes \mathbf { e } _ { Q } ) \odot \mathrm { t a n h } ( \mathbf { W } ^ { \mathrm { u } } \mathbf { Q } + \mathbf { b } ^ { \mathrm { u } } \otimes \mathbf { e } _ { Q } ) , } \\ { \overline { { \mathbf { A } } } } & { = } & { \sigma ( \mathbf { W } ^ { \mathrm { i } } \mathbf { A } + \mathbf { b } ^ { \mathrm { i } } \otimes \mathbf { e } _ { A } ) \odot \mathrm { t a n h } ( \mathbf { W } ^ { \mathrm { u } } \mathbf { A } + \mathbf { b } ^ { \mathrm { u } } \otimes \mathbf { e } _ { A } ) , } \end{array}
+$$
+
+where $\odot$ is element-wise multiplication, and $\mathbf { W } ^ { \mathrm { i } } , \mathbf { W } ^ { \mathrm { u } } \in \mathbb { R } ^ { l \times d }$ and $\mathbf { b } ^ { \mathrm { i } } , \mathbf { b } ^ { \mathrm { u } } \in \mathbb { R } ^ { l }$ are parameters to be learned. The outer product $\left( \cdot \otimes \mathbf { e } _ { X } \right)$ produces a matrix or row vector by repeating the vector or scalar on the left for $X$ times. Here $\sigma ^ { \prime } (  { \mathbf { W } } ^ { \mathrm { i } } \mathbf { Q } +  { \mathbf { b } } ^ { \mathrm { i } } \otimes \mathbf { e } _ { Q } )$ and $\sigma ( \mathbf { W } ^ { \mathrm { i } } \mathbf { A } + \mathbf { b } ^ { \mathrm { i } } \otimes \mathbf { e } _ { A } ) $ act as gate values to control the degree to which the original values of $\mathbf { Q }$ and $\mathbf { A }$ are preserved in $\overline { { \mathbf { Q } } }$ and $\overline { { \mathbf A } }$ . For example, for stop words, their gate values would likely be low for tasks where stop words make little difference to the final predictions.
+
+In this preprocessing step, the word order does not matter. Although a better way would be to use RNN such as LSTM and GRU to chain up the words such that we can capture some contextual information, this could be computationally expensive for long sequences. In our experiments, we only incorporated LSTM into the formulas above for the SNLI task.
+
+The general attention (Luong et al., 2015) layer is built on top of the resulting $\overline { { \mathbf { Q } } }$ and $\overline { { \mathbf A } }$ as follows:
+
+$$
+\begin{array} { l l l } { { { \bf { G } } } } & { { = } } & { { \mathrm { s o f t m a x } \left( { ( { \bf { W } } ^ { \mathrm { g } } { \overline { { { \bf { Q } } } } } + { \bf { b } } ^ { \mathrm { g } } \otimes { \bf { e } } _ { Q } ) ^ { \mathrm { { T } } } { \overline { { { \bf { A } } } } } } \right) , } } \\ { { { \bf { H } } } } & { { = } } & { { { \overline { { { \bf { Q } } } } } { \bf { G } } , } } \end{array}
+$$
+
+where $\mathbf { W ^ { g } } \in \mathbb { R } ^ { l \times l }$ and $\mathbf { b } ^ { \mathrm { g } } \in \mathbb { R } ^ { l }$ are parameters to be learned, $\mathbf { G } \in \mathbb { R } ^ { Q \times A }$ is the attention weight matrix, and $\mathbf { H } \in \mathbb { R } ^ { l \times A }$ are the attention-weighted vectors. Specifically, $\mathbf { h } _ { j }$ , which is the $j ^ { \mathrm { t h } }$ column vector of $\mathbf { H }$ , is a weighted sum of the column vectors of $\overline { { \mathbf { Q } } }$ and represents the part of $\mathbf { Q }$ that best matches the $j ^ { \mathrm { t h } }$ word in A. Next we will combine $\mathbf { h } _ { j }$ and $\overline { { \mathbf { a } } } _ { j }$ using a comparison function.
+
+# 2.3 COMPARISON
+
+The goal of the comparison layer is to match each $\overline { { \mathbf { a } } } _ { j }$ , which represents the $j ^ { \mathrm { t h } }$ word and its context in $\mathbf { A }$ , with $\mathbf { h } _ { j }$ , which represents a weighted version of $\mathbf { Q }$ that best matches $\overline { { \mathbf { a } } } _ { j }$ . Let $f$ denote a comparison function that transforms $\overline { { \mathbf { a } } } _ { j }$ and $\mathbf { h } _ { j }$ into a vector $\mathbf { t } _ { j }$ to represent the comparison result.
+
+A natural choice of $f$ is a standard neural network layer that consists of a linear transformation followed by a non-linear activation function. For example, we can consider the following choice:
+
+$$
+\mathrm { N E U R A L N E T } \left( \mathrm { N N } \right) ; \qquad \mathbf { t } _ { j } = f \bigl ( \mathbf { \overline { { a } } } _ { j } , \mathbf { h } _ { j } \bigr ) = \mathrm { R e L U } \bigl ( \mathbf { W } \left[ \mathbf { \overline { { a } } } _ { j } \right] + \mathbf { b } \bigr ) ,
+$$
+
+where matrix $\mathbf { W } \in \mathbb { R } ^ { l \times { 2 l } }$ and vector $\mathbf { b } \in \mathbb { R } ^ { l }$ are parameters to be learned.
+
+Alternatively, another natural choice is a neural tensor network (Socher et al., 2013) as follows:
+
+$\mathrm { N E U R A L T E N S O R N E T } \left( \mathrm { N T N } \right) : \qquad \mathbf { t } _ { j } = f ( \overline { { \mathbf { a } } } _ { j } , \mathbf { h } _ { j } ) = \mathrm { R e L U } ( \overline { { \mathbf { a } } } _ { j } ^ { \mathrm { { T } } } \mathbf { T } ^ { [ 1 \ldots l ] } \mathbf { h } _ { j } + \mathbf { b } ) ,$ where tensor $\mathbf { T } ^ { [ 1 \ldots l ] } \in \mathbb { R } ^ { l \times l \times l }$ and vector $\mathbf { b } \in \mathbb { R } ^ { l }$ are parameters to be learned.
+
+However, we note that for many sequence matching problems, we intend to measure the semantic similarity or relatedness of the two sequences. So at the word level, we also intend to check how similar or related $\overline { { \mathbf { a } } } _ { j }$ is to $\mathbf { h } _ { j }$ . For this reason, a more natural choice used in some previous work is Euclidean distance or cosine similarity between $\overline { { \mathbf { a } } } _ { j }$ and $\mathbf { h } _ { j }$ . We therefore consider the following definition of $f$ :
+
+$$
+\begin{array} { r } { \mathrm { E U C L I D E A N + C O S I N E ~ ( E U C C O S ) : } \qquad \mathbf { t } _ { j } = f ( \overline { { \mathbf { a } } } _ { j } , \mathbf { h } _ { j } ) = \left[ \Vert \overline { { \mathbf { a } } } _ { j } - \mathbf { h } _ { j } \Vert _ { 2 } \right] . } \end{array}
+$$
+
+Note that with EUCCOS, the resulting vector $\mathbf { t } _ { j }$ is only a 2-dimensional vector. Although EUCCOS is a well-justified comparison function, we suspect that it may lose some useful information from the original vectors $\overline { { \mathbf { a } } } _ { j }$ and $\mathbf { h } _ { j }$ . On the other hand, NN and NTN are too general and thus do not capture the intuition that we care mostly about the similarity between $\mathbf { \overline { { a } } } _ { j }$ and $\mathbf { h } _ { j }$ .
+
+To use something that is a good compromise between the two extreme cases, we consider the following two new comparison functions, which operate on the two vectors in an element-wise manner. These functions have been used previously by Mou et al. (2016).
+
+$$
+\begin{array} { r l } { \mathrm { S U B T R A C T I O N ~ ( S U B ) } \colon \quad } & { \mathbf { t } _ { j } = f ( \overline { { \mathbf { a } } } _ { j } , \mathbf { h } _ { j } ) = ( \overline { { \mathbf { a } } } _ { j } - \mathbf { h } _ { j } ) \odot ( \overline { { \mathbf { a } } } _ { j } - \mathbf { h } _ { j } ) , } \\ { \mathrm { M U L T I P L I C A T I O N ~ ( M U L T ) } \colon \quad } & { \mathbf { t } _ { j } = f ( \overline { { \mathbf { a } } } _ { j } , \mathbf { h } _ { j } ) = \overline { { \mathbf { a } } } _ { j } \odot \mathbf { h } _ { j } . } \end{array}
+$$
+
+Note that the operator $\odot$ is element-wise multiplication. For both comparison functions, the resulting vector $\mathbf { t } _ { j }$ has the same dimensionality as $\overline { { \mathbf { a } } } _ { j }$ and $\mathbf { h } _ { j }$ .
+
+We can see that SUB is closely related to Euclidean distance in that Euclidean distance is the sum of all the entries of the vector $\mathbf { t } _ { j }$ produced by SUB. But by not summing up these entries, SUB preserves some information about the different dimensions of the original two vectors. Similarly, MULT is closely related to cosine similarity but preserves some information about the original two vectors.
+
+Finally, we consider combining SUB and MULT followed by an NN layer as follows:
+
+$$
+\begin{array} { r l } { \mathrm { S U B M U L T + N N : } \quad } & { \mathbf { t } _ { j } = f ( \overline { { \mathbf { a } } } _ { j } , \mathbf { h } _ { j } ) = \mathrm { R e L U } \big ( \mathbf { W } \left[ \mathbf { ( \overline { { a } } } _ { j } - \mathbf { h } _ { j } ) \odot ( \overline { { \mathbf { a } } } _ { j } - \mathbf { h } _ { j } ) \right] + \mathbf { b } \big ) . } \end{array}
+$$
+
+In summary, we consider six different comparison functions: NN, NTN, EUCCOS, SUB, MULT and SUBMULT $\mathbf { \Gamma } + \mathbf { N N }$ . Among these functions, the last three (SUB, MULT and SUBMULT $+ \mathrm { N N }$ ) have not been widely used in previous work for word-level matching.
+
+# 2.4 AGGREGATION
+
+After we apply the comparison function to each pair of $\overline { { \mathbf { a } } } _ { j }$ and $\mathbf { h } _ { j }$ to obtain a series of vectors $\mathbf { t } _ { j }$ , finally we aggregate these vectors using a one-layer CNN (Kim, 2014):
+
+$$
+\begin{array} { r l r } { { \bf r } } & { { } = } & { { \bf C } { \bf N } { \bf N } ( [ { \bf t } _ { 1 } , \ldots , { \bf t } _ { A } ] ) . } \end{array}
+$$
+
+$\mathbf { r } \in \mathbb { R } ^ { n l }$ is then used for the final classification, where $n$ is the number of windows in CNN.
+
+# 3 EXPERIMENTS
+
+<table><tr><td></td><td colspan="3">MovieQA</td><td colspan="3">InsuranceQA</td><td colspan="3">WikiQA</td><td colspan="3">SNLI</td></tr><tr><td></td><td>train</td><td>dev</td><td>test</td><td>train</td><td>dev</td><td>test</td><td>train</td><td>dev</td><td>test</td><td>train</td><td>dev</td><td>test</td></tr><tr><td>#Q</td><td>9848</td><td>1958</td><td>3138</td><td>13K</td><td>1K</td><td>1.8K*2</td><td>873</td><td>126</td><td>243</td><td>549K</td><td>9842</td><td>9824</td></tr><tr><td>#C</td><td>5</td><td>5</td><td>5</td><td>50</td><td>500</td><td>500</td><td>10</td><td>9</td><td>10</td><td>-</td><td>-</td><td>-</td></tr><tr><td>#w in P</td><td>873</td><td>866</td><td>914</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>1</td><td>-</td><td>-</td><td>1</td></tr><tr><td>#w in Q</td><td>10.6</td><td>10.6</td><td>10.8</td><td>7.2</td><td>7.2</td><td>7.2</td><td>6.5</td><td>6.5</td><td>6.4</td><td>14</td><td>15.2</td><td>15.2</td></tr><tr><td>#w in A</td><td>5.9</td><td>5.6</td><td>5.5</td><td>92.1</td><td>92.1</td><td>92.1</td><td>25.5</td><td>24.7</td><td>25.1</td><td>8.3</td><td>8.4</td><td>8.3</td></tr></table>
+
+Table 2: The statistics of different datasets. Q:question/hypothesis, C:candidate answers for each question, A:answer/hypothesis, P:plot, w:word (average).
+
+Table 3: Experiment Results   
+
+<table><tr><td rowspan="2">Models</td><td colspan="2">MovieQA</td><td colspan="3">InsuranceQA</td><td colspan="2">WikiQA</td><td colspan="2">SNLI</td></tr><tr><td>dev</td><td>test</td><td>dev</td><td>test1</td><td>test2</td><td>MAP</td><td>MRR</td><td>train</td><td>test</td></tr><tr><td>Cosine Word2Vec</td><td>46.4</td><td>45.63</td><td>-</td><td>=</td><td></td><td>=</td><td>=</td><td>=</td><td>=</td></tr><tr><td>Cosine TFIDF</td><td>47.6</td><td>47.36</td><td>=</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SSCB TFIDF</td><td>48.5</td><td>1</td><td>=</td><td>=</td><td>=</td><td></td><td></td><td></td><td></td></tr><tr><td>IR model</td><td>1</td><td>=</td><td>52.7</td><td>55.1</td><td>50.8</td><td></td><td></td><td></td><td></td></tr><tr><td>CNN with GESD</td><td></td><td>=</td><td>65.4</td><td>65.3</td><td>61.0</td><td></td><td></td><td></td><td></td></tr><tr><td>Attentive LSTM</td><td></td><td></td><td>68.9</td><td>69.0</td><td>64.8</td><td></td><td></td><td></td><td></td></tr><tr><td>IARNN-Occam</td><td></td><td>=</td><td>69.1</td><td>68.9</td><td>65.1</td><td>0.7341</td><td>0.7418</td><td></td><td></td></tr><tr><td>IARNN-Gate</td><td></td><td></td><td>70.0</td><td>70.1</td><td>62.8</td><td>0.7258</td><td>0.7394</td><td></td><td></td></tr><tr><td>CNN-Cnt</td><td></td><td></td><td>-</td><td>-</td><td>-</td><td>0.6520</td><td>0.6652</td><td></td><td></td></tr><tr><td>ABCNN</td><td></td><td></td><td>=</td><td></td><td>=</td><td>0.6921</td><td>0.7108</td><td></td><td></td></tr><tr><td>CubeCNN</td><td></td><td></td><td></td><td></td><td></td><td>0.7090</td><td>0.7234</td><td></td><td></td></tr><tr><td>W-by-WAttention</td><td></td><td></td><td></td><td></td><td></td><td>=</td><td>=</td><td>85.3</td><td>83.5</td></tr><tr><td>match-LSTM</td><td></td><td></td><td></td><td></td><td></td><td></td><td>=</td><td>92.0</td><td>86.1</td></tr><tr><td>LSTMN</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>88.5</td><td>86.3</td></tr><tr><td>Decomp Attention</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>90.5</td><td>86.8</td></tr><tr><td>EBIM+TreeLSTM</td><td>=</td><td></td><td>=</td><td>=</td><td>=</td><td>=</td><td>=</td><td>93.0</td><td>88.3</td></tr><tr><td>NN</td><td>31.6</td><td>=</td><td>76.8</td><td>74.9</td><td>72.4</td><td>0.7102</td><td>0.7224</td><td>89.3</td><td>86.3</td></tr><tr><td>NTN</td><td>31.6</td><td>=</td><td>75.6</td><td>75.0</td><td>72.5</td><td>0.7349</td><td>0.7456</td><td>91.6</td><td>86.3</td></tr><tr><td>EucCos</td><td>71.9</td><td>=</td><td>70.6</td><td>70.2</td><td>67.9</td><td>0.6740</td><td>0.6882</td><td>87.1</td><td>84.0</td></tr><tr><td>SUB</td><td>64.9</td><td></td><td>70.0</td><td>71.3</td><td>68.2</td><td>0.7019</td><td>0.7151</td><td>89.8</td><td>86.8</td></tr><tr><td>MULT</td><td>66.4</td><td>=</td><td>76.0</td><td>75.2</td><td>73.4</td><td>0.7433</td><td>0.7545</td><td>89.7</td><td>85.8</td></tr><tr><td>SUBMULT+NN</td><td>72.1</td><td>72.9</td><td>77.0</td><td>75.6</td><td>72.3</td><td>0.7332</td><td>0.7477</td><td>89.4</td><td>86.8</td></tr></table>
+
+<table><tr><td rowspan="2">Models</td><td colspan="2">MovieQA</td><td colspan="3">InsuranceQA</td><td colspan="2">WikiQA</td><td colspan="2">SNLI</td></tr><tr><td>dev</td><td>test</td><td>dev</td><td>test1</td><td>test2</td><td>MAP</td><td>MRR</td><td>train</td><td>test</td></tr><tr><td>SUBMULT+NN (no preprocess)</td><td>72.0</td><td>：</td><td>72.8</td><td>73.8</td><td>70.7</td><td>0.6996</td><td>0.7156</td><td>89.6</td><td>82.8</td></tr><tr><td>SUBMULT+NN (no attention)</td><td>60.4</td><td>：</td><td>69.4</td><td>70.4</td><td>67.8</td><td>0.7164</td><td>0.7238</td><td>89.0</td><td>84.4</td></tr></table>
+
+Table 4: Ablation Experiment Results. “no preprocess”: remove the preprocessing layer by directly using word embeddings $\mathbf { Q }$ and A to replace $\overline { { \mathbf { Q } } }$ and $\overline { { \mathbf A } }$ in Eqn. 1; “no attention”: remove the attention layer by using mean pooling of $\overline { { \mathbf { Q } } }$ to replace all the vectors of $\mathbf { H }$ in Eqn. 2.
+
+In this section, we evaluate our model on four different datasets representing different tasks. The first three datasets are question answering tasks while the last one is on textual entailment. The statistics of the four datasets are shown in Table 2. We will fist introduce the task settings and the way we customize the “compare-aggregate” structure to each task. Then we will show the baselines for the different datasets. Finally, we discuss the experiment results shown in Table 3 and the ablation study shown in Table 4.
+
+# 3.1 TASK-SPECIFIC MODEL STRUCTURES
+
+In all these tasks, we use matrix $\mathbf { Q } \in \mathbb { R } ^ { d \times Q }$ to represent the question or premise and matrix $\mathbf { A } _ { k } \in$ $\mathbb { R } ^ { d \times A _ { k } }$ $( k \in [ 1 , K ] )$ to represent the $k ^ { \mathrm { { t h } } }$ answer or the hypothesis. For the machine comprehension task MovieQA (Tapaswi et al., 2016), there is also a matrix $\mathbf { P } \in \mathbb { R } ^ { d \times P }$ that represents the plot of a movie. Here $Q$ is the length of the question or premise, $A _ { k }$ the length of the $\bar { k ^ { \mathrm { { t h } } } }$ answer, and $P$ the length of the plot.
+
+For the SNLI (Bowman et al., 2015) dataset, the task is text entailment, which identifies the relationship (entailment, contradiction or neutral) between a premise sentence and a hypothesis sentence. Here $K = 1$ , and there are exactly two sequences to match. The actual model structure is what we have described before.
+
+For the InsuranceQA (Feng et al., 2015) dataset, the task is an answer selection task which needs to select the correct answer for a question from a candidate pool. For the WikiQA (Yang et al., 2015) datasets, we need to rank the candidate answers according to a question. For both tasks, there are $K$ candidate answers for each question. Let us use $\mathbf { r } _ { k }$ to represent the resulting vector produced by Eqn. 9 for the $k ^ { \mathrm { { t h } } }$ answer. In order to select one of the $K$ answers, we first define $\mathbf { R } = [ \mathbf { r } _ { 1 } , \mathbf { r } _ { 2 } , \ldots , \mathbf { r } _ { K } ]$ . We then compute the probability of the $k ^ { \mathrm { { t h } } }$ answer to be the correct one as follows:
+
+$$
+\begin{array} { r l r } { p ( k | { \bf R } ) } & { = } & { \mathrm { s o f t m a x } ( { \bf w } ^ { \mathrm { T } } \operatorname { t a n h } ( { \bf W } ^ { \mathrm { s } } { \bf R } + { \bf b } ^ { \mathrm { s } } \otimes { \bf e } _ { K } ) + b \otimes { \bf e } _ { K } ) , } \end{array}
+$$
+
+where $\mathbf { W ^ { s } } \in \mathbb { R } ^ { l \times n l }$ , $\mathbf { w } \in \mathbb { R } ^ { l }$ , $\mathbf { b } ^ { \mathrm { s } } \in \mathbb { R } ^ { l }$ , $b \in \mathbb { R }$ are parameters to be learned.
+
+For the machine comprehension task MovieQA, each question is related to Plot Synopses written by fans after watching the movie and each question has five candidate answers. So for each candidate answer there are three sequences to be matched: the plot $\mathbf { P }$ , the question $\mathbf { Q }$ and the answer $\mathbf { A } _ { k }$ . For each $k$ , we first match $\mathbf { Q }$ and $\mathbf { P }$ and refer to the matching result at position $j$ as $\mathbf { t } _ { j } ^ { \mathrm { q } }$ , as generated by one of the comparison functions $f$ . Similarly, we also match $\mathbf { A } _ { k }$ with $\mathbf { P }$ and refer to the matching result at position $j$ as $\mathbf { t } _ { k , j } ^ { \mathrm { a } }$ . We then define
+
+$$
+\begin{array} { r l r } { \mathbf { \mathrm { t } } _ { k , j } } & { { } = } & { \left[ \begin{array} { c } { \mathbf { \mathrm { t } } _ { j } ^ { \mathrm { q } } } \\ { \mathbf { \mathrm { t } } _ { k , j } ^ { \mathrm { a } } } \end{array} \right] , } \end{array}
+$$
+
+and
+
+$$
+\begin{array} { l l l } { \mathbf { r } _ { k } } & { = } & { \mathbf { C N N } ( [ \mathbf { t } _ { k , 1 } , \dots , \mathbf { t } _ { k , P } ] ) . } \end{array}
+$$
+
+To select an answer from the $K$ candidate answers, again we use Eqn. 10 to compute the probabilities.
+
+The implementation details of the modes are as follows. The word embeddings are initialized from GloVe (Pennington et al., 2014). During training, they are not updated. The word embeddings not found in GloVe are initialized with zero.
+
+The dimensionality $l$ of the hidden layers is set to be 150. We use ADAMAX (Kingma & Ba, 2015) with the coefficients $\beta _ { 1 } = 0 . 9$ and $\beta _ { 2 } = 0 . 9 9 9$ to optimize the model. We do not use L2- regularization. The main parameter we tuned is the dropout on the embedding layer. For WikiQA, which is a relatively small dataset, we also tune the learning rate and the batch size. For the others, we set the batch size to be 30 and the learning rate 0.002.
+
+# 3.2 BASELINES
+
+Here, we will introduce the baselines for each dataset. We did not re-implement these models but simply took the reported performance for the purpose of comparison.
+
+SNLI: • W-by-W Attention: The model by Rocktaschel et al. (2015), who first introduced attention ¨ mechanism into text entailment. • match-LSTM: The model by Wang & Jiang (2016b), which concatenates the matched words as the inputs of an LSTM. • LSTMN: Long short-term memorynetworks proposed by Cheng et al. (2016). • Decomp Attention: Another “compare-aggregate” model proposed by Parikh et al. (2016). • EBIM $\mathbf { + }$ TreeLSTM: The state-of-the-art model proposed by Chen et al. (2016) on the SNLI dataset.
+
+InsuranceQA: • IR model: This model by Bendersky et al. (2010) learns the concept information to help rank the candidates. • CNN with GESD: This model by Feng et al. (2015) uses Euclidean distance and dot product between sequence representations built through convolutional neural networks to select the answer. • Attentive LSTM: Tan et al. (2016) used soft-attention mechanism to select the most important information from the candidates according to the representation of the questions. • IARNN-Occam: This model by Wang et al. (2016) adds regularization on the attention weights. • IARNN-Gate: This model by Wang et al. (2016) uses the representation of the question to build the GRU gates for each candidate answer.
+
+WikiQA: • IARNN-Occam and IARNN-Gate as introduced before. • CNN-Cnt: This model by Yang et al. (2015) combines sentence representations built by a convolutional neural network with logistic regression. • ABCNN: This model is Attention-Based Convolutional Neural Network proposed by Yin et al. (2015). • CubeCNN proposed by He & Lin (2016) builds a CNN on all pairs of word similarity.
+
+MovieQA: All the baselines we consider come from Tapaswi et al. (2016)’s work: • Cosine Word2Vec: A sliding window is used to select the answer according to the similarities computed through Word2Vec between the sentences in plot and the question/answer. • Cosine TFIDF: This model is similar to the previous method but uses bag-of-word with tf-idf scores to compute similarity. • SSCB TFIDF: Instead of using the sliding window method, a convolutional neural network is built on the sentence level similarities.
+
+# 3.3 ANALYSIS OF RESULTS
+
+We use accuracy as the evaluation metric for the datasets MovieQA, InsuranceQA and SNLI, as there is only one correct answer or one label for each instance. For WikiQA, there may be multiple correct answers, so evaluation metrics we use are Mean Average Precision (MAP) and Mean Reciprocal Rank (MRR).
+
+We observe the following from the results. (1) Overall, we can find that our general “compareaggregate” structure achieves the best performance on MovieQA, InsuranceQA, WikiQA datasets and very competitive performance on the SNLI dataset. Especially for the InsuranceQA dataset, with any comparison function we use, our model can outperform all the previous models. (2) The comparison method SUBMULT $\bf { \Phi } + \bf { N N }$ is the best in general. (3) Some simple comparison functions can achieve better performance than the neural networks or neural tensor network comparison functions. For example, the simplest comparison function EUCCOS achieves nearly the best performance in the MovieQA dataset, and the element-wise comparison functions, which do not need parameters can achieve the best performance on the WikiQA dataset. (4) We find the preprocessing layer and the attention layer for word selection to be important in the “compare-aggregate” structure through the experiments of removing these two layers separately. We also see that for sequence matching with big difference in length, such as the MovieQA and InsuranceQA tasks, the attention layer plays a more important role. For sequence matching with smaller difference in length, such as the WikiQA and SNLI tasks, the pre-processing layer plays a more important role. (5) For the MovieQA, InsuranceQA and WikiQA tasks, our preprocessing layer is order-insensitive so that it will not take the context information into consideration during the comparison, but our model can still outperform the previous work with order-sensitive preprocessing layer. With this finding, we believe the word-by-word comparison part plays a very important role in these tasks. We will further explore the preprocessing layer in the future.
+
+# 3.4 FURTHER ANALYSES
+
+To further explain how our model works, we visualize the max values in each dimension of the convolutional layer. We use two examples shown in Table 1 from MovieQA and InsuranceQA datasets respectively. In the top of Figure 2, we can see that the plot words that also appear in either the question or the answer will draw more attention by the CNN. We hypothesize that if the nearby words in the plot can match both the words in question and the words in one answer, then this answer is more likely to be the correct one. Similarly, the bottom one of Figure 2 also shows that the CNN will focus more on the matched word representations. If the words in one answer continuously match the words in the question, this answer is more likely to be the correct one.
+
+# 4 RELATED WORK
+
+We review related work in three types of general structures for matching sequences.
+
+Siamense network: These kinds of models use the same structure, such as RNN or CNN, to build the representations for the sequences separately and then use them for classification. Then cosine similarity (Feng et al., 2015; Yang et al., 2015), element-wise operation (Tai et al., 2015; Mou et al., 2016) or neural network-based combination Bowman et al. (2015) are used for sequence matching.
+
+Attentive network: Soft-attention mechanism (Bahdanau et al., 2014; Luong et al., 2015) has been widely used for sequence matching in machine comprehension (Hermann et al., 2015), text entailment (Rocktaschel et al., 2015) and question answering (Tan et al., 2016). Instead of using the ¨ final state of RNN to represent a sequence, these studies use weighted sum of all the states for the sequence representation.
+
+Compare-Aggregate network: This kind of framework is to perform the word level matching (Wang & Jiang, 2016a; Parikh et al., 2016; He & Lin, 2016; Trischler et al., 2016; Wan et al.,
+
+![](images/27f1d5e7b23b964c7ee665e91a3e8b362fec068358e8183d673024ba6b5afb7d.jpg)  
+Figure 2: An visualization of the largest value of each dimension in the convolutional layer of CNN. The top figure is an example from the dataset MovieQA with CNN window size 5. The bottom figure is an example from the dataset InsuranceQA with CNN window size 3. Due to the sparsity of the representation, we show only the dimensions with larger values. The dimensionality of the raw representations is 150.
+
+2016). Our work is under this framework. But our structure is different from previous models and our model can be applied on different tasks. Besides, we analyzed different word-level comparison functions separately.
+
+# 5 CONCLUSIONS
+
+In this paper, we systematically analyzed the effectiveness of a “compare-aggregate” model on four different datasets representing different tasks. Moreover, we compared and tested different kinds of word-level comparison functions and found that some element-wise comparison functions can outperform the others. According to our experiment results, many different tasks can share the same “compare-aggregate” structure. In the future work, we would like to test its effectiveness on multi-task learning.
+
+# 6 ACKNOWLEDGMENTS
+
+This research is supported by the National Research Foundation, Prime Ministers Office, Singapore under its International Research Centres in Singapore Funding Initiative.
+
+# REFERENCES
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In Proceedings of the International Conference on Learning Representations, 2014.
+
+Michael Bendersky, Donald Metzler, and W Bruce Croft. Learning concept importance using a weighted dependence model. In Proceedings of the third ACM International Conference on Web Search and Data Mining. ACM, 2010.
+
+Samuel R Bowman, Gabor Angeli, Christopher Potts, and Christopher D Manning. A large annotated corpus for learning natural language inference. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2015.
+
+Qian Chen, Xiaodan Zhu, Zhenhua Ling, Si Wei, and Hui Jiang. Enhancing and combining sequential and tree LSTM for natural language inference. arXiv preprint arXiv:1609.06038, 2016.
+
+Jianpeng Cheng, Li Dong, and Mirella Lapata. Long short-term memory-networks for machine reading. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2016.
+
+Minwei Feng, Bing Xiang, Michael R Glass, Lidan Wang, and Bowen Zhou. Applying deep learning to answer selection: A study and an open task. In 2015 IEEE Workshop on Automatic Speech Recognition and Understanding (ASRU), pp. 813–820. IEEE, 2015.
+
+Hua He and Jimmy Lin. Pairwise word interaction modeling with deep neural networks for semantic similarity measurement. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 2016.
+
+Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Proceedings of the Conference on Advances in Neural Information Processing Systems, 2015.
+
+Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The Goldilocks principle: Reading children’s books with explicit memory representations. In Proceedings of the International Conference on Learning Representations, 2016.
+
+Baotian Hu, Zhengdong Lu, Hang Li, and Qingcai Chen. Convolutional neural network architectures for matching natural language sentences. In Advances in Neural Information Processing Systems, 2014.
+
+Yoon Kim. Convolutional neural networks for sentence classification. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2014.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the International Conference on Learning Representations, 2015.
+
+Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Effective approaches to attentionbased neural machine translation. Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2015.
+
+Lili Mou, Rui Men, Ge Li, Yan Xu, Lu Zhang, Rui Yan, and Zhi Jin. Natural language inference by tree-based convolution and heuristic matching. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2016.
+
+Ankur P Parikh, Oscar Tackstr ¨ om, Dipanjan Das, and Jakob Uszkoreit. A decomposable attention ¨ model for natural language inference. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2016.
+
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. GloVe: Global vectors for word representation. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2014.
+
+Matthew Richardson, Christopher JC Burges, and Erin Renshaw. MCTest: A challenge dataset for the open-domain machine comprehension of text. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2013.
+
+Tim Rocktaschel, Edward Grefenstette, Karl Moritz Hermann, Tom ¨ a´s Ko ˇ cisk ˇ y, and Phil Blunsom. \` Reasoning about entailment with neural attention. In Proceedings of the International Conference on Learning Representations, 2015.
+
+Richard Socher, Alex Perelygin, Jean Y Wu, Jason Chuang, Christopher D Manning, Andrew Y $\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2013.
+
+Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. In Proceedings of the Conference on Association for Computational Linguistics, 2015.
+
+Ming Tan, Cicero dos Santos, Bing Xiang, and Bowen Zhou. Improved representation learning for question answer matching. In Proceedings of the Conference on Association for Computational Linguistics, 2016.
+
+Makarand Tapaswi, Yukun Zhu, Rainer Stiefelhagen, Antonio Torralba, Raquel Urtasun, and Sanja Fidler. MovieQA: Understanding stories in movies through question-answering. In Proceedings of IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Adam Trischler, Zheng Ye, Xingdi Yuan, Jing He, Phillip Bachman, and Kaheer Suleman. A parallel-hierarchical model for machine comprehension on sparse data. In Proceedings of the Conference on Association for Computational Linguistics, 2016.
+
+Shengxian Wan, Yanyan Lan, Jun Xu, Jiafeng Guo, Liang Pang, and Xueqi Cheng. Match-srnn: Modeling the recursive matching structure with spatial RNN. International Joint Conference on Artificial Intelligence, 2016.
+
+Bingning Wang, Kang Liu, and Jun Zhao. Inner attention based recurrent neural networks for answer selection. In Proceedings of the Conference on Association for Computational Linguistics, 2016.
+
+Shuohang Wang and Jing Jiang. Machine comprehension using match-LSTM and answer pointer. arXiv preprint arXiv:1608.07905, 2016a.
+
+Shuohang Wang and Jing Jiang. Learning natural language inference with LSTM. In Proceedings of the Conference on the North American Chapter of the Association for Computational Linguistics, 2016b.
+
+Yi Yang, Wen-tau Yih, and Christopher Meek. WikiQA: A challenge dataset for open-domain question answering. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2015.
+
+Wenpeng Yin, Hinrich Schutze, Bing Xiang, and Bowen Zhou. ABCNN: Attention-based convolu- ¨ tional neural network for modeling sentence pairs. arXiv preprint arXiv:1512.05193, 2015.

parse/train/HJTzHtqee/HJTzHtqee_content_list.json

@@ -0,0 +1,1509 @@
+[
+    {
+        "type": "text",
+        "text": "A COMPARE-AGGREGATE MODEL FOR MATCHING TEXT SEQUENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang School of Information Systems Singapore Management University shwang.2014@phdis.smu.edu.sg ",
+        "bbox": [
+            184,
+            172,
+            459,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jing Jiang School of Information Systems Singapore Management University jingjiang@smu.edu.sg ",
+        "bbox": [
+            531,
+            172,
+            759,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            266,
+            544,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many NLP tasks including machine comprehension, answer selection and text entailment require the comparison between sequences. Matching the important units between sequences is a key to solve these problems. In this paper, we present a general “compare-aggregate” framework that performs word-level matching followed by aggregation using Convolutional Neural Networks. We particularly focus on the different comparison functions we can use to match two vectors. We use four different datasets to evaluate the model. We find that some simple comparison functions based on element-wise operations can work better than standard neural network and neural tensor network. ",
+        "bbox": [
+            233,
+            296,
+            764,
+            421
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            448,
+            336,
+            463
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many natural language processing problems involve matching two or more sequences to make a decision. For example, in textual entailment, one needs to determine whether a hypothesis sentence can be inferred from a premise sentence (Bowman et al., 2015). In machine comprehension, given a passage, a question needs to be matched against it in order to find the correct answer (Richardson et al., 2013; Tapaswi et al., 2016). Table 1 gives two example sequence matching problems. In the first example, a passage, a question and four candidate answers are given. We can see that to get the correct answer, we need to match the question against the passage and identify the last sentence to be the answer-bearing sentence. In the second example, given a question and a set of candidate answers, we need to find the answer that best matches the question. Because of the fundamental importance of comparing two sequences of text to judge their semantic similarity or relatedness, sequence matching has been well studied in natural language processing. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With recent advances of neural network models in natural language processing, a standard practice for sequence modeling now is to encode a sequence of text as an embedding vector using models such as RNN and CNN. To match two sequences, a straightforward approach is to encode each sequence as a vector and then to combine the two vectors to make a decision (Bowman et al., 2015; Feng et al., 2015). However, it has been found that using a single vector to encode an entire sequence is not sufficient to capture all the important information from the sequence, and therefore advanced techniques such as attention mechanisms and memory networks have been applied to sequence matching problems (Hermann et al., 2015; Hill et al., 2016; Rocktaschel et al., 2015). ¨ ",
+        "bbox": [
+            174,
+            638,
+            825,
+            750
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A common trait of a number of these recent studies on sequence matching problems is the use of a “compare-aggregate” framework (Wang & Jiang, 2016b; He & Lin, 2016; Parikh et al., 2016). In such a framework, comparison of two sequences is not done by comparing two vectors each representing an entire sequence. Instead, these models first compare vector representations of smaller units such as words from these sequences and then aggregate these comparison results to make the final decision. For example, the match-LSTM model proposed by Wang & Jiang (2016b) for textual entailment first compares each word in the hypothesis with an attention-weighted version of the premise. The comparison results are then aggregated through an LSTM. He & Lin (2016) proposed a pairwise word interaction model that first takes each pair of words from two sequences and applies a comparison unit on the two words. It then combines the results of these word interactions using a similarity focus layer followed by a multi-layer CNN. Parikh et al. (2016) proposed a decomposable attention model for textual entailment, in which words from each sequence are compared with an attention-weighted version of the other sequence to produce a series of comparison vectors. The comparison vectors are then aggregated and fed into a feed forward network for final classification. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/e7246d3cfcd7b6757f27dfc4b71d053f2f0d1d93e714ed940cdc828ff7a3734c.jpg",
+        "table_caption": [
+            "Table 1: The example on the left is a machine comprehension problem from MovieQA, where the correct answer here is The Shire. The example on the right is an answer selection problem from InsuranceQA. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Plot:... Aragorn is crowned King of Gon- dor and taking Arwen as his queen before all present at his coronation bowing before Frodo and the other Hobbits．The Hobbits return to the Shire where Sam marries Rosie Cotton ....</td></tr><tr><td>Qustion: Where does Sam marry Rosie?</td></tr><tr><td>Candidate answers: O) Grey Havens.1) Gon- dor.2) The Shire.3) Erebor.4) Mordor.</td></tr></table>",
+        "bbox": [
+            189,
+            102,
+            490,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/47ef6c53f8c954ba7eeaf8b30cc32a5b37a75d0532daa0a5b2a96a384ba26be1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Question: can i have auto insurance without a car</td></tr><tr><td>Ground-truth answer: yes,it be possible have auto insurance without own a vehicle.you will purchase what be call a name ..</td></tr><tr><td>Another candidate answer: insurance not be a tax or merely a legal obligation because auto insurance follow a car...</td></tr></table>",
+        "bbox": [
+            506,
+            102,
+            808,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            308,
+            821,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Although these studies have shown the effectiveness of such a “compare-aggregate” framework for sequence matching, there are at least two limitations with these previous studies: (1) Each of the models proposed in these studies is tested on one or two tasks only, but we hypothesize that this general framework is effective on many sequence matching problems. There has not been any study that empirically verifies this. (2) More importantly, these studies did not pay much attention to the comparison function that is used to compare two small textual units. Usually a standard feedforward network is used (Hu et al., 2014; Wang & Jiang, 2016b) to combine two vectors representing two units that need to be compared, e.g., two words. However, based on the nature of these sequence matching problems, we essentially need to measure how semantically similar the two sequences are. Presumably, this property of these sequence matching problems should guide us in choosing more appropriate comparison functions. Indeed He & Lin (2016) used cosine similarity, Euclidean distance and dot product to define the comparison function, which seem to be better justifiable. But they did not systematically evaluate these similarity or distance functions or compare them with a standard feedforward network. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we argue that the general “compare-aggregate” framework is effective for a wide range of sequence matching problems. We present a model that follows this general framework and test it on four different datasets, namely, MovieQA, InsuranceQA, WikiQA and SNLI. The first three datasets are for Question Answering, but the setups of the tasks are quite different. The last dataset is for textual entailment. More importantly, we systematically present and test six different comparison functions. We find that overall a comparison function based on element-wise subtraction and multiplication works the best on the four datasets. ",
+        "bbox": [
+            174,
+            544,
+            825,
+            640
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The contributions of this work are twofold: (1) Using four different datasets, we show that our model following the “compare-aggregate” framework is very effective when compared with the state-ofthe-art performance on these datasets. (2) We conduct systematic evaluation of different comparison functions and show that a comparison function based on element-wise operations, which is not widely used for word-level matching, works the best across the different datasets. We believe that these findings will be useful for future research on sequence matching problems. We have also made our code available online.1 ",
+        "bbox": [
+            174,
+            647,
+            825,
+            744
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            771,
+            281,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose a general model following the “compare-aggregate” framework for matching two sequences. This general model can be applied to different tasks. We focus our discussion on six different comparison functions that can be plugged into this general “compare-aggregate” model. In particular, we hypothesize that two comparison functions based on element-wise operations, SUB and MULT, are good middle ground between highly flexible functions using standard neural network models and highly restrictive functions based on cosine similarity and/or Euclidean distance. As we will show in the experiment section, these comparison functions based on elementwise operations can indeed perform very well on a number of sequence matching problems. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            890
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/bd9a255fdaa82548a427cb5a4a44ace17f1c92aeebb388009fa7221b6faef7c6.jpg",
+        "image_caption": [
+            "Figure 1: The left hand side is an overview of the model. The right hand side shows the details about the different comparison functions. The rectangles in dark represent parameters to be learned. $\\times$ represents matrix multiplication. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            102,
+            812,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            470,
+            821,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 PROBLEM DEFINITION AND MODEL OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            520,
+            544,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The general setup of the sequence matching problem we consider is the following. We assume there are two sequences to be matched. We use two matrices $\\mathbf { Q } \\in \\mathbb { R } ^ { d \\times Q }$ and $\\mathbf { A } \\in \\mathbf { \\mathbb { R } } ^ { d \\times A }$ to represent the word embeddings of the two sequences, where $Q$ and $A$ are the lengths of the two sequences, respectively, and $d$ is the dimensionality of the word embeddings. In other words, each column vector of $\\mathbf { Q }$ or $\\mathbf { A }$ is an embedding vector representing a single word. Given a pair of $\\mathbf { Q }$ and $\\mathbf { A }$ , the goal is to predict a label $y$ . For example, in textual entailment, $\\mathbf { Q }$ may represent a premise and $\\mathbf { A }$ a hypothesis, and $y$ indicates whether $\\mathbf { Q }$ entails $\\mathbf { A }$ or contradicts A. In question answering, $\\mathbf { Q }$ may be a question and A a candidate answer, and $y$ indicates whether A is the correct answer to $\\mathbf { Q }$ . ",
+        "bbox": [
+            174,
+            547,
+            825,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We treat the problem as a supervised learning task. We assume that a set of training examples in the form of $( \\mathbf { Q } , \\mathbf { A } , y )$ is given and we aim to learn a model that maps any pair of $( \\mathbf { Q } , \\mathbf { A } )$ to a $y$ . ",
+        "bbox": [
+            176,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An overview of our model is shown in Figure 1. The model can be divided into the following four layers: ",
+        "bbox": [
+            176,
+            702,
+            823,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Preprocessing: We use a preprocessing layer (not shown in the figure) to process $\\mathbf { Q }$ and A to obtain two new matrices $\\mathbf { \\bar { Q } } \\in \\mathbb { R } ^ { l \\times \\mathbf { \\bar { Q } } }$ and $\\overline { { \\mathbf { A } } } \\in \\mathbb { R } ^ { l \\times A }$ . The purpose here is to use some gate values to control the importance of different words in making the predictions on the sequence pair. For example, $\\overline { { \\mathbf { q } } } _ { i } \\in \\mathbb { R } ^ { l }$ , which is the $i ^ { \\mathrm { { t h } } }$ column vector of $\\overline { { \\mathbf { Q } } }$ , encodes the $i ^ { \\mathrm { { t h } } }$ word in $\\mathbf { Q }$ . ",
+        "bbox": [
+            214,
+            744,
+            823,
+            818
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2. Attention: We apply a standard attention mechanism on $\\overline { { \\mathbf { Q } } }$ and $\\overline { { \\mathbf A } }$ to obtain attention weights over the column vectors in $\\overline { { \\mathbf { Q } } }$ for each column vector in $\\overline { { \\bf A } }$ . With these attention weights, for each column vector $\\overline { { \\mathbf { a } } } _ { j }$ in $\\overline { { \\mathbf A } }$ , we obtain a corresponding vector $\\mathbf { h } _ { j }$ , which is an attention-weighted sum of the column vectors of $\\overline { { \\mathbf { Q } } }$ . ",
+        "bbox": [
+            212,
+            825,
+            825,
+            887
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3. Comparison: We use a comparison function $f$ to combine each pair of $\\overline { { \\mathbf { a } } } _ { j }$ and $\\mathbf { h } _ { j }$ into a vector $\\mathbf { t } _ { j }$ . ",
+        "bbox": [
+            209,
+            895,
+            823,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4. Aggregation: We use a CNN layer to aggregate the sequence of vectors $\\mathbf { t } _ { j }$ for the final classification. ",
+        "bbox": [
+            205,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Although this model follows more or less the same framework as the model proposed by Parikh et al. (2016), our work has some notable differences. First, we will pay much attention to the comparison function $f$ and compare a number of options, including some uncommon ones based on elementwise operations. Second, we apply our model to four different datasets representing four different tasks to evaluate its general effectiveness for sequence matching problems. There are also some other differences from the work by Parikh et al. (2016). For example, we use a CNN layer instead of summation and concatenation for aggregation. Our attention mechanism is one-directional instead of two-directional. ",
+        "bbox": [
+            173,
+            142,
+            825,
+            255
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the rest of this section we will present the model in detail. We will focus mostly on the comparison functions we consider. ",
+        "bbox": [
+            176,
+            261,
+            823,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 PREPROCESSING AND ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            452,
+            320
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the use of gates in LSTM and GRU, we preprocess $\\mathbf { Q }$ and A with the following formulas: ",
+        "bbox": [
+            174,
+            332,
+            823,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9b618fd086a2e7dfd9e73143f01d9755250b2d9c346f30dc4cd6fdabe623caf.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\overline { { \\mathbf { Q } } } } & { = } & { \\sigma ( \\mathbf { W } ^ { \\mathrm { i } } \\mathbf { Q } + \\mathbf { b } ^ { \\mathrm { i } } \\otimes \\mathbf { e } _ { Q } ) \\odot \\mathrm { t a n h } ( \\mathbf { W } ^ { \\mathrm { u } } \\mathbf { Q } + \\mathbf { b } ^ { \\mathrm { u } } \\otimes \\mathbf { e } _ { Q } ) , } \\\\ { \\overline { { \\mathbf { A } } } } & { = } & { \\sigma ( \\mathbf { W } ^ { \\mathrm { i } } \\mathbf { A } + \\mathbf { b } ^ { \\mathrm { i } } \\otimes \\mathbf { e } _ { A } ) \\odot \\mathrm { t a n h } ( \\mathbf { W } ^ { \\mathrm { u } } \\mathbf { A } + \\mathbf { b } ^ { \\mathrm { u } } \\otimes \\mathbf { e } _ { A } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            352,
+            687,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ is element-wise multiplication, and $\\mathbf { W } ^ { \\mathrm { i } } , \\mathbf { W } ^ { \\mathrm { u } } \\in \\mathbb { R } ^ { l \\times d }$ and $\\mathbf { b } ^ { \\mathrm { i } } , \\mathbf { b } ^ { \\mathrm { u } } \\in \\mathbb { R } ^ { l }$ are parameters to be learned. The outer product $\\left( \\cdot \\otimes \\mathbf { e } _ { X } \\right)$ produces a matrix or row vector by repeating the vector or scalar on the left for $X$ times. Here $\\sigma ^ { \\prime } (  { \\mathbf { W } } ^ { \\mathrm { i } } \\mathbf { Q } +  { \\mathbf { b } } ^ { \\mathrm { i } } \\otimes \\mathbf { e } _ { Q } )$ and $\\sigma ( \\mathbf { W } ^ { \\mathrm { i } } \\mathbf { A } + \\mathbf { b } ^ { \\mathrm { i } } \\otimes \\mathbf { e } _ { A } ) $ act as gate values to control the degree to which the original values of $\\mathbf { Q }$ and $\\mathbf { A }$ are preserved in $\\overline { { \\mathbf { Q } } }$ and $\\overline { { \\mathbf A } }$ . For example, for stop words, their gate values would likely be low for tasks where stop words make little difference to the final predictions. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this preprocessing step, the word order does not matter. Although a better way would be to use RNN such as LSTM and GRU to chain up the words such that we can capture some contextual information, this could be computationally expensive for long sequences. In our experiments, we only incorporated LSTM into the formulas above for the SNLI task. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The general attention (Luong et al., 2015) layer is built on top of the resulting $\\overline { { \\mathbf { Q } } }$ and $\\overline { { \\mathbf A } }$ as follows: ",
+        "bbox": [
+            178,
+            551,
+            818,
+            568
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2f58f8cf027e0a28c361eead1ee1d7cea87541e94433b1d0b52c3842027daa3b.jpg",
+        "text": "$$\n\\begin{array} { l l l } { { { \\bf { G } } } } & { { = } } & { { \\mathrm { s o f t m a x } \\left( { ( { \\bf { W } } ^ { \\mathrm { g } } { \\overline { { { \\bf { Q } } } } } + { \\bf { b } } ^ { \\mathrm { g } } \\otimes { \\bf { e } } _ { Q } ) ^ { \\mathrm { { T } } } { \\overline { { { \\bf { A } } } } } } \\right) , } } \\\\ { { { \\bf { H } } } } & { { = } } & { { { \\overline { { { \\bf { Q } } } } } { \\bf { G } } , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            571,
+            642,
+            612
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W ^ { g } } \\in \\mathbb { R } ^ { l \\times l }$ and $\\mathbf { b } ^ { \\mathrm { g } } \\in \\mathbb { R } ^ { l }$ are parameters to be learned, $\\mathbf { G } \\in \\mathbb { R } ^ { Q \\times A }$ is the attention weight matrix, and $\\mathbf { H } \\in \\mathbb { R } ^ { l \\times A }$ are the attention-weighted vectors. Specifically, $\\mathbf { h } _ { j }$ , which is the $j ^ { \\mathrm { t h } }$ column vector of $\\mathbf { H }$ , is a weighted sum of the column vectors of $\\overline { { \\mathbf { Q } } }$ and represents the part of $\\mathbf { Q }$ that best matches the $j ^ { \\mathrm { t h } }$ word in A. Next we will combine $\\mathbf { h } _ { j }$ and $\\overline { { \\mathbf { a } } } _ { j }$ using a comparison function. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            675
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 COMPARISON ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            690,
+            310,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The goal of the comparison layer is to match each $\\overline { { \\mathbf { a } } } _ { j }$ , which represents the $j ^ { \\mathrm { t h } }$ word and its context in $\\mathbf { A }$ , with $\\mathbf { h } _ { j }$ , which represents a weighted version of $\\mathbf { Q }$ that best matches $\\overline { { \\mathbf { a } } } _ { j }$ . Let $f$ denote a comparison function that transforms $\\overline { { \\mathbf { a } } } _ { j }$ and $\\mathbf { h } _ { j }$ into a vector $\\mathbf { t } _ { j }$ to represent the comparison result. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A natural choice of $f$ is a standard neural network layer that consists of a linear transformation followed by a non-linear activation function. For example, we can consider the following choice: ",
+        "bbox": [
+            171,
+            766,
+            823,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3061e8ad87b8af7eed01ab31665caf35e1f7a696192eb41b09488cabc0c26a4a.jpg",
+        "text": "$$\n\\mathrm { N E U R A L N E T } \\left( \\mathrm { N N } \\right) ; \\qquad \\mathbf { t } _ { j } = f \\bigl ( \\mathbf { \\overline { { a } } } _ { j } , \\mathbf { h } _ { j } \\bigr ) = \\mathrm { R e L U } \\bigl ( \\mathbf { W } \\left[ \\mathbf { \\overline { { a } } } _ { j } \\right] + \\mathbf { b } \\bigr ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            799,
+            717,
+            834
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where matrix $\\mathbf { W } \\in \\mathbb { R } ^ { l \\times { 2 l } }$ and vector $\\mathbf { b } \\in \\mathbb { R } ^ { l }$ are parameters to be learned. ",
+        "bbox": [
+            176,
+            839,
+            660,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Alternatively, another natural choice is a neural tensor network (Socher et al., 2013) as follows: ",
+        "bbox": [
+            171,
+            861,
+            795,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\mathrm { N E U R A L T E N S O R N E T } \\left( \\mathrm { N T N } \\right) : \\qquad \\mathbf { t } _ { j } = f ( \\overline { { \\mathbf { a } } } _ { j } , \\mathbf { h } _ { j } ) = \\mathrm { R e L U } ( \\overline { { \\mathbf { a } } } _ { j } ^ { \\mathrm { { T } } } \\mathbf { T } ^ { [ 1 \\ldots l ] } \\mathbf { h } _ { j } + \\mathbf { b } ) ,$ where tensor $\\mathbf { T } ^ { [ 1 \\ldots l ] } \\in \\mathbb { R } ^ { l \\times l \\times l }$ and vector $\\mathbf { b } \\in \\mathbb { R } ^ { l }$ are parameters to be learned. ",
+        "bbox": [
+            174,
+            881,
+            763,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, we note that for many sequence matching problems, we intend to measure the semantic similarity or relatedness of the two sequences. So at the word level, we also intend to check how similar or related $\\overline { { \\mathbf { a } } } _ { j }$ is to $\\mathbf { h } _ { j }$ . For this reason, a more natural choice used in some previous work is Euclidean distance or cosine similarity between $\\overline { { \\mathbf { a } } } _ { j }$ and $\\mathbf { h } _ { j }$ . We therefore consider the following definition of $f$ : ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9b21b547f3744ef6951f7edfb042e0dd022c713f40ddcd9f23f772f52d1a5095.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { E U C L I D E A N + C O S I N E ~ ( E U C C O S ) : } \\qquad \\mathbf { t } _ { j } = f ( \\overline { { \\mathbf { a } } } _ { j } , \\mathbf { h } _ { j } ) = \\left[ \\Vert \\overline { { \\mathbf { a } } } _ { j } - \\mathbf { h } _ { j } \\Vert _ { 2 } \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            180,
+            743,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that with EUCCOS, the resulting vector $\\mathbf { t } _ { j }$ is only a 2-dimensional vector. Although EUCCOS is a well-justified comparison function, we suspect that it may lose some useful information from the original vectors $\\overline { { \\mathbf { a } } } _ { j }$ and $\\mathbf { h } _ { j }$ . On the other hand, NN and NTN are too general and thus do not capture the intuition that we care mostly about the similarity between $\\mathbf { \\overline { { a } } } _ { j }$ and $\\mathbf { h } _ { j }$ . ",
+        "bbox": [
+            173,
+            227,
+            825,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To use something that is a good compromise between the two extreme cases, we consider the following two new comparison functions, which operate on the two vectors in an element-wise manner. These functions have been used previously by Mou et al. (2016). ",
+        "bbox": [
+            173,
+            290,
+            821,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cd45acbae685ef8206b570b22c58332565d7069cba72cb3616fdb494e1bd1ef4.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathrm { S U B T R A C T I O N ~ ( S U B ) } \\colon \\quad } & { \\mathbf { t } _ { j } = f ( \\overline { { \\mathbf { a } } } _ { j } , \\mathbf { h } _ { j } ) = ( \\overline { { \\mathbf { a } } } _ { j } - \\mathbf { h } _ { j } ) \\odot ( \\overline { { \\mathbf { a } } } _ { j } - \\mathbf { h } _ { j } ) , } \\\\ { \\mathrm { M U L T I P L I C A T I O N ~ ( M U L T ) } \\colon \\quad } & { \\mathbf { t } _ { j } = f ( \\overline { { \\mathbf { a } } } _ { j } , \\mathbf { h } _ { j } ) = \\overline { { \\mathbf { a } } } _ { j } \\odot \\mathbf { h } _ { j } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            339,
+            745,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the operator $\\odot$ is element-wise multiplication. For both comparison functions, the resulting vector $\\mathbf { t } _ { j }$ has the same dimensionality as $\\overline { { \\mathbf { a } } } _ { j }$ and $\\mathbf { h } _ { j }$ . ",
+        "bbox": [
+            174,
+            381,
+            825,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can see that SUB is closely related to Euclidean distance in that Euclidean distance is the sum of all the entries of the vector $\\mathbf { t } _ { j }$ produced by SUB. But by not summing up these entries, SUB preserves some information about the different dimensions of the original two vectors. Similarly, MULT is closely related to cosine similarity but preserves some information about the original two vectors. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            486
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, we consider combining SUB and MULT followed by an NN layer as follows: ",
+        "bbox": [
+            173,
+            492,
+            728,
+            508
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c45e3ce39f0ef2ef73ce7592632b72e8732a501f9426580799c2ef869ecfd055.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathrm { S U B M U L T + N N : } \\quad } & { \\mathbf { t } _ { j } = f ( \\overline { { \\mathbf { a } } } _ { j } , \\mathbf { h } _ { j } ) = \\mathrm { R e L U } \\big ( \\mathbf { W } \\left[ \\mathbf { ( \\overline { { a } } } _ { j } - \\mathbf { h } _ { j } ) \\odot ( \\overline { { \\mathbf { a } } } _ { j } - \\mathbf { h } _ { j } ) \\right] + \\mathbf { b } \\big ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            513,
+            772,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In summary, we consider six different comparison functions: NN, NTN, EUCCOS, SUB, MULT and SUBMULT $\\mathbf { \\Gamma } + \\mathbf { N N }$ . Among these functions, the last three (SUB, MULT and SUBMULT $+ \\mathrm { N N }$ ) have not been widely used in previous work for word-level matching. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            606
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 AGGREGATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            622,
+            320,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After we apply the comparison function to each pair of $\\overline { { \\mathbf { a } } } _ { j }$ and $\\mathbf { h } _ { j }$ to obtain a series of vectors $\\mathbf { t } _ { j }$ , finally we aggregate these vectors using a one-layer CNN (Kim, 2014): ",
+        "bbox": [
+            173,
+            647,
+            825,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9027ff79f70cd34053e9562dce83b4427cd66fa65413dbaeab615f7be89a1ce1.jpg",
+        "text": "$$\n\\begin{array} { r l r } { { \\bf r } } & { { } = } & { { \\bf C } { \\bf N } { \\bf N } ( [ { \\bf t } _ { 1 } , \\ldots , { \\bf t } _ { A } ] ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            683,
+            593,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { r } \\in \\mathbb { R } ^ { n l }$ is then used for the final classification, where $n$ is the number of windows in CNN. ",
+        "bbox": [
+            169,
+            707,
+            772,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            742,
+            326,
+            758
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/d1057cc14dc2bc6d6b7f3f371a7abfc24c012da631a5cfa50c202802e882a080.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: The statistics of different datasets. Q:question/hypothesis, C:candidate answers for each question, A:answer/hypothesis, P:plot, w:word (average). "
+        ],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">MovieQA</td><td colspan=\"3\">InsuranceQA</td><td colspan=\"3\">WikiQA</td><td colspan=\"3\">SNLI</td></tr><tr><td></td><td>train</td><td>dev</td><td>test</td><td>train</td><td>dev</td><td>test</td><td>train</td><td>dev</td><td>test</td><td>train</td><td>dev</td><td>test</td></tr><tr><td>#Q</td><td>9848</td><td>1958</td><td>3138</td><td>13K</td><td>1K</td><td>1.8K*2</td><td>873</td><td>126</td><td>243</td><td>549K</td><td>9842</td><td>9824</td></tr><tr><td>#C</td><td>5</td><td>5</td><td>5</td><td>50</td><td>500</td><td>500</td><td>10</td><td>9</td><td>10</td><td>-</td><td>-</td><td>-</td></tr><tr><td>#w in P</td><td>873</td><td>866</td><td>914</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>1</td><td>-</td><td>-</td><td>1</td></tr><tr><td>#w in Q</td><td>10.6</td><td>10.6</td><td>10.8</td><td>7.2</td><td>7.2</td><td>7.2</td><td>6.5</td><td>6.5</td><td>6.4</td><td>14</td><td>15.2</td><td>15.2</td></tr><tr><td>#w in A</td><td>5.9</td><td>5.6</td><td>5.5</td><td>92.1</td><td>92.1</td><td>92.1</td><td>25.5</td><td>24.7</td><td>25.1</td><td>8.3</td><td>8.4</td><td>8.3</td></tr></table>",
+        "bbox": [
+            173,
+            776,
+            831,
+            882
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0a8568dde2253140922f4d853d699038d7a6ef4f5a89ad327b503b37386b401.jpg",
+        "table_caption": [
+            "Table 3: Experiment Results "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td colspan=\"2\">MovieQA</td><td colspan=\"3\">InsuranceQA</td><td colspan=\"2\">WikiQA</td><td colspan=\"2\">SNLI</td></tr><tr><td>dev</td><td>test</td><td>dev</td><td>test1</td><td>test2</td><td>MAP</td><td>MRR</td><td>train</td><td>test</td></tr><tr><td>Cosine Word2Vec</td><td>46.4</td><td>45.63</td><td>-</td><td>=</td><td></td><td>=</td><td>=</td><td>=</td><td>=</td></tr><tr><td>Cosine TFIDF</td><td>47.6</td><td>47.36</td><td>=</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SSCB TFIDF</td><td>48.5</td><td>1</td><td>=</td><td>=</td><td>=</td><td></td><td></td><td></td><td></td></tr><tr><td>IR model</td><td>1</td><td>=</td><td>52.7</td><td>55.1</td><td>50.8</td><td></td><td></td><td></td><td></td></tr><tr><td>CNN with GESD</td><td></td><td>=</td><td>65.4</td><td>65.3</td><td>61.0</td><td></td><td></td><td></td><td></td></tr><tr><td>Attentive LSTM</td><td></td><td></td><td>68.9</td><td>69.0</td><td>64.8</td><td></td><td></td><td></td><td></td></tr><tr><td>IARNN-Occam</td><td></td><td>=</td><td>69.1</td><td>68.9</td><td>65.1</td><td>0.7341</td><td>0.7418</td><td></td><td></td></tr><tr><td>IARNN-Gate</td><td></td><td></td><td>70.0</td><td>70.1</td><td>62.8</td><td>0.7258</td><td>0.7394</td><td></td><td></td></tr><tr><td>CNN-Cnt</td><td></td><td></td><td>-</td><td>-</td><td>-</td><td>0.6520</td><td>0.6652</td><td></td><td></td></tr><tr><td>ABCNN</td><td></td><td></td><td>=</td><td></td><td>=</td><td>0.6921</td><td>0.7108</td><td></td><td></td></tr><tr><td>CubeCNN</td><td></td><td></td><td></td><td></td><td></td><td>0.7090</td><td>0.7234</td><td></td><td></td></tr><tr><td>W-by-WAttention</td><td></td><td></td><td></td><td></td><td></td><td>=</td><td>=</td><td>85.3</td><td>83.5</td></tr><tr><td>match-LSTM</td><td></td><td></td><td></td><td></td><td></td><td></td><td>=</td><td>92.0</td><td>86.1</td></tr><tr><td>LSTMN</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>88.5</td><td>86.3</td></tr><tr><td>Decomp Attention</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>90.5</td><td>86.8</td></tr><tr><td>EBIM+TreeLSTM</td><td>=</td><td></td><td>=</td><td>=</td><td>=</td><td>=</td><td>=</td><td>93.0</td><td>88.3</td></tr><tr><td>NN</td><td>31.6</td><td>=</td><td>76.8</td><td>74.9</td><td>72.4</td><td>0.7102</td><td>0.7224</td><td>89.3</td><td>86.3</td></tr><tr><td>NTN</td><td>31.6</td><td>=</td><td>75.6</td><td>75.0</td><td>72.5</td><td>0.7349</td><td>0.7456</td><td>91.6</td><td>86.3</td></tr><tr><td>EucCos</td><td>71.9</td><td>=</td><td>70.6</td><td>70.2</td><td>67.9</td><td>0.6740</td><td>0.6882</td><td>87.1</td><td>84.0</td></tr><tr><td>SUB</td><td>64.9</td><td></td><td>70.0</td><td>71.3</td><td>68.2</td><td>0.7019</td><td>0.7151</td><td>89.8</td><td>86.8</td></tr><tr><td>MULT</td><td>66.4</td><td>=</td><td>76.0</td><td>75.2</td><td>73.4</td><td>0.7433</td><td>0.7545</td><td>89.7</td><td>85.8</td></tr><tr><td>SUBMULT+NN</td><td>72.1</td><td>72.9</td><td>77.0</td><td>75.6</td><td>72.3</td><td>0.7332</td><td>0.7477</td><td>89.4</td><td>86.8</td></tr></table>",
+        "bbox": [
+            205,
+            101,
+            790,
+            425
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/c3c8791170e88783f30fa3439501c45d07d7f89a85d89e569bbc31931f4fa05e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td colspan=\"2\">MovieQA</td><td colspan=\"3\">InsuranceQA</td><td colspan=\"2\">WikiQA</td><td colspan=\"2\">SNLI</td></tr><tr><td>dev</td><td>test</td><td>dev</td><td>test1</td><td>test2</td><td>MAP</td><td>MRR</td><td>train</td><td>test</td></tr><tr><td>SUBMULT+NN (no preprocess)</td><td>72.0</td><td>：</td><td>72.8</td><td>73.8</td><td>70.7</td><td>0.6996</td><td>0.7156</td><td>89.6</td><td>82.8</td></tr><tr><td>SUBMULT+NN (no attention)</td><td>60.4</td><td>：</td><td>69.4</td><td>70.4</td><td>67.8</td><td>0.7164</td><td>0.7238</td><td>89.0</td><td>84.4</td></tr></table>",
+        "bbox": [
+            174,
+            463,
+            823,
+            530
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Ablation Experiment Results. “no preprocess”: remove the preprocessing layer by directly using word embeddings $\\mathbf { Q }$ and A to replace $\\overline { { \\mathbf { Q } } }$ and $\\overline { { \\mathbf A } }$ in Eqn. 1; “no attention”: remove the attention layer by using mean pooling of $\\overline { { \\mathbf { Q } } }$ to replace all the vectors of $\\mathbf { H }$ in Eqn. 2. ",
+        "bbox": [
+            173,
+            545,
+            825,
+            590
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate our model on four different datasets representing different tasks. The first three datasets are question answering tasks while the last one is on textual entailment. The statistics of the four datasets are shown in Table 2. We will fist introduce the task settings and the way we customize the “compare-aggregate” structure to each task. Then we will show the baselines for the different datasets. Finally, we discuss the experiment results shown in Table 3 and the ablation study shown in Table 4. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            699
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 TASK-SPECIFIC MODEL STRUCTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            715,
+            473,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In all these tasks, we use matrix $\\mathbf { Q } \\in \\mathbb { R } ^ { d \\times Q }$ to represent the question or premise and matrix $\\mathbf { A } _ { k } \\in$ $\\mathbb { R } ^ { d \\times A _ { k } }$ $( k \\in [ 1 , K ] )$ to represent the $k ^ { \\mathrm { { t h } } }$ answer or the hypothesis. For the machine comprehension task MovieQA (Tapaswi et al., 2016), there is also a matrix $\\mathbf { P } \\in \\mathbb { R } ^ { d \\times P }$ that represents the plot of a movie. Here $Q$ is the length of the question or premise, $A _ { k }$ the length of the $\\bar { k ^ { \\mathrm { { t h } } } }$ answer, and $P$ the length of the plot. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            811
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the SNLI (Bowman et al., 2015) dataset, the task is text entailment, which identifies the relationship (entailment, contradiction or neutral) between a premise sentence and a hypothesis sentence. Here $K = 1$ , and there are exactly two sequences to match. The actual model structure is what we have described before. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the InsuranceQA (Feng et al., 2015) dataset, the task is an answer selection task which needs to select the correct answer for a question from a candidate pool. For the WikiQA (Yang et al., 2015) datasets, we need to rank the candidate answers according to a question. For both tasks, there are $K$ candidate answers for each question. Let us use $\\mathbf { r } _ { k }$ to represent the resulting vector produced by Eqn. 9 for the $k ^ { \\mathrm { { t h } } }$ answer. In order to select one of the $K$ answers, we first define $\\mathbf { R } = [ \\mathbf { r } _ { 1 } , \\mathbf { r } _ { 2 } , \\ldots , \\mathbf { r } _ { K } ]$ . We then compute the probability of the $k ^ { \\mathrm { { t h } } }$ answer to be the correct one as follows: ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6538b4459c8302fbe6b1600e66a8b70d7bd68eab8149729e496caf6d6d01bbb.jpg",
+        "text": "$$\n\\begin{array} { r l r } { p ( k | { \\bf R } ) } & { = } & { \\mathrm { s o f t m a x } ( { \\bf w } ^ { \\mathrm { T } } \\operatorname { t a n h } ( { \\bf W } ^ { \\mathrm { s } } { \\bf R } + { \\bf b } ^ { \\mathrm { s } } \\otimes { \\bf e } _ { K } ) + b \\otimes { \\bf e } _ { K } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            162,
+            709,
+            181
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W ^ { s } } \\in \\mathbb { R } ^ { l \\times n l }$ , $\\mathbf { w } \\in \\mathbb { R } ^ { l }$ , $\\mathbf { b } ^ { \\mathrm { s } } \\in \\mathbb { R } ^ { l }$ , $b \\in \\mathbb { R }$ are parameters to be learned. ",
+        "bbox": [
+            176,
+            184,
+            661,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the machine comprehension task MovieQA, each question is related to Plot Synopses written by fans after watching the movie and each question has five candidate answers. So for each candidate answer there are three sequences to be matched: the plot $\\mathbf { P }$ , the question $\\mathbf { Q }$ and the answer $\\mathbf { A } _ { k }$ . For each $k$ , we first match $\\mathbf { Q }$ and $\\mathbf { P }$ and refer to the matching result at position $j$ as $\\mathbf { t } _ { j } ^ { \\mathrm { q } }$ , as generated by one of the comparison functions $f$ . Similarly, we also match $\\mathbf { A } _ { k }$ with $\\mathbf { P }$ and refer to the matching result at position $j$ as $\\mathbf { t } _ { k , j } ^ { \\mathrm { a } }$ . We then define ",
+        "bbox": [
+            174,
+            207,
+            825,
+            294
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5c7710d092072fc8bd4ad1d3e358e39cae9826e4d8274b4f2817682e2425ba56.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\mathbf { \\mathrm { t } } _ { k , j } } & { { } = } & { \\left[ \\begin{array} { c } { \\mathbf { \\mathrm { t } } _ { j } ^ { \\mathrm { q } } } \\\\ { \\mathbf { \\mathrm { t } } _ { k , j } ^ { \\mathrm { a } } } \\end{array} \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            297,
+            560,
+            335
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            338,
+            200,
+            352
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a08eaa1d814ca369c84ee1c0f12d71b45cde87ed7d6b8a3171c18297c41fa092.jpg",
+        "text": "$$\n\\begin{array} { l l l } { \\mathbf { r } _ { k } } & { = } & { \\mathbf { C N N } ( [ \\mathbf { t } _ { k , 1 } , \\dots , \\mathbf { t } _ { k , P } ] ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            356,
+            606,
+            375
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To select an answer from the $K$ candidate answers, again we use Eqn. 10 to compute the probabilities. ",
+        "bbox": [
+            174,
+            377,
+            823,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The implementation details of the modes are as follows. The word embeddings are initialized from GloVe (Pennington et al., 2014). During training, they are not updated. The word embeddings not found in GloVe are initialized with zero. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            455
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The dimensionality $l$ of the hidden layers is set to be 150. We use ADAMAX (Kingma & Ba, 2015) with the coefficients $\\beta _ { 1 } = 0 . 9$ and $\\beta _ { 2 } = 0 . 9 9 9$ to optimize the model. We do not use L2- regularization. The main parameter we tuned is the dropout on the embedding layer. For WikiQA, which is a relatively small dataset, we also tune the learning rate and the batch size. For the others, we set the batch size to be 30 and the learning rate 0.002. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            532
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            294,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here, we will introduce the baselines for each dataset. We did not re-implement these models but simply took the reported performance for the purpose of comparison. ",
+        "bbox": [
+            174,
+            574,
+            823,
+            603
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "SNLI: • W-by-W Attention: The model by Rocktaschel et al. (2015), who first introduced attention ¨ mechanism into text entailment. • match-LSTM: The model by Wang & Jiang (2016b), which concatenates the matched words as the inputs of an LSTM. • LSTMN: Long short-term memorynetworks proposed by Cheng et al. (2016). • Decomp Attention: Another “compare-aggregate” model proposed by Parikh et al. (2016). • EBIM $\\mathbf { + }$ TreeLSTM: The state-of-the-art model proposed by Chen et al. (2016) on the SNLI dataset. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            694
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "InsuranceQA: • IR model: This model by Bendersky et al. (2010) learns the concept information to help rank the candidates. • CNN with GESD: This model by Feng et al. (2015) uses Euclidean distance and dot product between sequence representations built through convolutional neural networks to select the answer. • Attentive LSTM: Tan et al. (2016) used soft-attention mechanism to select the most important information from the candidates according to the representation of the questions. • IARNN-Occam: This model by Wang et al. (2016) adds regularization on the attention weights. • IARNN-Gate: This model by Wang et al. (2016) uses the representation of the question to build the GRU gates for each candidate answer. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            811
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "WikiQA: • IARNN-Occam and IARNN-Gate as introduced before. • CNN-Cnt: This model by Yang et al. (2015) combines sentence representations built by a convolutional neural network with logistic regression. • ABCNN: This model is Attention-Based Convolutional Neural Network proposed by Yin et al. (2015). • CubeCNN proposed by He & Lin (2016) builds a CNN on all pairs of word similarity. ",
+        "bbox": [
+            173,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MovieQA: All the baselines we consider come from Tapaswi et al. (2016)’s work: • Cosine Word2Vec: A sliding window is used to select the answer according to the similarities computed through Word2Vec between the sentences in plot and the question/answer. • Cosine TFIDF: This model is similar to the previous method but uses bag-of-word with tf-idf scores to compute similarity. • SSCB TFIDF: Instead of using the sliding window method, a convolutional neural network is built on the sentence level similarities. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3 ANALYSIS OF RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            176,
+            375,
+            190
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use accuracy as the evaluation metric for the datasets MovieQA, InsuranceQA and SNLI, as there is only one correct answer or one label for each instance. For WikiQA, there may be multiple correct answers, so evaluation metrics we use are Mean Average Precision (MAP) and Mean Reciprocal Rank (MRR). ",
+        "bbox": [
+            174,
+            202,
+            825,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We observe the following from the results. (1) Overall, we can find that our general “compareaggregate” structure achieves the best performance on MovieQA, InsuranceQA, WikiQA datasets and very competitive performance on the SNLI dataset. Especially for the InsuranceQA dataset, with any comparison function we use, our model can outperform all the previous models. (2) The comparison method SUBMULT $\\bf { \\Phi } + \\bf { N N }$ is the best in general. (3) Some simple comparison functions can achieve better performance than the neural networks or neural tensor network comparison functions. For example, the simplest comparison function EUCCOS achieves nearly the best performance in the MovieQA dataset, and the element-wise comparison functions, which do not need parameters can achieve the best performance on the WikiQA dataset. (4) We find the preprocessing layer and the attention layer for word selection to be important in the “compare-aggregate” structure through the experiments of removing these two layers separately. We also see that for sequence matching with big difference in length, such as the MovieQA and InsuranceQA tasks, the attention layer plays a more important role. For sequence matching with smaller difference in length, such as the WikiQA and SNLI tasks, the pre-processing layer plays a more important role. (5) For the MovieQA, InsuranceQA and WikiQA tasks, our preprocessing layer is order-insensitive so that it will not take the context information into consideration during the comparison, but our model can still outperform the previous work with order-sensitive preprocessing layer. With this finding, we believe the word-by-word comparison part plays a very important role in these tasks. We will further explore the preprocessing layer in the future. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            529
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4 FURTHER ANALYSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            359,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To further explain how our model works, we visualize the max values in each dimension of the convolutional layer. We use two examples shown in Table 1 from MovieQA and InsuranceQA datasets respectively. In the top of Figure 2, we can see that the plot words that also appear in either the question or the answer will draw more attention by the CNN. We hypothesize that if the nearby words in the plot can match both the words in question and the words in one answer, then this answer is more likely to be the correct one. Similarly, the bottom one of Figure 2 also shows that the CNN will focus more on the matched word representations. If the words in one answer continuously match the words in the question, this answer is more likely to be the correct one. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            702,
+            344,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We review related work in three types of general structures for matching sequences. ",
+        "bbox": [
+            176,
+            734,
+            720,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Siamense network: These kinds of models use the same structure, such as RNN or CNN, to build the representations for the sequences separately and then use them for classification. Then cosine similarity (Feng et al., 2015; Yang et al., 2015), element-wise operation (Tai et al., 2015; Mou et al., 2016) or neural network-based combination Bowman et al. (2015) are used for sequence matching. ",
+        "bbox": [
+            174,
+            756,
+            823,
+            811
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Attentive network: Soft-attention mechanism (Bahdanau et al., 2014; Luong et al., 2015) has been widely used for sequence matching in machine comprehension (Hermann et al., 2015), text entailment (Rocktaschel et al., 2015) and question answering (Tan et al., 2016). Instead of using the ¨ final state of RNN to represent a sequence, these studies use weighted sum of all the states for the sequence representation. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Compare-Aggregate network: This kind of framework is to perform the word level matching (Wang & Jiang, 2016a; Parikh et al., 2016; He & Lin, 2016; Trischler et al., 2016; Wan et al., ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/27f1d5e7b23b964c7ee665e91a3e8b362fec068358e8183d673024ba6b5afb7d.jpg",
+        "image_caption": [
+            "Figure 2: An visualization of the largest value of each dimension in the convolutional layer of CNN. The top figure is an example from the dataset MovieQA with CNN window size 5. The bottom figure is an example from the dataset InsuranceQA with CNN window size 3. Due to the sparsity of the representation, we show only the dimensions with larger values. The dimensionality of the raw representations is 150. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            111,
+            813,
+            459
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "2016). Our work is under this framework. But our structure is different from previous models and our model can be applied on different tasks. Besides, we analyzed different word-level comparison functions separately. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            623
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            642,
+            328,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we systematically analyzed the effectiveness of a “compare-aggregate” model on four different datasets representing different tasks. Moreover, we compared and tested different kinds of word-level comparison functions and found that some element-wise comparison functions can outperform the others. According to our experiment results, many different tasks can share the same “compare-aggregate” structure. In the future work, we would like to test its effectiveness on multi-task learning. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            779,
+            387,
+            794
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This research is supported by the National Research Foundation, Prime Ministers Office, Singapore under its International Research Centres in Singapore Funding Initiative. ",
+        "bbox": [
+            173,
+            809,
+            823,
+            838
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            285,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In Proceedings of the International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Bendersky, Donald Metzler, and W Bruce Croft. Learning concept importance using a weighted dependence model. In Proceedings of the third ACM International Conference on Web Search and Data Mining. ACM, 2010. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel R Bowman, Gabor Angeli, Christopher Potts, and Christopher D Manning. A large annotated corpus for learning natural language inference. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2015. ",
+        "bbox": [
+            176,
+            154,
+            820,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Qian Chen, Xiaodan Zhu, Zhenhua Ling, Si Wei, and Hui Jiang. Enhancing and combining sequential and tree LSTM for natural language inference. arXiv preprint arXiv:1609.06038, 2016. ",
+        "bbox": [
+            173,
+            205,
+            823,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianpeng Cheng, Li Dong, and Mirella Lapata. Long short-term memory-networks for machine reading. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2016. ",
+        "bbox": [
+            173,
+            243,
+            823,
+            285
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Minwei Feng, Bing Xiang, Michael R Glass, Lidan Wang, and Bowen Zhou. Applying deep learning to answer selection: A study and an open task. In 2015 IEEE Workshop on Automatic Speech Recognition and Understanding (ASRU), pp. 813–820. IEEE, 2015. ",
+        "bbox": [
+            173,
+            294,
+            826,
+            337
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hua He and Jimmy Lin. Pairwise word interaction modeling with deep neural networks for semantic similarity measurement. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 2016. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            388
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Proceedings of the Conference on Advances in Neural Information Processing Systems, 2015. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            439
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The Goldilocks principle: Reading children’s books with explicit memory representations. In Proceedings of the International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Baotian Hu, Zhengdong Lu, Hang Li, and Qingcai Chen. Convolutional neural network architectures for matching natural language sentences. In Advances in Neural Information Processing Systems, 2014. ",
+        "bbox": [
+            173,
+            498,
+            825,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim. Convolutional neural networks for sentence classification. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2014. ",
+        "bbox": [
+            174,
+            550,
+            821,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            173,
+            587,
+            823,
+            617
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Effective approaches to attentionbased neural machine translation. Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2015. ",
+        "bbox": [
+            173,
+            625,
+            826,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lili Mou, Rui Men, Ge Li, Yan Xu, Lu Zhang, Rui Yan, and Zhi Jin. Natural language inference by tree-based convolution and heuristic matching. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2016. ",
+        "bbox": [
+            174,
+            676,
+            823,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ankur P Parikh, Oscar Tackstr ¨ om, Dipanjan Das, and Jakob Uszkoreit. A decomposable attention ¨ model for natural language inference. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2016. ",
+        "bbox": [
+            174,
+            727,
+            823,
+            770
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D Manning. GloVe: Global vectors for word representation. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2014. ",
+        "bbox": [
+            174,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew Richardson, Christopher JC Burges, and Erin Renshaw. MCTest: A challenge dataset for the open-domain machine comprehension of text. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2013. ",
+        "bbox": [
+            173,
+            829,
+            823,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tim Rocktaschel, Edward Grefenstette, Karl Moritz Hermann, Tom ¨ a´s Ko ˇ cisk ˇ y, and Phil Blunsom. \\` Reasoning about entailment with neural attention. In Proceedings of the International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Alex Perelygin, Jean Y Wu, Jason Chuang, Christopher D Manning, Andrew Y $\\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2013. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. In Proceedings of the Conference on Association for Computational Linguistics, 2015. ",
+        "bbox": [
+            174,
+            167,
+            821,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ming Tan, Cicero dos Santos, Bing Xiang, and Bowen Zhou. Improved representation learning for question answer matching. In Proceedings of the Conference on Association for Computational Linguistics, 2016. ",
+        "bbox": [
+            173,
+            219,
+            825,
+            262
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Makarand Tapaswi, Yukun Zhu, Rainer Stiefelhagen, Antonio Torralba, Raquel Urtasun, and Sanja Fidler. MovieQA: Understanding stories in movies through question-answering. In Proceedings of IEEE Conference on Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            173,
+            271,
+            825,
+            315
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Trischler, Zheng Ye, Xingdi Yuan, Jing He, Phillip Bachman, and Kaheer Suleman. A parallel-hierarchical model for machine comprehension on sparse data. In Proceedings of the Conference on Association for Computational Linguistics, 2016. ",
+        "bbox": [
+            173,
+            323,
+            821,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shengxian Wan, Yanyan Lan, Jun Xu, Jiafeng Guo, Liang Pang, and Xueqi Cheng. Match-srnn: Modeling the recursive matching structure with spatial RNN. International Joint Conference on Artificial Intelligence, 2016. ",
+        "bbox": [
+            174,
+            375,
+            821,
+            417
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bingning Wang, Kang Liu, and Jun Zhao. Inner attention based recurrent neural networks for answer selection. In Proceedings of the Conference on Association for Computational Linguistics, 2016. ",
+        "bbox": [
+            169,
+            426,
+            823,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang and Jing Jiang. Machine comprehension using match-LSTM and answer pointer. arXiv preprint arXiv:1608.07905, 2016a. ",
+        "bbox": [
+            169,
+            464,
+            823,
+            493
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang and Jing Jiang. Learning natural language inference with LSTM. In Proceedings of the Conference on the North American Chapter of the Association for Computational Linguistics, 2016b. ",
+        "bbox": [
+            174,
+            502,
+            823,
+            545
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yi Yang, Wen-tau Yih, and Christopher Meek. WikiQA: A challenge dataset for open-domain question answering. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2015. ",
+        "bbox": [
+            174,
+            553,
+            823,
+            597
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenpeng Yin, Hinrich Schutze, Bing Xiang, and Bowen Zhou. ABCNN: Attention-based convolu- ¨ tional neural network for modeling sentence pairs. arXiv preprint arXiv:1512.05193, 2015. ",
+        "bbox": [
+            171,
+            604,
+            823,
+            635
+        ],
+        "page_idx": 10
+    }
+]

parse/train/O3bqkf_Puys/O3bqkf_Puys.md

@@ -0,0 +1,481 @@
+# PSTNET: POINT SPATIO-TEMPORAL CONVOLUTION ON POINT CLOUD SEQUENCES
+
+Hehe $\mathbf { F a n ^ { 1 } }$ , Xin $\mathbf { Y } \mathbf { u } ^ { 2 }$ , Yuhang $\mathbf { D i n g ^ { 3 } }$ , Yi Yang2 & Mohan Kankanhalli1
+
+1School of Computing, National University of Singapore   
+2ReLER, University of Technology Sydney   
+3Baidu Research
+
+# ABSTRACT
+
+Point cloud sequences are irregular and unordered in the spatial dimension while exhibiting regularities and order in the temporal dimension. Therefore, existing grid based convolutions for conventional video processing cannot be directly applied to spatio-temporal modeling of raw point cloud sequences. In this paper, we propose a point spatio-temporal (PST) convolution to achieve informative representations of point cloud sequences. The proposed PST convolution first disentangles space and time in point cloud sequences. Then, a spatial convolution is employed to capture the local structure of points in the 3D space, and a temporal convolution is used to model the dynamics of the spatial regions along the time dimension. Furthermore, we incorporate the proposed PST convolution into a deep network, namely PSTNet, to extract features of point cloud sequences in a hierarchical manner. Extensive experiments on widely-used 3D action recognition and 4D semantic segmentation datasets demonstrate the effectiveness of PSTNet to model point cloud sequences.
+
+# 1 INTRODUCTION
+
+Modern robotic and automatic driving systems usually employ real-time depth sensors, such as LiDAR, to capture the geometric information of scenes accurately while being robust to different lighting conditions. A scene geometry is thus represented by a 3D point cloud, i.e., a set of measured point coordinates $\{ ( x , y , z ) \}$ . Moreover, when RGB images are available, they are often used as additional features associated with the 3D points to enhance the discriminativeness of point clouds. However, unlike conventional grid based videos, dynamic point clouds are irregular and unordered in the spatial dimension while points are not consistent and even flow in and out over time. Therefore, existing 3D convolutions on grid based videos (Tran et al., 2015; Carreira & Zisserman, 2017; Hara et al., 2018) are not suitable to model raw point cloud sequences, as shown in Fig. 1.
+
+To model the dynamics of point clouds, one solution is converting point clouds to a sequence of 3D voxels, and then applying 4D convolutions (Choy et al., 2019) to the voxel sequence. However, directly performing convolutions on voxel sequences require a large amount of computation. Furthermore, quantization errors are inevitable during voxelization, which may restrict applications that require precise measurement of scene geometry. Another solution MeteorNet (Liu et al., 2019e) is extending the static point cloud method PointNet++ (Qi et al., 2017b) to process raw point cloud sequences by appending 1D temporal dimension to 3D points. However, simply concatenating coordinates and time together and treating point cloud sequences as unordered 4D point sets neglect the temporal order of timestamps, which may not properly exploit the temporal information and lead to inferior performance. Moreover, the scales of spatial displacements and temporal differences in point cloud sequences may not be compatible. Treating them equally is not conducive for network optimization. Besides, MeteorNet only considers spatial neighbors and neglects the local dependencies of neighboring frames. With the use of whole sequence length as its temporal receptive field, MeteorNet cannot construct temporal hierarchy. As points are not consistent and even flow in and out of the region, especially for long sequences and fast motion embedding points in a spatially local area along an entire sequence handicaps capturing accurate local dynamics of point clouds.
+
+In this paper, we propose a point spatio-temporal (PST) convolution to directly process raw point cloud sequences. As dynamic point clouds are spatially irregular but ordered in the temporal dimension, we decouple the spatial and temporal information to model point cloud sequences. Specifically, PST convolution consists of (i) a point based spatial convolution that models the spatial structure of 3D points and (ii) a temporal convolution that captures the temporal dynamics of point cloud sequences. In this fashion, PST convolution significantly facilitates the modeling of dynamic point clouds and reduces the impact of the spatial irregularity of points on temporal modeling. Because point cloud sequences emerge inconsistently across frames, it is challenging to perform convolution on them. To address this problem, we introduce a point tube to preserve the spatio-temporal local structure.
+
+![](images/7fc355595272337407bd012824bbd51c276373fdd492d55d655447def2f05f52.jpg)  
+Figure 1: Illustration of grid based and point based convolutions on spatio-temporal sequences. (a) For a grid based video, each grid represents a feature of a pixel, where $C$ , $L$ , $H$ and $W$ denote the feature dimension, the number of frames, height and width, respectively. A 3D convolution encodes an input to an output of size $C ^ { \prime } \times L ^ { \prime } \times H ^ { \prime } \times \bar { W } ^ { \prime }$ . (b) A point cloud sequence consists of a coordinate part $( 3 \times L \times N )$ and a feature part $( C \times L \times N )$ , where $N$ indicates the number of points in a frame. Our PST convolution encodes an input to an output composed of a coordinate tensor $( 3 \times L ^ { \prime } \times N ^ { \prime } )$ and a feature tensor $( C ^ { \prime } \times L ^ { \prime } \times N ^ { \prime } )$ . Usually, $L ^ { \prime } \leq L$ and $N ^ { \prime } \leq N$ so that networks can model point cloud sequences in a spatio-temporally hierarchical manner. Note that points in different frames are not consistent, and thus it is challenging to capture the spatio-temporal correlation.
+
+To enhance the feature extraction ability, we incorporate the proposed PST convolution into a spatiotemporally hierarchical network, namely PSTNet. Moreover, we extend our PST convolution to a transposed version to address point-level prediction tasks. Different from the convolutional version, the PST transposed convolution is designed to interpolate temporal dynamics and spatial features. Extensive experiments on widely-used 3D action recognition and 4D semantic segmentation datasets demonstrate the effectiveness of the proposed PST convolution and the superiority of PSTNet in modeling point clouds sequences. The contributions of this paper are fourfold:
+
+• To the best of our knowledge, we are the first attempt to decompose spatial and temporal information in modeling raw point cloud sequences, and propose a generic point based convolutional operation, named PST convolution, to encode raw point cloud sequences. • We propose a PST transposed convolution to decode raw point cloud sequences via interpolating the temporal dynamics and spatial feature for point-level prediction tasks. • We construct convolutional neural networks based on the PST convolutions and transposed convolutions, dubbed PSTNet, to tackle sequence-level classification and point-level prediction tasks. To the best of our knowledge, our PSTNet is the first deep neural network to model raw point cloud sequences in a both spatially and temporally hierarchical manner. • Extensive experiments on four datasets indicate that our method improves the accuracy of 3D action recognition and 4D semantic segmentation.
+
+# 2 RELATED WORK
+
+Learning Representations on Grid based Videos. Impressive progress has been made on generating compact and discriminative representations for RGB/RGBD videos due to the success of deep neural networks. For example, two-stream convolutional neural networks (Simonyan & Zisserman, 2014; Wang et al., 2016) utilize a spatial stream and an optical flow stream for video modeling. To summarize the temporal dependencies of videos, recurrent neural networks $\mathrm { N g }$ et al., 2015; Fan et al., 2018) and pooling techniques (Fan et al., 2017) are employed. In addition, by stacking multiple 2D frames into a 3D tensor, 3D convolutional neural networks (Tran et al., 2015; Carreira & Zisserman, 2017; Tran et al., 2018; Hara et al., 2018) are widely used to learn spatio-temporal representations for videos, and achieve promising performance. Besides, interpretable video or action reasoning methods (Zhuo et al., 2019; Fan et al., 2021b) are proposed by explicitly parsing changes in videos.
+
+Static Point Cloud Processing. Static point cloud analysis has been widely investigated for many problems, such as classification, object part segmentation, scene semantic segmentation (Qi et al., 2017a;b; Li et al., 2018b; Wu et al., 2019; Thomas et al., 2019; Wang et al., 2019), reconstruction (Dai et al., 2017; Yu et al., 2018) and object detection (Chen et al., 2017; Qi et al., 2019). Most recent works aim to directly manipulate point sets without transforming coordinates into regular voxel grids. Since a point cloud is essentially a set of unordered points and invariant to permutations of its points, static point cloud processing methods mainly focus on designing effective point based spatial correlation operations that do not rely on point orderings.
+
+Dynamic Point Cloud Modeling. Compared with static point cloud processing, dynamic point cloud modeling is a fairly new task. Fast and Furious (FaF) (Luo et al., 2018) converts a point cloud frame into a bird’s view voxel and then extracts features via 3D convolutions. MinkowskiNet (Choy et al., 2019) converts a point cloud sequence into a 4D occupancy grid and then applies 4D Spatio-Temporal ConvNets. PointRNN (Fan & Yang, 2019) leverages point based recurrent neural networks for raw point cloud sequence forecasting. MeteorNet (Liu et al., 2019e) extends 3D points to 4D points and then appends a temporal dimension to PointNet+ $^ +$ to process these 4D points. 3DV (Wang et al., 2020) first integrates 3D motion information into a regular compact voxel set and then applies PointNet+ $^ +$ to extract representations from the set for 3D action recognition. P4Transformer (Fan et al., 2021a) employs transformer to avoid point tracking for raw point cloud sequence modeling. Niemeyer et al. (2019) learned a temporal and spatial vector field for 4D reconstruction. Prantl et al. (2020) learned stable and temporal coherent feature spaces for point based super-resolution. CaSPR (Rempe et al., 2020) learns to encode spatio-temporal changes in object shape from point clouds for reconstruction and camera pose estimation. In this paper, we propose a point based convolution to model raw point cloud sequences in a spatio-temporally hierarchical manner.
+
+# 3 PROPOSED POINT SPATIO-TEMPORAL CONVOLUTIONAL NETWORK
+
+In this section, we first briefly review the grid based 3D convolution operation as our point spatiotemporal (PST) convolution is motivated by it. Then, we introduce how the proposed PST convolution extracts features from dynamic point clouds in detail. In order to address dense point prediction tasks, i.e., semantic segmentation, we develop a PST transposed convolution. Finally, we incorporate our operations into deep hierarchical networks to address different dynamic point cloud tasks.
+
+# 3.1 MOTIVATION FROM GRID BASED 3D CONVOLUTION
+
+The power of convolutional neural network (CNNs) comes from local structure modeling by convolutions and global representation learning via hierarchical architectures. Given an input feature map $\pmb { \mathsf { F } } \in \mathbb { R } ^ { C \times \mathbf { \breve { L } } \times H \times W }$ , where $C , L , H$ and $W$ denote the input feature dimension, length, height and width, 3D convolution is designed to capture the spatio-temporal local structure of $\boldsymbol { \mathsf { F } }$ , written as:
+
+$$
+\pmb { \mathsf { F } } _ { t } ^ { \prime ( x , y ) } = \sum _ { k = - \lfloor l / 2 \rfloor } ^ { \lfloor l / 2 \rfloor } \sum _ { i = - \lfloor h / 2 \rfloor } ^ { \lfloor h / 2 \rfloor } \sum _ { j = - \lfloor w / 2 \rfloor } ^ { \lfloor w / 2 \rfloor } \pmb { \mathsf { W } } _ { k } ^ { ( i , j ) } \cdot \pmb { \mathsf { F } } _ { t + k } ^ { ( x + i , y + j ) } ,
+$$
+
+where $\pmb { \mathsf { W } } \in \mathbb { R } ^ { C ^ { \prime } \times C \times l \times h \times w }$ is the convolution kernel, $( l , h , w )$ is the kernel size, $C ^ { \prime }$ represents the output feature dimension and $\cdot$ is matrix multiplication. The $\boldsymbol { \mathsf { W } } _ { k } ^ { ( i , j ) } \in \mathbb { R } ^ { C ^ { \prime } \times C }$ denotes the weight at kernel position $( k , i , j )$ and $\bar { \mathsf { F } } _ { t + k } ^ { ( x + i , y + j ) } \in \mathbb { R } ^ { C \times 1 }$ denotes the feature of pixel at input position $( t + k , x + i , y + j )$ . Usually, CNNs employ small kernel sizes, e.g., $( 3 , 3 , 3 )$ , which are much smaller than the input size, to effectively model the local structure. To construct hierarchical CNNs, stride $( > 1 )$ is used to subsample input feature maps during the convolution operation. In this fashion, following convolutional layers will have relatively larger receptive fields.
+
+# 3.2 POINT SPATIO-TEMPORAL (PST) CONVOLUTION
+
+Let $P _ { t } \in \mathbb { R } ^ { 3 \times N }$ and $\pmb { F } _ { t } \in \mathbb { R } ^ { C \times N }$ denote the point coordinates and features of the $t$ -th frame in a point cloud sequence, where $N$ and $C$ denote the number of points and feature channels, respectively. Given a point cloud sequence $\left( [ P _ { 1 } ; F _ { 1 } ] , [ P _ { 2 } ; F _ { 2 } ] , \cdot \cdot \cdot , [ P _ { L } ; { \bar { F } } _ { L } ] \right)$ , the proposed PST convolution will encode the sequence to $\left( [ P _ { 1 } ^ { \prime } ; F _ { 1 } ^ { \prime } ] , [ P _ { 2 } ^ { \prime } ; F _ { 2 } ^ { \prime } ] , \cdot \cdot \cdot , [ P _ { L ^ { \prime } } ^ { \prime } ; F _ { L ^ { \prime } } ^ { \prime } ] \right)$ , where $L$ and $L ^ { \prime }$ indicate the number of frames, and $P _ { t } ^ { \prime } \in \mathbb { R } ^ { 3 \times N ^ { \prime } }$ and $\pmb { F } _ { t } ^ { \prime } \in \mathbb { R } ^ { C ^ { \prime } \times N ^ { \prime } }$ represent the encoded coordinates and features.
+
+# 3.2.1 DECOMPOSING SPACE AND TIME IN POINT CLOUD SEQUENCE MODELING
+
+Because point clouds are irregular and unordered, grid based 3D convolution cannot be directly applied to point cloud sequences. As point cloud sequences are spatially irregular and unordered but temporally ordered, this motivates us to decouple these two dimensions in order to reduce the impacts of the spatial irregularity of points on temporal modeling. Moreover, the scales of spatial displacements and temporal differences in point cloud sequences may not be compatible. Treating them equally is not conducive for network optimization. By decoupling the spatio-temporal information in point cloud sequences, we not only make the spatio-temporal modeling easier but also significantly improve the ability to capture the temporal information. Therefore, our PST convolution is formulated as:
+
+$$
+\begin{array} { r l } & { \pmb { F } _ { t } ^ { \prime ( x , y , z ) } = \displaystyle \sum _ { k = - \lfloor l / 2 \rfloor } ^ { \lfloor l / 2 \rfloor } \quad \displaystyle \sum _ { \| ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \| \leq r } \mathbf { W } _ { k } ^ { ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) } \cdot \pmb { F } _ { t + k } ^ { ( x + \delta _ { x } , y + \delta _ { y } , z + \delta _ { z } ) } , } \\ & { = \displaystyle \sum _ { k = - \lfloor l / 2 \rfloor } ^ { \lfloor l / 2 \rfloor } \quad \displaystyle \sum _ { \| ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \| \leq r } \mathbf { T } _ { k } ^ { ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) } \cdot \big ( \pmb { \ S } _ { k } ^ { ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) } \cdot \pmb { F } _ { t + k } ^ { ( x + \delta _ { x } , y + \delta _ { y } , z + \delta _ { z } ) } \big ) , } \end{array}
+$$
+
+where $( x , y , z ) \in P _ { t }$ , $( \delta _ { x } , \delta _ { y } , \delta _ { z } )$ represents displacement and $r$ is spatial search radius. The convolution kernel $\pmb { \mathsf { W } } \in \mathbb { R } ^ { C ^ { \prime } \times C \times l } \times \mathbb { R }$ is decomposed into a spatial convolution kernel $\pmb { \mathsf { S } } \in \mathbb { R } ^ { C _ { m } \times C \times l } \times \mathbb { R }$ and a temporal convolution kernel $\mathbf { T } \in \bar { \mathbb { R } ^ { C ^ { \prime } \times C _ { m } \times l } } \times \bar { \mathbb { R } }$ and $C _ { m }$ is the dimension of the intermediate feature. Moreover, because space and time are orthogonal and independent of each other, we further decompose spatial and temporal modeling as:
+
+$$
+\pmb { F } _ { t } ^ { \prime ( x , y , z ) } = \sum _ { k = - \lfloor l / 2 \rfloor } ^ { \lfloor l / 2 \rfloor } \pmb { \mathsf { T } } _ { k } \cdot \sum _ { \parallel ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \parallel \leq r } \pmb { \mathsf { S } } ^ { ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) } \cdot \pmb { F } _ { t + k } ^ { ( x + \delta _ { x } , y + \delta _ { y } , z + \delta _ { z } ) } ,
+$$
+
+where $\pmb { \mathsf { S } } \in \mathbb { R } ^ { C _ { m } \times C } \times \mathbb { R }$ and $\pmb { \mathsf { T } } \in \mathbb { R } ^ { C ^ { \prime } \times C _ { m } \times l }$ . The above decomposition can also be expressed as applying temporal convolution first and then spatial convolution to input features. However, doing so requires point tracking to capture point motion. Because it is difficult to achieve accurate point trajectory and tracking points usually relies on point colors and may fail to handle colorless point clouds, we opt to model the spatial structure of irregular points first, and then capture the temporal information from the spatial regions. In this fashion, Eq. (3) can be rewritten as:
+
+$$
+M _ { t } ^ { ( x , y , z ) } = \sum _ { \substack { \| ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \| \leq r } } \mathbb { S } ^ { ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) } \cdot F _ { t } ^ { ( x + \delta _ { x } , y + \delta _ { y } , z + \delta _ { z } ) } , \quad F _ { t } ^ { \prime ( x , y , z ) } = \sum _ { k = - \lfloor l / 2 \rfloor } ^ { \lfloor l / 2 \rfloor } \mathsf { T } _ { k } \cdot M _ { t + k } ^ { ( x , y , z ) } .
+$$
+
+The spatial convolution captures spatial local structures of point clouds in 3D space, while the temporal convolution aims to describe the temporal local dynamics of point cloud sequences along the time dimension. In order to capture the distributions of neighboring points, it is required to learn a convolution kernel $\boldsymbol { \mathsf { s } }$ for all displacements. However, this is impossible because point displacements are not discrete. To address this problem, we convert the kernel to a function of displacements, defined as:
+
+$$
+M _ { t } ^ { ( x , y , z ) } = \sum _ { \| ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \| \leq r } f \big ( ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) ; \theta \big ) \cdot F _ { t } ^ { ( x + \delta _ { x } , y + \delta _ { y } , z + \delta _ { z } ) } ,
+$$
+
+where $f : \mathbb { R } ^ { 1 \times 3 }  \mathbb { R } ^ { C _ { m } \times C }$ is a function of $( \delta _ { x } , \delta _ { y } , \delta _ { z } )$ parametrized by $\pmb { \theta }$ to generate different $\mathbb { R } ^ { C _ { m } \times C }$ according to different displacements. There can be many ways to implement the $f$ function. In principle, the $f$ function should be both computation-efficient and memory-efficient so that PST convolution is able to encode long sequences. Existing static point cloud convolution methods (Li et al., 2018b; Wu et al., 2019; Wang et al., 2019) usually contains multilayer perceptrons (MLPs), which are computation and memory consuming. In this paper, we design a lightweight implementation for $f$ , which contains only a few parameters. Specifically, we further decompose the $f$ function as $f \big ( ( \mathring { \delta } _ { x } , \delta _ { y } , \delta _ { z } ) ; \pmb \theta \big ) = \pmb \theta _ { d } \cdot \mathring { ( } \delta _ { x } , \delta _ { y } , \mathring { \delta } _ { z } ) ^ { T } \cdot { \bf 1 } \odot \pmb \theta _ { s }$ , where $\pmb { \theta } \overset { ^ { \bullet } } { = } [ \pmb { \theta } _ { d } , \pmb { \theta } _ { s } ] , \pmb { \theta } _ { d } \in \mathbb { R } ^ { C _ { m } \times 3 }$ is a displacement transform kernel, $\pmb { \theta } _ { s } \in \mathbb { R } ^ { C _ { m } \times C }$ is a sharing kernel, $\mathbf { 1 } = ( 1 , \cdots , 1 ) \in \mathbb { R } ^ { 1 \times C }$ is for broadcasting, and $\odot$ is element-wise product. The sharing kernel $\theta _ { s }$ is to increase point feature dimension to improve the feature representation ability. The displacement kernel $\theta _ { d }$ is to capture spatial local structure based on displacements. In this fashion, $f$ generates a unique spatial kernel for each displacement so that the lightweight spatial convolution is able to increase feature dimension while capturing spatial local structure like conventional convolutions.
+
+![](images/7580ebd1b2a866d6c1d04489c89ab794907a8524d30018ade979d4b07dc13968.jpg)  
+Figure 2: Illustration of the proposed point spatio-temporal (PST) convolution. The input contains $L = 5$ frames, with $N = 8$ points per frame. (a) Based on the temporal kernel size $l = 3$ , temporal stride $s _ { t } = 2$ , and temporal padding $p = 1$ , the 1st, 3rd, 5th frames are selected as temporal anchor frames. According to a spatial subsampling rate $s _ { s } = 4$ , 2 spatial anchor points are sampled by FPS in each anchor frame. The sampled anchor points are then transferred to the $\lfloor \frac { l } { 2 } \rfloor = 1$ nearest neighboring frames. A point tube is constructed with a spatial search radius $r$ for the anchor points. (b) The spatial convolution encodes the local structure around each anchor point. (c) The temporal convolution encodes the $l$ spatial features to a spatio-temporal feature. The original $L \times N = 5 \times 8$ sequence is encoded as a $L ^ { \bar { \prime } } \times N ^ { \prime } = 3 \times 2$ sequence.
+
+# 3.2.2 POINT TUBE
+
+Grid based 3D convolutions can be easily performed on regular conventional videos by sliding along the length, height and width. Because point cloud sequences are irregular and unordered in 3D space and emerge inconsistently across different frames, it is challenging to perform convolution on them. To address this problem, we introduce a point tube to preserve the spatio-temporal local structure. In contrast to pixel cubes in 3D convolution, in which pixels are distributed regularly, point tubes are dynamically generated based on the input sequences so that dense areas have more tubes than sparse ones. Specifically, the point tube is constructed as follows:
+
+Temporal anchor frame selection. For an entire sequence of point clouds, we need to select some anchor frames to generate our tubes. Temporal anchor frames in a point cloud sequence are automatically selected based on temporal kernel size $( l )$ , temporal stride $\left( { { s } _ { t } } \right)$ and temporal padding $( p )$ , where $l$ is set to an odd number so that an anchor frame is located in the middle of a point tube. Moreover, we set $\left\lfloor { \frac { l } { 2 } } \right\rfloor \geq p$ to avoid selecting a padding frame as an anchor frame.
+
+Spatial anchor point sampling. Once a temporal anchor frame is selected, we need to choose spatial anchor points that can represent the distribution of all the points in the frame. Given a spatial subsampling rate $s _ { s }$ , this operation aims to subsample $N$ points to $\begin{array} { r } { N ^ { \prime } = \left\lfloor \frac { N } { s _ { s } } \right\rfloor } \end{array}$ points. We employ the farthest point sampling (FPS) (Qi et al., 2017b) to sample points in each anchor frame. Point tubes are generated according to sampled anchor points.
+
+Transferring spatial anchor points. 3D convolutions can effectively capture local changes within a cube of a kernel size $( l , h , w )$ rather than tracking a specific pixel. Following this idea, we propagate the positions of sampled anchor points to the neighboring frames without tracking, and they are regarded as the anchor points in those frames. Specifically, each anchor point is transferred to the $\lfloor \frac { l } { 2 } \rfloor$ nearest frames. The original and transferred anchor points form the central axis of a tube.
+
+Spatial neighbor. This step aims to find the spatial neighbors of every anchor point in each frame for performing spatial convolution. As indicated in Eq. (5), radius neighborhood $r$ is used to search neighbors within the tube slice, where local structure of points is depicted. Note that, padding is usually used in grid based convolution to align feature maps. However, our point based spatial convolution is not conducted on grids and thus spatial padding is not employed.
+
+By performing PST convolution on point tubes, our network is able to capture the dynamic changes in local areas. The temporal kernel size $l$ and spatial search radius $r$ allow our PST convolution to capture temporal and spatial local structure, respectively. Frame subsampling (according to $s _ { t }$ ) and point subsampling (according to $s _ { s }$ ) make our PSTNet be both temporally and spatially hierarchical. Global movement can be summarized by merging the information from these tubes in a spatio-temporally hierarchical manner. An illustration of PST convolution is shown in Fig. 2.
+
+# 3.3 POINT SPATIO-TEMPORAL TRANSPOSED CONVOLUTION
+
+After PST convolution, the original point cloud sequence is both spatially and temporally subsampled. However, for point-level prediction tasks, we need to provide point features for all the original points. Thus, we develop a PST transposed convolution. Suppose $\left( [ \hat { P _ { 1 } ^ { \prime } } ; F _ { 1 } ^ { \prime } ] , [ P _ { 2 } ^ { \prime } ; F _ { 2 } ^ { \prime } ] , \cdot \cdot \cdot , [ P _ { L ^ { \prime } } ^ { \prime } ; \mathbf { \bar { \boldsymbol { F } } } _ { L ^ { \prime } } ^ { \prime } ] \right)$ is the encoded sequence of the original one $\left( [ P _ { 1 } ; F _ { 1 } ] , [ P _ { 2 } ; F _ { 2 } ] , \cdot \cdot \cdot , [ P _ { L } ; F _ { L } ] \right)$ . PST transposed convolution propagates features $( F _ { 1 } ^ { \prime } , F _ { 2 } ^ { \prime } , \cdots , \dot { F } _ { L ^ { \prime } } ^ { \prime } )$ to the original point coordinates $( P _ { 1 } , P _ { 2 } , \cdots , P _ { L } )$ , thus outputting new features $( F _ { 1 } ^ { \prime \prime } , F _ { 2 } ^ { \prime \prime } , \cdots , F _ { L } ^ { \prime \prime } )$ , where $\pmb { F } _ { t } ^ { \prime \prime } \in \mathbb { R } ^ { C ^ { \prime \prime } \times N }$ and $C ^ { \prime \prime }$ denotes the new feature dimension. To this end, PST transposed convolution first recovers the temporal length by a temporal transposed convolution:
+
+$$
+\boldsymbol { \mathsf { T } } ^ { \prime } \cdot \boldsymbol { F ^ { \prime } } _ { t } ^ { ( x , y , z ) } = \left[ M _ { t - \lfloor l / 2 \rfloor } ^ { \prime ( x , y , z ) } , \cdot \cdot \cdot , M _ { t + \lfloor l / 2 \rfloor } ^ { \prime ( x , y , z ) } \right] ,
+$$
+
+where $\boldsymbol { \mathsf { T } } ^ { \prime } \in \mathbb { R } ^ { l \times C _ { m } ^ { \prime } \times C ^ { \prime } }$ is the temporal transposed convolution kernel, and then increases the number of points by assigning temporal features to original points. Inspired by (Qi et al., 2017b), the interpolated features are weighted by inverse distance between an original point and neighboring anchor points:
+
+$$
+F _ { t } ^ { \prime \prime ( x , y , z ) } = S ^ { \prime } \cdot \frac { \sum _ { \parallel ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \parallel \leq r } w ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) M _ { t } ^ { \prime ( x + \delta _ { x } , y + \delta _ { y } , z + \delta _ { z } ) } } { \sum _ { \parallel ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \parallel \leq r } w ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) } , w ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) = \frac { 1 } { \parallel ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \parallel ^ { 2 } } ,
+$$
+
+where $S ^ { \prime } \in \mathbb { R } ^ { C ^ { \prime \prime } \times C _ { m } ^ { \prime } }$ is a sharing kernel to enhance the interpolated features and change the feature dimension from $C _ { m } ^ { \prime }$ to $C ^ { \prime \prime }$ . An illustration of PST transposed convolution is shown in Appendix A.
+
+# 3.4 PSTNET ARCHITECTURES
+
+PSTNet for 3D action recognition. We employ 6 PST convolution layers and a fully-connected (FC) layer for 3D action recognition. In the 1st, 2nd, 4th, 6th layers, the spatial subsampling rate is set to 2 to halve the spatial resolution. Because point clouds are irregular and unordered, spatial receptive fields cannot be relatively enlarged by spatial subsampling. To address this problem, we progressively increase the spatial search radius. In the 2nd and 4th layers, the temporal stride is set to 2 to halve the temporal resolution. In the 2-4 layers, the temporal kernel size is set to 3 to capture temporal correlation. Temporal paddings are added when necessary. After the convolution layers, average and max poolings are used for spatial pooling and temporal pooling, respectively. Finally, the FC layer maps the global feature to action predictions.
+
+PSTNet for 4D semantic segmentation. We use 4 PST convolution layers and 4 PST transposed convolution layers for 4D semantic segmentation. The spatial subsampling rate is set to 4 to reduce the spatial resolution in the 1-3 PST convolutions and 2 in the fourth PST convolution. Similar to 3D action recognition, the spatial search radius progressively increases to grow spatial receptive fields along the network layers. In the 3rd PST convolution and 2nd transposed convolution, the temporal kernel size is set to 3 to reduce and increase temporal dimension, respectively. Skip connections are added between the corresponding convolution layers and transposed convolution layers. After the last PST transposed convolution layer, a 1D convolution layer is appended for semantic predictions.
+
+In addition, batch normalization and ReLU activation are inserted between PST convolution and transposed convolution layers. Our PSTNet architectures are illustrated in Appendix B.
+
+# 4 EXPERIMENTS
+
+# 4.1 3D ACTION RECOGNITION
+
+To show the effectiveness in sequence-level classification, we apply PSTNet to 3D action recognition. Following (Liu et al., 2019e; Wang et al., 2020), we sample 2,048 points for each frame. Point
+
+Table 1: Action recognition accuracy $( \% )$ on the MSR-Action3D dataset.   
+
+<table><tr><td>Method</td><td>Input</td><td>#Frames</td><td>Accuracy</td></tr><tr><td>Vieira et al. (Vieira et al., 2012)</td><td>depth</td><td>20</td><td>78.20</td></tr><tr><td>Kläser et al. (Kläser et al., 2008)</td><td>depth</td><td>18</td><td>81.43</td></tr><tr><td>Actionlet (Wang et al., 2012)</td><td>skeleton</td><td>all</td><td>88.21</td></tr><tr><td>PointNet++ (Qi et al., 2017b)</td><td>point</td><td>1</td><td>61.61</td></tr><tr><td rowspan="5">MeteorNet (Liu et al.,2019e)</td><td rowspan="5">point</td><td>4</td><td>78.11</td></tr><tr><td>8</td><td>81.14</td></tr><tr><td>12</td><td>86.53</td></tr><tr><td>16</td><td>88.21</td></tr><tr><td>24</td><td>88.50</td></tr><tr><td rowspan="5">PSTNet (ours)</td><td rowspan="5">point</td><td>4</td><td>81.14</td></tr><tr><td>8</td><td>83.50</td></tr><tr><td>12</td><td>87.88</td></tr><tr><td>16</td><td>89.90</td></tr><tr><td>24</td><td>91.20</td></tr></table>
+
+![](images/056587546c9353e604d860c193bdd1268dc4bd985b086e5957f7b934d2023f59.jpg)  
+Figure 3: Influence of temporal kernel size and (initial) spatial search radius on MSR-Action3D with 24 frames.
+
+![](images/517e380ebd89f860d513ab4018f92d67c887b6dddee146f1b4dfb95b62bb59cb.jpg)  
+Figure 4: Visualization of PST convolution’s output. Top: input point cloud sequences, where color encodes depth. Bottom: output of PST convolution, where brighter color indicates higher activation. Interestingly, PST convolution outputs high activation to salient motion. Best viewed in color.
+
+cloud sequences are split into multiple clips (with a fixed number of frames) as inputs. For training, sequence-level labels are used as clip-level labels. For evaluation, the mean of the clip-level predicted probabilities is used as the sequence-level prediction. Point colors are not used.
+
+# 4.1.1 MSR-ACTION3D
+
+The MSR-Action3D (Li et al., 2010) dataset consists of 567 Kinect depth videos, with 20 action categories and 23K frames in total. We use the same training/test split as previous works (Wang et al., 2012; Liu et al., 2019e). We conduct experiments with 10 times and report the mean.
+
+Comparison with the state-of-the-art. We compare our PSTNet with skeleton-based, depth-based and point-based 3D action recognition methods on this dataset. As shown in Table 1, the proposed PSTNet significantly outperforms all the state-of-the-art methods, demonstrating the superiority of our PST convolution on feature extraction. Moreover, when encoding long point sequences, our spatio-temporally hierarchical PSTNet is more effective than the spatially hierarchical MeteorNet. Specifically, from 16 frames to 24 frames, MeteorNet only achieves a slight improvement of $0 . 2 9 \%$ , while our method increases the accuracy by $1 . 3 0 \%$ .
+
+What does PST convolution learn? To investigate what PST convolution learns, we visualize the output of the middle layer (i.e., the 3rd layer) in Fig. 4. As ReLU is employed as the activation function, larger values indicate higher activation. As expected, PSTNet outputs higher activation on moving areas, demonstrating that our PSTNet captures the most informative clues in action reasoning.
+
+# 4.1.2 NTU RGB $^ +$ D 60 AND NTU RGB+D 120
+
+The NTU RGB $+ \mathrm { D } 6 0$ (Shahroudy et al., 2016) is the second largest dataset for 3D action recognition. It consists of 56K videos, with 60 action categories and 4M frames in total. The videos are captured using Kinect v2, with 3 cameras and 40 subjects (performers). The dataset defines two types of evaluation, i.e., cross-subject and cross-view. The cross-subject evaluation splits the 40 performers into training and test groups. Each group consists of 20 performers. The cross-view evaluation uses all the samples from camera 1 for testing and samples from cameras 2 and 3 for training.
+
+Table 2: Action recognition accuracy $( \% )$ on the NTU $\mathrm { R G B + D }$ 60 and NTU $\mathrm { R G B + D }$ 120 datasets.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Input</td><td colspan="2">NTU RGB+D 60</td><td colspan="2">NTU RGB+D 120</td></tr><tr><td>Subject</td><td>View</td><td>Subject</td><td>Setup</td></tr><tr><td>SkeleMotion (Caetano et al., 2019)</td><td>skeleton</td><td>69.6</td><td>80.1</td><td>67.7</td><td>66.9</td></tr><tr><td>GCA-LSTM (Liu et al., 2017)</td><td>skeleton</td><td>74.4</td><td>82.8</td><td>58.3</td><td>59.3</td></tr><tr><td>FSNet (Liu et al., 2019b)</td><td>skeleton</td><td>-</td><td>-</td><td>59.9</td><td>62.4</td></tr><tr><td>Two Stream Attention LSTM (Liu et al.,2018)</td><td>skeleton</td><td>77.1</td><td>85.1</td><td>61.2</td><td>63.3</td></tr><tr><td>Body Pose Evolution Map (Liu &amp; Yuan,2018)</td><td>skeleton</td><td>=</td><td>=</td><td>64.6</td><td>66.9</td></tr><tr><td>AGC-LSTM (Si et al., 2019)</td><td>skeleton</td><td>89.2</td><td>95.0</td><td>1</td><td>-</td></tr><tr><td>AS-GCN (Li et al., 2019)</td><td>skeleton</td><td>86.8</td><td>94.2</td><td>1</td><td>=</td></tr><tr><td>VA-fusion (Zhang et al., 2019)</td><td>skeleton</td><td>89.4</td><td>95.0</td><td>=</td><td></td></tr><tr><td>2s-AGCN (Shi et al., 2019b)</td><td>skeleton</td><td>88.5</td><td>95.1</td><td></td><td></td></tr><tr><td>DGNN (Shi et al., 2019a)</td><td>skeleton</td><td>89.9</td><td>96.1</td><td></td><td></td></tr><tr><td>HON4D (Oreifej &amp; Liu, 2013)</td><td>depth</td><td>30.6</td><td>7.3</td><td></td><td></td></tr><tr><td>SNV (Yang &amp; Tian, 2014)</td><td>depth</td><td>31.8</td><td>13.6</td><td></td><td></td></tr><tr><td>HOG² (Ohn-Bar &amp; Trivedi,2013)</td><td>depth</td><td>32.2</td><td>22.3</td><td></td><td></td></tr><tr><td>Li et al. (2018a)</td><td>depth</td><td>68.1</td><td>83.4</td><td></td><td></td></tr><tr><td>Wang et al. (2018)</td><td>depth</td><td>87.1</td><td>84.2</td><td></td><td></td></tr><tr><td>MVDI (Xiao et al., 2019)</td><td>depth</td><td>84.6</td><td>87.3</td><td>=</td><td></td></tr><tr><td>NTU RGB+D 120 Baseline (Liu et al., 2019a)</td><td>depth</td><td>-</td><td>1</td><td>48.7</td><td>40.1</td></tr><tr><td>PointNet++ (appearance) (Qi et al., 2017b)</td><td>point</td><td>80.1</td><td>85.1</td><td>72.1</td><td>79.4</td></tr><tr><td>3DV (motion) (Wang et al., 2020)</td><td>voxel</td><td>84.5</td><td>95.4</td><td>76.9</td><td>92.5</td></tr><tr><td>3DV-PointNet++ (Wang et al., 2020)</td><td>voxel + point</td><td>88.8</td><td>96.3</td><td>82.4</td><td>93.5</td></tr><tr><td>PSTNet (ours)</td><td>point</td><td>90.5</td><td>96.5</td><td>87.0</td><td>93.8</td></tr></table>
+
+The NTU $\mathrm { R G B + D }$ 120 (Liu et al., 2019a) dataset, the largest dataset for 3D action recognition, is an extension of NTU $\mathrm { R G B + D \ 6 0 }$ . It consists of 114K videos, with 120 action categories and 8M frames in total. The videos are captured with 106 performers and 32 collection setups (locations and backgrounds). Besides cross-subject evaluation, the dataset defines a new evaluation setting, i.e., cross-setup, where 16 setups are used for training, and the others are used for testing.
+
+Comparison with state-of-the-art methods. As indicated in Table 2, PSTNet outperforms all the other approaches in all evaluation settings. Particularly, as indicated by the cross-setup evaluation on NTU RGB $+ \mathbf { D }$ 120, PSTNet outperforms the second best 3DV-PointNet $^ { + + }$ (Wang et al., 2020) by $4 . 6 \%$ . Moreover, compared to 3DV that extracts motion from voxels, PSTNet directly models the dynamic information of raw point cloud sequences and thus is efficient.
+
+Computational efficiency. We provide a running time comparison with the second best 3DVPointNet $^ { + + }$ (Wang et al., 2020). The average running time per video is shown in Fig. 5. Experiments are conducted using 1 Nvidia RTX 2080Ti GPU on NTU $\mathrm { R G B + D } 6$ 0. Impressively, compared to 3DV-PointNet++, PSTNet reduces running time by about 2s, showing that PSTNet is efficient.
+
+# 4.2 4D SEMANTIC SEGMENTATION
+
+To demonstrate that our PST convolution can be generalized to point-level dense prediction tasks, we apply PSTNet to 4D semantic segmentation. Following the works (Choy et al., 2019; Liu et al., 2019e), we conduct experiments on video clips with length of 3 frames. Note that, although semantic segmentation can be achieved from a single frame, exploring temporal consistency would facilitate exploring the structure of scenes, thus improving segmentation accuracy and robustness to noise. The widely-used standard mean Intersection over Union (mIoU) is adopted as the evaluation metric.
+
+Synthia 4D (Choy et al., 2019) uses the Synthia dataset (Ros et al., 2016) to create 3D video sequences. The Synthia 4D dataset includes 6 sequences of driving scenarios. Each sequence consists of 4 stereo
+
+Table 3: Semantic segmentation results on the Synthia 4D dataset.   
+
+<table><tr><td>Method</td><td>Input #Frms #Params (M) mIoU (%)</td><td></td><td></td></tr><tr><td>3D MinkNet14 (Choy et al., 2019) </td><td>）voxel</td><td>19.31</td><td>76.24</td></tr><tr><td>4D MinkNet14 (Choy et al., 2019) </td><td>）voxel 3</td><td>23.72</td><td>77.46</td></tr><tr><td>PointNet++ (Qi et al., 2017b)</td><td>point</td><td>0.88</td><td>79.35</td></tr><tr><td>MeteorNet (Liu et al.,2019e)</td><td>point</td><td>1.78</td><td>81.80</td></tr><tr><td>PSTNet (l = 1)</td><td>point</td><td>1.42</td><td>80.79</td></tr><tr><td>PSTNet (l = 3)</td><td>point</td><td>1.67</td><td>82.24</td></tr></table>
+
+![](images/ed152babc343fb0d6494e538270c268e76dbe0e4ba77078250b4b668beb58e4d.jpg)  
+Figure 5: Comparison of recognition running time per video on NTU $\mathrm { R G B } { + } \mathrm { D } 6$ 0.
+
+RGB-D images taken from the top of a moving car. Following (Liu et al., 2019e), we use the same training/validation/test split, with 19,888/815/1,886 frames, respectively.
+
+As seen in Table 3, PSTNet $\mathit { l } = 3$ ) exploits the temporal information and outperforms the state-ofthe-art. Moreover, our method saves 0.11M, relative $6 \%$ of parameters compared to the second best method MeteorNet (Liu et al., 2019e). We visualize a few segmentation examples in Appendix N.
+
+# 4.3 ABLATION STUDY
+
+Clip length. Usually, information is not equally distributed in sequences along time. Short point cloud clips may miss key frames and thus confuse the models as noise. Therefore, as shown in Table 1, increasing clip length (i.e., the number of frames) benefits models for action recognition.
+
+Temporal kernel size. The temporal kernel size $l$ controls the temporal dynamics modeling of point cloud sequences. Fig. 3(a) shows the accuracy on MSR-Action3D with different $l$ . (a) When $l$ is set to 1, temporal correlation is not captured. However, PSTNet can still observe 24 frames and the pooling operation allows PSTNet to capture the pose information of an entire clip. Moreover, some actions (e.g., “golf swing”) can be easily recognized by a certain pose, and thus PSTNet with $l = 1$ can still achieve satisfied accuracy. (b) When $l$ is greater than 1, PSTNet models temporal dynamics and therefore improves accuracy on actions that rely on motion or trajectory reasoning (e.g., “draw $\mathbf { X } ^ { \prime \prime }$ , “draw tick” and “draw circle”). (c) When $l$ is greater than 3, the accuracy decreases. This mainly depends on motion in sequences. Because most actions in MSR-Action3D are fast (e.g., “high arm wave”), using smaller temporal kernel size facilitates capturing fast motion, and long-range temporal dependencies will be captured in high-level layers. Since we aim to present generic point based convolution operations, we do not tune the kernel size for each action but use the same size. When PSTNet is used in 4D semantic segmentation, we observe that PSTNet $( l = 3$ ) improves mIoU by $1 . 4 5 \%$ compared to PSTNet $( l = 1 )$ ) that neglects temporal structure (shown in Table 3).
+
+Spatial search radius. The spatial search radius $r$ controls the range of the spatial structure to be modeled. As shown in Fig. 3(b), using too small $r$ cannot capture sufficient structure information while using large $r$ will decrease the discriminativeness of spatial local structure for modeling.
+
+# 5 CONCLUSION
+
+In this paper, we propose an point spatio-temporal (PST) convolution to learn informative representations from raw point cloud sequences and a PST transposed convolution for point-level dense prediction tasks. We demonstrate that, by incorporating the proposed convolutions into deep networks, dubbed PSTNets, our method is competent to address various point-based tasks. Extensive experiments demonstrate that our PSTNet significantly improves the 3D action recognition and 4D semantic segmentation performance by effectively modeling point cloud sequences.
+
+# ACKNOWLEDGMENTS
+
+This research is supported by the Agency for Science, Technology and Research (A\*STAR) under its AME Programmatic Funding Scheme (#A18A2b0046).
+
+# REFERENCES
+
+Paul J. Besl and Neil D. McKay. A method for registration of 3-d shapes. IEEE Trans. Pattern Anal. Mach. Intell., 14(2):239–256, 1992. doi: 10.1109/34.121791.
+
+Carlos Caetano, Jessica Sena de Souza, Franc¸ois Bremond, Jefersson A. dos Santos, and William Rob- ´ son Schwartz. Skelemotion: A new representation of skeleton joint sequences based on motion information for 3d action recognition. In 16th IEEE International Conference on Advanced Video and Signal Based Surveillance, AVSS, 2019.
+
+Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? A new model and the kinetics ˜ dataset. In CVPR, 2017.
+
+Xiaozhi Chen, Huimin Ma, Ji Wan, Bo Li, and Tian Xia. Multi-view 3d object detection network for autonomous driving. In CVPR, 2017.
+
+Christopher B. Choy, JunYoung Gwak, and Silvio Savarese. 4d spatio-temporal convnets: Minkowski convolutional neural networks. In CVPR, 2019.
+
+Angela Dai, Angel X. Chang, Manolis Savva, Maciej Halber, Thomas A. Funkhouser, and Matthias Nießner. Scannet: Richly-annotated 3d reconstructions of indoor scenes. In CVPR, 2017.
+
+Hehe Fan and Yi Yang. PointRNN: Point recurrent neural network for moving point cloud processing. arXiv, 1910.08287, 2019.
+
+Hehe Fan, Xiaojun Chang, De Cheng, Yi Yang, Dong Xu, and Alexander G. Hauptmann. Complex event detection by identifying reliable shots from untrimmed videos. In ICCV, 2017.
+
+Hehe Fan, Zhongwen Xu, Linchao Zhu, Chenggang Yan, Jianjun Ge, and Yi Yang. Watching a small portion could be as good as watching all: Towards efficient video classification. In IJCAI, 2018.
+
+Hehe Fan, Yi Yang, and Mohan S. Kankanhalli. Point 4d transformer networks for spatio-temporal modeling in point cloud videos. In CVPR, 2021a.
+
+Hehe Fan, Tao Zhuo, Xin Yu, Yi Yang, and Mohan S. Kankanhalli. Understanding atomic hand-object interaction with human intention. IEEE Transactions on Circuits and Systems for Video Technology (TCSVT), 2021b. doi: 10.1109/TCSVT.2021.3058688.
+
+Kensho Hara, Hirokatsu Kataoka, and Yutaka Satoh. Can spatiotemporal 3d cnns retrace the history of 2d cnns and imagenet? In CVPR, 2018.
+
+Alexander Klaser, Marcin Marszalek, and Cordelia Schmid. A spatio-temporal descriptor based on ¨ 3d-gradients. In BMVC, 2008.
+
+Junnan Li, Yongkang Wong, Qi Zhao, and Mohan S. Kankanhalli. Unsupervised learning of viewinvariant action representations. In NeurIPS, 2018a.
+
+Maosen Li, Siheng Chen, Xu Chen, Ya Zhang, Yanfeng Wang, and Qi Tian. Actional-structural graph convolutional networks for skeleton-based action recognition. In CVPR, 2019.
+
+Wanqing Li, Zhengyou Zhang, and Zicheng Liu. Action recognition based on a bag of 3d points. In CVPR Workshops, 2010.
+
+Yangyan Li, Rui Bu, Mingchao Sun, Wei Wu, Xinhan Di, and Baoquan Chen. Pointcnn: Convolution on $\mathbf { X }$ -transformed points. In NeurIPS, 2018b.
+
+Jun Liu, Gang Wang, Ping Hu, Ling-Yu Duan, and Alex C. Kot. Global context-aware attention LSTM networks for 3d action recognition. In CVPR, 2017.
+
+Jun Liu, Gang Wang, Ling-Yu Duan, Kamila Abdiyeva, and Alex C. Kot. Skeleton-based human action recognition with global context-aware attention LSTM networks. IEEE Trans. Image Processing, 27(4):1586–1599, 2018. doi: 10.1109/TIP.2017.2785279.
+
+Jun Liu, Amir Shahroudy, Mauricio Perez, Gang Wang, Ling-Yu Duan, and Alex C. Kot. Ntu rgb+d 120: A large-scale benchmark for 3d human activity understanding. IEEE Trans. Pattern Anal. Mach. Intell., 2019a. doi: 10.1109/TPAMI.2019.2916873.
+
+Jun Liu, Amir Shahroudy, Gang Wang, Ling-Yu Duan, and Alex C. Kot. Skeleton-based online action prediction using scale selection network. IEEE Trans. Pattern Anal. Mach. Intell., 2019b. doi: 10.1109/TPAMI.2019.2898954.
+
+Lu Liu, Tianyi Zhou, Guodong Long, Jing Jiang, Lina Yao, and Chengqi Zhang. Prototype propagation networks (PPN) for weakly-supervised few-shot learning on category graph. In IJCAI, 2019c.
+
+Lu Liu, William Hamilton, Guodong Long, Jing Jiang, and Hugo Larochelle. A universal representation transformer layer for few-shot image classification. In ICLR, 2021.
+
+Mengyuan Liu and Junsong Yuan. Recognizing human actions as the evolution of pose estimation maps. In CVPR, 2018.
+
+Xingyu Liu, Charles R. Qi, and Leonidas J. Guibas. Flownet3d: Learning scene flow in 3d point clouds. In CVPR, 2019d.
+
+Xingyu Liu, Mengyuan Yan, and Jeannette Bohg. Meteornet: Deep learning on dynamic 3d point cloud sequences. In ICCV, 2019e.
+
+Yanbin Liu, Juho Lee, Minseop Park, Saehoon Kim, Eunho Yang, Sung Ju Hwang, and Yi Yang. Learning to propagate labels: Transductive propagation network for few-shot learning. In ICLR, 2019f.
+
+Wenjie Luo, Bin Yang, and Raquel Urtasun. Fast and furious: Real time end-to-end 3d detection, tracking and motion forecasting with a single convolutional net. In CVPR, 2018.
+
+Joe Yue-Hei Ng, Matthew J. Hausknecht, Sudheendra Vijayanarasimhan, Oriol Vinyals, Rajat Monga, and George Toderici. Beyond short snippets: Deep networks for video classification. In CVPR, 2015.
+
+Michael Niemeyer, Lars M. Mescheder, Michael Oechsle, and Andreas Geiger. Occupancy flow: 4d reconstruction by learning particle dynamics. In ICCV, 2019.
+
+Eshed Ohn-Bar and Mohan M. Trivedi. Joint angles similarities and HOG2 for action recognition. In CVPR Workshops, 2013.
+
+Omar Oreifej and Zicheng Liu. HON4D: histogram of oriented 4d normals for activity recognition from depth sequences. In CVPR, 2013.
+
+Lukas Prantl, Nuttapong Chentanez, Stefan Jeschke, and Nils Thuerey. Tranquil clouds: Neural networks for learning temporally coherent features in point clouds. In ICLR, 2020.
+
+Charles Ruizhongtai Qi, Hao Su, Kaichun Mo, and Leonidas J. Guibas. Pointnet: Deep learning on point sets for 3d classification and segmentation. In CVPR, 2017a.
+
+Charles Ruizhongtai Qi, Li Yi, Hao Su, and Leonidas J. Guibas. Pointnet++: Deep hierarchical feature learning on point sets in a metric space. In NeurIPS, 2017b.
+
+Charles Ruizhongtai Qi, Or Litany, Kaiming He, and Leonidas J. Guibas. Deep hough voting for 3d object detection in point clouds. In ICCV, 2019.
+
+Davis Rempe, Tolga Birdal, Yongheng Zhao, Zan Gojcic, Srinath Sridhar, and Leonidas J. Guibas. Caspr: Learning canonical spatiotemporal point cloud representations. In NeurIPS, 2020.
+
+German Ros, Laura Sellart, Joanna Materzynska, David V ´ azquez, and Antonio M. L ´ opez. The ´ SYNTHIA dataset: A large collection of synthetic images for semantic segmentation of urban scenes. In CVPR, 2016.
+
+Amir Shahroudy, Jun Liu, Tian-Tsong Ng, and Gang Wang. NTU RGB+D: A large scale dataset for 3d human activity analysis. In CVPR, 2016.
+
+Lei Shi, Yifan Zhang, Jian Cheng, and Hanqing Lu. Skeleton-based action recognition with directed graph neural networks. In CVPR, 2019a.
+
+Lei Shi, Yifan Zhang, Jian Cheng, and Hanqing Lu. Two-stream adaptive graph convolutional networks for skeleton-based action recognition. In CVPR, 2019b.
+
+Chenyang Si, Wentao Chen, Wei Wang, Liang Wang, and Tieniu Tan. An attention enhanced graph convolutional LSTM network for skeleton-based action recognition. In CVPR, 2019.
+
+Karen Simonyan and Andrew Zisserman. Two-stream convolutional networks for action recognition in videos. In NeurIPS, 2014.
+
+Hugues Thomas, Charles Ruizhongtai Qi, Jean-Emmanuel Deschaud, Beatriz Marcotegui, Franc¸ois Goulette, and Leonidas J. Guibas. Kpconv: Flexible and deformable convolution for point clouds. In ICCV, 2019.
+
+Du Tran, Lubomir D. Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. Learning spatiotemporal features with 3d convolutional networks. In ICCV, 2015.
+
+Du Tran, Heng Wang, Lorenzo Torresani, Jamie Ray, Yann LeCun, and Manohar Paluri. A closer look at spatiotemporal convolutions for action recognition. In CVPR, 2018.
+
+Antonio Wilson Vieira, Erickson R. Nascimento, Gabriel L. Oliveira, Zicheng Liu, and Mario ˆ Fernando Montenegro Campos. STOP: space-time occupancy patterns for 3d action recognition from depth map sequences. In Progress in Pattern Recognition, Image Analysis, Computer Vision, and Applications - 17th Iberoamerican Congress, CIARP, 2012.
+
+Jiang Wang, Zicheng Liu, Ying Wu, and Junsong Yuan. Mining actionlet ensemble for action recognition with depth cameras. In CVPR, 2012.
+
+Limin Wang, Yuanjun Xiong, Zhe Wang, Yu Qiao, Dahua Lin, Xiaoou Tang, and Luc Van Gool. Temporal segment networks: Towards good practices for deep action recognition. In ECCV, 2016.
+
+Pichao Wang, Wanqing Li, Zhimin Gao, Chang Tang, and Philip O. Ogunbona. Depth pooling based large-scale 3-d action recognition with convolutional neural networks. IEEE Trans. Multimedia, 20(5):1051–1061, 2018. doi: 10.1109/TMM.2018.2818329.
+
+Yancheng Wang, Yang Xiao, Fu Xiong, Wenxiang Jiang, Zhiguo Cao, Joey Tianyi Zhou, and Junsong Yuan. 3dv: 3d dynamic voxel for action recognition in depth video. In CVPR, 2020.
+
+Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E. Sarma, Michael M. Bronstein, and Justin M. Solomon. Dynamic graph CNN for learning on point clouds. ACM Trans. Graph., 38(5):146:1–146:12, 2019. doi: 10.1145/3326362.
+
+Wenxuan Wu, Zhongang Qi, and Fuxin Li. Pointconv: Deep convolutional networks on 3d point clouds. In CVPR, 2019.
+
+Yang Xiao, Jun Chen, Yancheng Wang, Zhiguo Cao, Joey Tianyi Zhou, and Xiang Bai. Action recognition for depth video using multi-view dynamic images. Inf. Sci., 480:287–304, 2019. doi: 10.1016/j.ins.2018.12.050.
+
+Xiaodong Yang and Yingli Tian. Super normal vector for activity recognition using depth sequences. In CVPR, 2014.
+
+Lequan Yu, Xianzhi Li, Chi-Wing Fu, Daniel Cohen-Or, and Pheng-Ann Heng. Pu-net: Point cloud upsampling network. In CVPR, 2018.
+
+Pengfei Zhang, Cuiling Lan, Junliang Xing, Wenjun Zeng, Jianru Xue, and Nanning Zheng. View adaptive neural networks for high performance skeleton-based human action recognition. IEEE Trans. Pattern Anal. Mach. Intell., 41(8):1963–1978, 2019. doi: 10.1109/TPAMI.2019.2896631.
+
+Linchao Zhu and Yi Yang. Label independent memory for semi-supervised few-shot video classification. IEEE Trans. Pattern Anal. Mach. Intell., 2020. doi: 10.1109/TPAMI.2020.3007511.
+
+Tao Zhuo, Zhiyong Cheng, Peng Zhang, Yongkang Wong, and Mohan S. Kankanhalli. Explainable video action reasoning via prior knowledge and state transitions. In ACM Multimedia, 2019.
+
+# A PST TRANSPOSED CONVOLUTION
+
+![](images/460365afe9d0e329b49b6da03325c520f2912bbef1c4881bd4d3a26a27aeab8f.jpg)  
+Figure 6: Illustration of the proposed PST transposed convolution. The input contains $L ^ { \prime } = 3$ frames, with $N ^ { \prime } = 2$ points per frame. The PST transposed convolution is to generate new original point features for the original point cloud sequence, which contains $L = 5$ frames, with $N = 8$ points per frame. The temporal kernel size $l$ is 3 and the temporal stride is $s _ { t }$ is 2. (a) Temporal transposed convolution. (b) Temporal interpolation. (c) Spatial interpolation.
+
+We illustrate an example of PST transposed convolution in Fig. 6. Given a convolved sequence $\left( [ P _ { 1 } ^ { \prime } ; F _ { 1 } ^ { \prime } ] , [ P _ { 2 } ^ { \prime } ; F _ { 2 } ^ { \prime } ] , [ \bar { P _ { 3 ^ { \prime } } ^ { \prime } } ; F _ { 3 ^ { \prime } } ^ { \prime } ] \right)$ , and its original coordinate sequence $\left( P _ { 1 } , P _ { 2 } , P _ { 3 } , P _ { 4 } , P _ { 5 } \right)$ , PST transposed convolution aims to generate new features $( F _ { 1 } ^ { \prime \prime } , F _ { 2 } ^ { \prime \prime } , F _ { 3 } ^ { \prime \prime } , F _ { 4 } ^ { \prime \prime } , F _ { 5 } ^ { \prime \prime } )$ according to the original point coordinates. First, with the temporal kernel size $l = 3$ , each input point feature is decoded to 3 features by a temporal transposed convolution. Second, 5 frames are interpolated in accordance with a temporal stride $s _ { t } = 2$ , and the input points with the decoded features are assigned to interpolated frames. In this way, the temporal cross-correlation is constructed. Third, given the original coordinates of a point cloud frame $( e . g . , P _ { 1 } )$ and the corresponding interpolated frame (i.e., $[ { \tilde { P _ { 1 } ^ { \prime } } } ; [ { M ^ { \prime } } _ { 1 } ^ { a } , { M ^ { \prime } } _ { 1 } ^ { b } ] ] )$ , we generate features (i.e., ${ \cal F } _ { 1 } ^ { \prime \prime }$ ) for all the original point coordinates.
+
+# B PSTNET ARCHITECTURES
+
+# B.1 PSTNET FOR 3D ACTION RECOGNITION
+
+![](images/f00760e2f8eac7b2d1f6c4c1dd5fa968773e0729457ad2963f5acba3b282c112.jpg)  
+Figure 7: Hierarchical PSTNet architecture for 3D action recognition.
+
+As shown in Fig. 7, the architecture of PSTNet for 3D action recognition consists of 6 PST convolutions, i.e., PSTConv1, PSTConv2a, PSTConv2b, PSTConv3a, PSTConv3b, PSTConv4, and a fully-connected (FC) layer. In PSTConv1, PSTConv2a, PSTConv3a and PSTConv4, the spatial subsampling rate is set to 2 to halve the spatial resolution. In PSTConv2a and PSTConv3a, the temporal stride is set to 2 to halve the temporal resolution. The $r _ { o }$ denotes the initial spatial search radius. The temporal padding $p$ is split as $[ p _ { 1 } , p _ { 2 } ]$ , where $p _ { 1 }$ and $p _ { 2 }$ denote the left padding and the right padding, respectively. After these convolution layers, average and max poolings are used for spatial pooling and temporal pooling, respectively. The FC layer is then used as a classifier.
+
+# B.2 PSTNET FOR 4D SEMANTIC SEGMENTATION
+
+![](images/553ddb674c10eb5d0b5cf200168a0a619e8b9eb3d4bfdc1f553bde98cf427e4c.jpg)  
+Figure 8: Hierarchical PSTNet architecture for 4D semantic segmentation.
+
+As shown in Fig. 8, we employ 4 PST convolutional layers, i.e., PSTConv1, PSTConv2, PSTConv3, and PSTConv4, and 4 PST transposed convolutional layers, i.e., PSTConvTrans1, PSTConvTrans2, PSTConvTrans3, and PSTConvTrans4 for 4D Semantic Segmentation. The spatial subsampling rate is set to 4 to reduce the spatial resolution in each PST convolution layer. Following (Choy et al., 2019; Liu et al., 2019e), we conduct 4D semantic segmentation on clips with the length of 3 frames, i.e., $L$ is fixed to 3. In PSTConv3 and PSTConvTrans2, the temporal kernel size is set to 3. Skip connections are added from input to PSTConvTrans1, PSTConv1 to PSTConvTrans2, PSTConv2 to PSTConvTrans3, and PSTConv3 to PSTConvTrans4. After PSTConvTrans4, a 1D convolution layer is appended for semantic predictions.
+
+# C IMPLEMENTATION DETAILS
+
+To build a unified network and train the network with mini-batch, the number of spatial neighbors needs to be fixed. We follow existing point based works (Qi et al., 2017b; Liu et al., 2019e) to randomly sample a fixed number of neighbors. For 3D action recognition, the number is set to 9. For 4D semantic segmentation, we follow (Liu et al., 2019e) to set the number to 32. If the actual number of neighbors of a point is less than the set one (e.g., 9), we randomly repeat some neighbors.
+
+We train our models for 35 epochs with the SGD optimizer. Learning rate is set to 0.01, and decays with a rate of 0.1 at the 10th epoch and the 20th epoch, respectively.
+
+MSR-Action3D (Li et al., 2010): Following (Liu et al., 2019e), batch size is set to 16 and frame sampling stride are set to and 1, respectively. We set the initial spatial search radius $r _ { o }$ to 0.5.
+
+NTU $\mathrm { R G B } { + } \mathrm { D } 6 0 / 1 2 0$ (Shahroudy et al., 2016; Liu et al., 2019a): Following (Wang et al., 2020), batch size is set to 32. We set the clip length, frame sampling stride and the initial spatial search radius $r _ { o }$ to 23, 2 and 0.1, respectively.
+
+Synthia 4D (Choy et al., 2019): Following (Liu et al., 2019e), batch size and frame sampling stride are set to 12 and 1, respectively. We set the spatial search radius $r _ { o }$ to 0.9.
+
+We have implemented our PSTNets using both PyTorch and PaddlePaddle, which have shown similar performance.
+
+# D INFLUENCE OF TEMPORAL KERNEL SIZE ON DIFFERENT ACTIONS
+
+We show the influence of temporal kernel size on different actions in MSR-Action3D in Fig. 9. Clip length is 24.
+
+When temporal kernel size $l = 1$ , temporal correlation is not exploited. However, PSTNet can leverage pose information for recognition, especially for actions whose poses are unique in the dataset. For example, PSTNet with $l = 1$ can correctly recognize the “jogging” action because the action’s pose is discriminative in the MSR-Action3D dataset. However, PSTNet with motion modeling $\left( l \geq 3 \right)$ ) can distinguish similar actions such as “draw x”, “draw tick” and “draw circle”. The results support our intuition that PSTNet effectively captures dynamics in point cloud sequences.
+
+![](images/d99770ee545c74c33a490b8964e6c9d712ad4f07d1fba13fd58663f101dee701.jpg)  
+Figure 9: Influence of temporal kernel size on different actions of MSR-Action3D.
+
+# E FEATURE VISUALIZATION
+
+![](images/c908a1e92cd399b6bcd2c508a4583c96e1c012c5e9ffae95529bc3114aa14afd.jpg)  
+Figure 10: Feature visualizations on MSR-Action3D using t-SNE. Each sequence is visualized as a point and sequences belonging to the same action have the same color. PSTNet features are semantically separable compared to MeteorNet, suggesting that it learns better representations for point cloud sequences.
+
+We qualitatively evaluate PSTNet’s ability to encode point cloud sequence by visualizing the learned features. We compare PSTNet with the sate-of-the-art MeteorNet (Liu et al., 2019e). Features are extracted from the layer before classifier (FC). These features are then projected to 2-dimensional space using t-SNE. As shown in Fig. 10, PSTNet feature is more compact and discriminative than MeteorNet.
+
+# F SYNTHIA 4D SEMANTIC SEGMENTATION RESULT DETAILS
+
+We list the segmentation result for each class in Table 4. The Synthia 4D dataset contains 12 categories.   
+Our PSTNet achieves five best accuracies among them, demonstrating the effectiveness of PSTNet.
+
+Table 4: Semantic segmentation result (mIoU $\%$ ) details on the Synthia 4D dataset.   
+
+<table><tr><td>Method</td><td>|#Frames|Bldn Road Sdwlk Fence Vegittn PoleCarT.Sign Pedstrn Bicycl Lane T.Light|Average</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>3D MinkNet14 (Choy et al.,2019)|</td><td>1</td><td>|89.39 97.68 69.43 86.52 98.11 97.26 93.50 79.45</td><td></td><td></td><td></td><td>92.27</td><td></td><td>0.00 44.61</td><td>66.69</td><td>76.24</td></tr><tr><td>4D MinkNet14 (Choy et al., 2019)</td><td></td><td>90.13 98.26 73.47 87.19 99.10 97.50 94.01 79.04</td><td></td><td></td><td></td><td>92.62</td><td>0.00</td><td>50.01</td><td>68.14</td><td>77.46</td></tr><tr><td>PointNet++ (Qi et al.,2017b)</td><td>1</td><td>96.88 97.72 86.20 92.75 97.12 97.09 90.85</td><td></td><td></td><td>66.87</td><td>78.64</td><td>0.00</td><td>72.93</td><td>75.17</td><td>79.35</td></tr><tr><td>MeteorNet (Liu et al.,2019e)</td><td>3</td><td>98.10 97.72 88.65 94.00</td><td>97.98</td><td>97.65 93.83</td><td>84.07</td><td>80.90</td><td>0.00</td><td>71.14</td><td>77.60</td><td>81.80</td></tr><tr><td>PSTNet (l =1)</td><td>3</td><td>96.32 98.07 85.40 94.66 97.16 97.51 94.83 76.65</td><td></td><td></td><td></td><td>76.99</td><td>0.00</td><td>75.39</td><td>76.45</td><td>80.79</td></tr><tr><td>PSTNet (l = 3)</td><td>3</td><td>96.91 98.33 90.83 95.00 96.96 97.61 95.15 77.45</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>85.68</td><td>0.00</td><td>75.71</td><td>77.28</td><td>82.24</td></tr></table>
+
+# G PST CONVOLUTION WITHOUT DISENTANGLING SPACE AND TIME
+
+To confirm the effectiveness of our disentangling structure for spatio-temporal modeling, we perform 3D action recognition on MSR-Action3D with non-decomposing convolution. To combine space and time, 3D displacements and time differences are encoded together to generate convolution kernel. We evaluate our PSTNet with different clip lengths. As shown in Fig. 11, the disentangling PST convolution achieves better accuracy than the non-decomposing structure, demonstrating the effectiveness of disentangling space and time for point cloud sequence modeling.
+
+![](images/9d7eb7003180c52e2db42603baca3b1c264820fe2c4b6b6bf573a848f92deb79.jpg)  
+Figure 11: Comparison of PST convolution with (w/) and without (w/o) disentangling structure on MSR-Action3D.
+
+H IMPACT OF DISPLACEMENT KERNEL AND SHARING KERNEL
+
+In this paper, we design a lightweight implementation for the $f$ function in Eq. (5), i.e., $f \big ( ( \delta _ { x } , \delta _ { y } , \hat { \delta } _ { z } ) ; \pmb \theta \big ) = \pmb \theta _ { d } \cdot ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) ^ { T } \cdot { \bf 1 } \odot \pmb \theta _ { s } ^ { \circ } ,$ , where $\theta _ { d }$ is a displacement transform kernel, $\theta _ { s }$ is a sharing kernel. In this section, we investigate the influence of these two kernels. We conduct 3D action recognition on MSR-Action3D. The experimental results are shown in Table 5.
+
+Table 5: Impact of displacement kernel and sharing kernel on 3D action recognition accuracy $( \% )$ The MSR-Action3D dataset is used.   
+
+<table><tr><td>0d</td><td>0s</td><td>16-frame</td><td>24-frame</td></tr><tr><td>√</td><td></td><td>58.25</td><td>61.67</td></tr><tr><td></td><td></td><td>86.35</td><td>87.46</td></tr><tr><td>√</td><td>?</td><td>89.90</td><td>91.20</td></tr></table>
+
+Without In this $\theta _ { s }$ , the spatial convolution degenerates into y, only the points in the final layer of o $\begin{array} { r } { M _ { t } ^ { ( x , y , z ) } = \sum _ { \parallel ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \parallel \leq r } \pmb { \theta } _ { d } \cdot ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) ^ { T } } \end{array}$ decreases dramatically.
+
+Without $\theta _ { d }$ , the spatial convolution becomes $\begin{array} { r } { M _ { t } ^ { ( x , y , z ) } = \sum _ { \parallel ( \delta _ { x } , \delta _ { y } , \delta _ { z } ) \parallel \leq r } \pmb { \theta } _ { s } \cdot \pmb { F } _ { t } ^ { ( x + \delta _ { x } , y + \delta _ { y } , z + \delta _ { z } ) } . } \end{array}$ In this fashion, the points in a neighborhood are treated equally. Point features are leveraged but their positions are ignored. Because spatial structure is not well captured, the accuracy decreases compared to the case where both $\theta _ { d }$ and $\theta _ { s }$ are used.
+
+# I COMPUTATIONAL EFFICIENCY AND MEMORY USAGE
+
+In this section, we evaluate the computational efficiency and memory usage, i.e., the running time and number of parameters, of our method. We conduct 3D action recognition with a clip length of 16 on MSR-Action3D using 1 Nvidia Quadro RTX 6000 GPU.
+
+As shown in Table 6, the proposed PSTNet is $4 1 . 5 \%$ faster than MeteorNet (Liu et al., 2019e). This is because that MeteorNet is based on MLPs, which are less efficient than convolutions.
+
+Table 6: Comparison of parameter and running time on 3D action recognition accuracy $( \% )$ . The MSR-Action3D dataset is used. Clip length is 16.   
+
+<table><tr><td>Method</td><td># Parameters (M) </td><td>Running time per clip (ms） Accuracy (%)</td><td></td></tr><tr><td>MeteorNet (Liu et al., 2019e)</td><td>17.60</td><td>54.56</td><td>88.21</td></tr><tr><td>PSTNet (lightweight)</td><td>8.44</td><td>31.92</td><td>89.90</td></tr><tr><td>PSTNet (with PointConv)</td><td>20.46</td><td>102.72</td><td>90.24</td></tr></table>
+
+Second, we study the impact of the number of PSTNet layers on running time and parameter. As shown in Fig. 12, when PSTNet becomes deep, the number of parameters significantly grows. This is because, like most deep neural networks, the point feature dimension exponentially increases to improve the feature representation ability in PSTNet, which needs more parameters. However, the running time does not increase significantly. This is because our PSTNet is spatio-temporally hierarchical, points are exponentially reduced along both spatial and temporal dimensions, thus saving running time.
+
+![](images/01abf5444e73949535bd3e12f454f3389e4c344d3baf6bb7646960185dfb6f57.jpg)  
+Figure 12: Impact of the number of PSTNet layers on running time and parameter.
+
+![](images/bcad2adc4b1a366716495e3d846f0194554015f76032340c27d084f7d6eb3041.jpg)  
+Figure 13: Running time proportion of main operations in PSTNet.
+
+Third, we investigate the running time of main operations in PSTNet, including convolution, farthest point sampling and spatial neighbor search. We show the running time proportion of these operations in Fig. 13.
+
+Finally, because the $f$ function in Eq. (5) can be implemented in different ways, we replace our lightweight spatial convolution with PointConv (Wu et al., 2019) to investigate the influence of the spatial modeling in our PSTNet. As shown in Table 6, using PointConv only improves accraucy slightly compared to our lightweight spatial convolutions, but significantly increases parameters and running time. This is because PointConv utilizes MLP based operations to process points and their features, which are less efficient than our lightweight convolutions.
+
+# J IRREGULAR FRAME SAMPLING
+
+Our PSTNet can also process irregularly sampled point cloud sequences by frame interpolation. In this section, we randomly remove some frames in sequences. Specifically, we conduct 3D action recognition on MSR-Action with 24 frames. We randomly remove 8 frames from each clip. Then, we use replication and Iterative Closest Point (ICP) (Besl & McKay, 1992) to interpolate missing frames, respectively. We compare our PSTNet with MeteorNet (Liu et al., 2019e), which explicitly encodes time and does not need interpolation.
+
+Table 7: 3D action recognition on MSR-Action3D with irregularly sampled frames. Clip length is originally 24 and then 8 frames are randomly removed from each clip.   
+
+<table><tr><td>Method</td><td>Accuracy (%)</td></tr><tr><td>MeteorNet (Liu et al., 2019e)</td><td>88.40</td></tr><tr><td>PSTNet (replication interpolation)</td><td>90.24</td></tr><tr><td>PSTNet (ICP interpolation)</td><td>90.94</td></tr></table>
+
+As shown in Table 7, our PSTNet still achieves the best accuracy, indicating that PSTNet is able to model point cloud sequences with irregular frame sampling.
+
+# K SCENE FLOW ESTIMATION
+
+To evaluate our method on the LiDAR data where points in a frame can be highly irregular, we apply our method to scene flow estimation. We follow the setting proposed by MeteorNet (Liu et al., 2019e), i.e., given a point cloud sequence, estimating a flow vector for every point in the last frame. However, because our point tube is constructed according to the middle frame, which is not applicable to the last-frame scene flow estimation, we adapt temporal anchor frame selection and spatial anchor point transferring. Specifically, we select the last frame in each tube as the anchor frame. Then, after spatial sampling, each anchor point is transferred to its previous nearest $l$ frames. Following MeteorNet, we first train our model on a FlyingThings3D dataset according to the synthetic method in (Liu et al., 2019e), and then fine-tune the model on a KITTI scene flow dataset (Liu et al., 2019e). Point tracking is not used.
+
+Table 8: Scene flow estimation accuracy on the KITTI scene flow dataset.   
+
+<table><tr><td>Method</td><td>Input</td><td>#Frames</td><td>End-Point-Error</td></tr><tr><td>FlowNet3D (Liu et al., 2019d)</td><td>points</td><td>2</td><td>0.287</td></tr><tr><td>MeteorNet (Liu et al., 2019e)</td><td>points</td><td>3</td><td>0.282</td></tr><tr><td>PSTNet (ours)</td><td>points</td><td>3</td><td>0.278</td></tr></table>
+
+As shown in Table 8, our PSTNet achieves promising accuracy on scene flow estimation.
+
+# L MOTION RECOGNITION ON THE SYNTHETIC MOVING MNIST POINT CLOUD DATASET
+
+In the real world, it is impossible to obtain point IDs. To evaluate our PSTNet in the scenario where points are correlated and can be accurately tracked across frames, we conduct motion recognition on a synthetic Moving MNIST Point Cloud dataset. To synthesize moving MNIST digit sequences, we use a generation process similar to that described in (Fan & Yang, 2019). Each synthetic sequence consists of 16 consecutive point cloud frames. Each frame contains one handwritten digit moving and bouncing inside a $6 4 \times 6 4$ area. The digits are chosen randomly from the MNIST dataset. We use the same training/test split as the original MNIST dataset. For each digit, we sample 128 points. Point order is maintained across frames so that tracking can be employed. We design 144 motions, including
+
+• nine initial locations: $( 1 , 1 ) , ( 1 , 3 ) , ( 1 , 5 ) , ( 3 , 1 ) , ( 3 , 3 ) , ( 3 , 5 ) , ( 5 , 1 ) , ( 5 , 3 ) , ( 5 , 5 ) .$ • eight velocities: $( 1 , 1 ) , ( - 1 , 1 ) , ( - 1 , - 1 ) , ( 1 , - 1 ) , ( 2 , 2 ) , ( - 2 , 2 ) , ( - 2 , - 2 ) , ( 2 , - 2 ) .$ • two kinds of digit distortion: scaling digits horizontally or vertically, i.e., $( | 0 . 4 - 0 . 0 5 t | +$ $0 . 6 ) \times ( x - c _ { x } ) + c _ { x }$ or $( | 0 . 4 - 0 . 0 5 t | + 0 . 6 ) \times ( y - c _ { y } ) + c _ { y }$ , where $\left( c _ { x } , c _ { y } \right)$ is the digit center and $t \in [ 1 , 1 6 ]$ .
+
+A few motion examples are shown in Fig. 14. Because motion and appearance are independent of each other, it is challenging to recognize motion while avoiding interference from digit appearance.
+
+![](images/7ad33305b11d63b6b96a2031dbcaa799a5d603b98fe220e16c66b391d8c977ff.jpg)  
+Figure 14: Motion examples in the synthetic Moving MNIST Point Cloud dataset.
+
+To exploit point correlation, anchor points and their neighbors are selected in the first frame, which are then propagated to other frames. In this fashion, anchors and their neighbors are tracked across frames.
+
+Table 9: Motion recognition accuracy on the Moving MNIST Point Cloud dataset.   
+
+<table><tr><td>Method</td><td>Accuracy (%)</td></tr><tr><td>PSTNet (original)</td><td>97.15</td></tr><tr><td>PSTNet (with tracking)</td><td>98.74</td></tr></table>
+
+As shown in Table 9, both the original PSTNet and the tracking based PSTNet achieve promising accuracy on the Moving MNIST Point Cloud dataset. Our original PSTNet achieves similar accuracy with the tracking based PSTNet in this simulated case, demonstrating that our PSTNet does not heavily rely on point IDs or tracking.
+
+# M VISUALIZATION OF THE OUTPUT OF EACH PST CONVOLUTION LAYER IN PSTNET
+
+We visualize the output of each layer in the PSTNet architecture trained on MSR-Action3D in Fig. 15. Because we use ReLU as the activation function, all outputs are greater than zero and large outputs indicate high activation. To visualize outputs, we squeeze output vectors to scalars via $l _ { 1 }$ norm. We observe that:
+
+• For PSTConv1, because temporal kernel size $l = 1$ , it does not capture the temporal correlation. In this case, PSTConv1 focuses on the appearance and therefore outputs high activation to performer contours.   
+• PSTConv2a to PSTConv4. When modeling the spatio-temporal structure of point cloud sequence, PST convolutions mainly focus on moving areas so as to achieve informative representations of actions.
+
+The visualization results support our intuition that the proposed PST convolution effectively captures dynamics of point cloud sequences.
+
+# N VISUALIZATION OF 4D SEMANTIC SEGMENTATION
+
+We visualize segmentation results from the Synthia 4D dataset in Fig. 16 and Fig. 17. Our PSTNet can accurately segment most objects.
+
+# O LIMITATION
+
+Like most deep neural networks, the proposed PSTNet relies on large-scale labeled datasets for training. A potential improvement is to integrate some learning methods, e.g., few-shot learning (Liu et al., 2019c;f; Zhu & Yang, 2020; Liu et al., 2021), into point cloud sequences modeling to reduce the reliance on human-annotated data.
+
+![](images/8bf5c6a1ef4e2a5c85e7dd7d774b0d4abfac5f8f390185990f4ed4449055214f.jpg)
+
+![](images/e19c993349a6f4bb45750420b42f213918b60013a3b892249cfa353ff58af3a7.jpg)  
+Figure 16: Visualization of semantic segmentation examples from Synthia 4D (I). Top: inputs. Middle: ground truth. Bottom: PSTNet predictions.
+
+![](images/cd3e15b9255a5a4a0c9968d2534be151a3d94a66c915c27712a74e0c58b547c1.jpg)  
+Figure 17: Visualization of semantic segmentation examples from Synthia 4D (II). Top: inputs. Middle: ground truth. Bottom: PSTNet predictions.

parse/train/Skeke3C5Fm/Skeke3C5Fm.md

@@ -0,0 +1,289 @@
+# MULTILINGUAL NEURAL MACHINE TRANSLATION WITH SOFT DECOUPLED ENCODING
+
+Xinyi Wang1, Hieu Pham1,2, Philip Arthur3, and Graham Neubig1
+
+1Language Technology Institute, Carnegie Mellon University, Pittsburgh, PA 15213, USA 2Google Brain, Mountain View, CA 94043, USA   
+3Monash University, Clayton VIC 3800, Australia   
+{xinyiw1,hyhieu,gneubig}@cs.cmu.edu,philip.arthur@monash.edu
+
+# ABSTRACT
+
+Multilingual training of neural machine translation (NMT) systems has led to impressive accuracy improvements on low-resource languages. However, there are still significant challenges in efficiently learning word representations in the face of paucity of data. In this paper, we propose Soft Decoupled Encoding (SDE), a multilingual lexicon encoding framework specifically designed to share lexicallevel information intelligently without requiring heuristic preprocessing such as pre-segmenting the data. SDE represents a word by its spelling through a character encoding, and its semantic meaning through a latent embedding space shared by all languages. Experiments on a standard dataset of four low-resource languages show consistent improvements over strong multilingual NMT baselines, with gains of up to 2 BLEU on one of the tested languages, achieving the new state-of-the-art on all four language pairs1.
+
+# 1 INTRODUCTION
+
+Multilingual Neural Machine Translation (NMT) has shown great potential both in creating parameter-efficient MT systems for many languages (Johnson et al., 2016), and in improving translation quality of low-resource languages (Zoph et al., 2016; Firat et al., 2016; Gu et al., 2018; Neubig & Hu, 2018; Nguyen & Chiang, 2018). Despite the success of multilingual NMT, it remains a research question how to represent the words from multiple languages in a way that is both parameter efficient and conducive to cross-lingual generalization. The standard sequence-to-sequence (seq2seq) NMT model (Sutskever et al., 2014) represents each lexical unit by a vector from a look-up table, making it difficult to share across different languages with limited lexicon overlap. This problem is particularly salient when translating low-resource languages, where there is not sufficient data to fully train the word embeddings.
+
+Several methods have been proposed to alleviate this data sparsity problem in multilingual lexical representation. The current de-facto standard method is to use subword units (Sennrich et al., 2016; Kudo, 2018), which split up longer words into shorter subwords to allow for generalization across morphological variants or compounds (e.g. “un/decide/d” or “sub/word”). These can be applied to the concatenated multilingual data, producing a shared vocabulary for different languages, resulting in sharing some but not all subwords of similarly spelled words (such as “traduccion” in Spanish and ´ “traduc¸ao” in Portuguese, which share the root “tradu-”). However, subword-based preprocessing ˜ can produce sub-optimal segmentations for multilingual data, with semantically identical and similarly spelled languages being split into different granularities (e.g. “traduccion” and “tradu/c¸ ´ ao”) ˜ leading to disconnect in the resulting representations. This problem is especially salient when the high-resource language dominates the training data (see empirical results in Section 4).
+
+In this paper, we propose Soft Decoupled Encoding (SDE), a multilingual lexicon representation framework that obviates the need for segmentation by representing words on a full-word level, but can nonetheless share parameters intelligently, aiding generalization. Specifically, SDE softly decouples the traditional word embedding into two interacting components: one component represents how the word is spelled, and the other component represents the word’s latent meaning, which is shared over all languages present at training time. We can view this representation as a decomposition of language-specific realization of the word’s form (i.e. its spelling) and its language-agnostic semantic function. More importantly, our decoupling is done in a soft manner to preserve the interaction between these two components.
+
+![](images/85e9834e246cc102ea4d838dff01ce7b44969cb92c4d5fe67cd4bf15c51a0c1f.jpg)  
+Figure 1: Three steps to compute the lexical representations for the input sequence “a cute puppy”, using various lexical unit segmentations.
+
+SDE has three key components: 1) an encoding of a word using character $n$ -grams (Wieting et al., 2016); 2) a language specific transform for the character encoding; 3) a latent word embedding constructed by using the character encoding to attend to a shared word embedding space, inspired by Gu et al. (2018). Our method can enhance lexical-level transfer through the shared latent word embedding while preserving the model’s capacity to learn specific features for each language. Moreover, it eliminates unknown words without any external preprocessing step such as subword segmentation.
+
+We test SDE on four low-resource languages from a multilingual TED corpus (Qi et al., 2018). Our method shows consistent improvements over multilingual NMT baselines for all four languages, and importantly outperforms previous methods for multilingual NMT that allow for more intelligent parameter sharing but do not use a two-step process of character-level representation and latent meaning representation (Gu et al., 2018). Our method outperforms the best baseline by about 2 BLEU for one of the low-resource languages, achieving new state-of-the-art results on all four language pairs compared to strong multi-lingually trained and adapted baselines (Neubig & Hu, 2018).
+
+# 2 LEXICAL REPRESENTATION FOR MULTILINGUAL NMT
+
+In this section, we first revisit the 3-step process of computing lexical representations for multilingual NMT, which is illustrated in Figure 1. Then, we discuss various design choices for each step, as well as the desiderata of an ideal lexical representation for multilingual NMT.
+
+# 2.1 LEXICAL UNIT SEGMENTATION
+
+The first step to compute the neural representation for a sentence is to segment the sentence into lexical units. There are three popular options with different granularities:
+
+• Word-based method splits an input sequence into words, often based on white spaces or punctuation. This is perhaps the natural choice for lexical unit segmentation. Early work in NMT all employ this method (Sutskever et al., 2014; Bahdanau et al., 2015).
+
+• Character-based method splits an input sequence into characters (Lee et al., 2017).
+
+• Subword-based method splits each word into pieces from a small vocabulary of frequently occurring patterns (Sennrich et al., 2016; Kudo, 2018).
+
+# 2.2 EMBEDDING LOOK-UP
+
+After a sentence is segmented into lexical units, NMT models generally look up embeddings from a dictionary to turn each lexical unit into a high-dimensional vector. In the context of multilingual NMT, the lexical unit segmentation method affects this dictionary in different ways.
+
+In word-based segmentation, since the number of unique words for each language is unbounded, while computer memory is not, previous work, e.g. Sutskever et al. (2014), resorts to a fixed-size vocabulary of the most frequent words, while mapping out-of-vocabulary words to an $\langle { \mathrm { u n k } } \rangle$ token. For multilingual NMT settings, where multiple languages are processed, the number of words mapped to $\langle { \mathrm { u n k } } \rangle$ significantly increases. Moreover, different languages, even related languages, have very few words that have exactly the same spelling, which leads to the same concept being represented by multiple and independent parameters. This disadvantage hurts the translation model’s ability to learn the same concept in multiple languages.
+
+Meanwhile, character-based segmentation can effectively reduce the vocabulary size, while maximizing the potential for parameter sharing between languages with identical or similar character sets. However, character segmentation is based on the strong assumption that neural networks can infer meaningful semantic boundaries and compose characters into meaningful words. This puts a large amount of pressure on neural models, requiring larger model sizes and training data. Additionally, training character-based NMT systems is often slow, due to the longer character sequences (Cherry et al., 2018).
+
+Subword-based segmentation is a middle ground between word and character segmentation. However, in multilingual translation, the subword segmentation can be sub-optimal, as the subwords from high-resource languages, i.e. languages with more training data, might dominate the subword vocabulary, so that the words in low-resource language can be split into extremely small pieces.
+
+Therefore, existing methods for lexical unit segmentation lead to difficulties in building an effective embedding look-up strategy for multilingual NMT.
+
+# 2.3 OPTIONAL ENCODING TRANSFORMATIONS
+
+Most commonly, the embedding vectors looked up from the embedding table are used as the final lexical representation. However, it is also possible to have multiple versions of embeddings for a single lexicon and combine them through operations such as attentional weighted sum (Gu et al., 2018). Without loss of generality, we can assume there is always a transformation applied to the embedding vectors, and models that do not use such a transformation can be treated as using the identity transformation.
+
+# 2.4 DESIDERATA
+
+To efficiently utilize parameters for multilingual NMT, the lexical representation should have two properties. First, for maximal accuracy, the lexical representation should be able to accurately represent words in all of the languages under consideration. Second, for better cross-lingual learning and generalization, such a representation should maximize the sharing of parameters across languages.
+
+These two conflicting objectives are difficult to achieve through existing methods. The most common method of using lookup embeddings can only share information through lexical units that overlap between the languages. Subword segmentation strikes a middle ground, but has many potential problems for multilingual NMT, as already discussed in Section 2.2. Although Gu et al. (2018)’s method of latent encoding increases lexical level parameter sharing, it still relies on subwords as its fundamental units, and thus inherits the previously stated problems of sub-word segmentation. We also find in experiments in Section 4 that it is actually less robust than simple lookup when large monolingual data to pre-train embeddings is not available, which is the case for many low-resourced languages.
+
+Next, in Section 3, we propose a novel lexical representation strategy that achieves both desiderata.
+
+# 3 SOFT DECOUPLED ENCODING
+
+Given the conflict between sharing lexical features and preserving language specific properties, we propose SDE, a general framework to represent lexical units for multilingual NMT. Specifically, following the linguistic concept of the “arbitrariness of the sign” (Chandler, 2007), SDE decomposes the modeling of each word into two stages: (1) modeling the language-specific spelling of the word, and (2) modeling the language-agnostic semantics of the word. This decomposition is based on the need for distinguished treatments between a word’s semantics and its spelling.
+
+Semantic representation is language-agnostic. For example, the English “hello” and the French “bonjour” deliver the same greeting message, which is invariant with respect to the language. SDE shares such semantic representations among languages by querying a list of shared concepts, which are loosely related to the linguistic concept of “sememes” (Greimas, 1983). This design is implemented using an attention mechanism, where the query is the lexical unit representation, and the keys and the values come from an embedding matrix shared among all languages.
+
+Meanwhile, the word spellings are more sophisticated. Here, we identify two important observations about word spellings. First, words in related languages can have similar spellings, e.g. the English word “color” and the French word “coleur”. In order to effectively share parameters among languages, a word spelling model should utilize this fact. Second, and not contradicting the first point, related languages can also exhibit consistent spelling shifts. For instance, “Christopher”, a common name in English, has the spelling “Krystof” in Czech. This necessitates a learnable rule to ˇ convert the spelling representations between such pairs of words in related languages. To account for both points, we use a language-specific transformation on top of a first encoding layer based on character $n$ -grams.
+
+# 3.1 EXISTING METHODS
+
+Before we describe our specific architecture in detail (Section 3.2), given these desiderata discussed above, we summarize the designs of several existing methods for lexical representation and our proposed SDE framework in Table 1. Without a preprocessing step of subword segmentation, SDE can capture the lexical similarities of two
+
+Table 1: Methods for lexical representation in multilingual NMT. joint-Lookup means the lookup table is jointly trained with the whole model. pretrain-Lookup means the lookup table is trained independently on monolingual data.   
+
+<table><tr><td>Method</td><td>Lex Unit</td><td>Embedding</td><td>Encoding</td></tr><tr><td>Johnson et al. (2016)</td><td>Subword</td><td> joint-Lookup</td><td>Identity</td></tr><tr><td>Lee et al. (2017)</td><td>Character</td><td> joint-Lookup</td><td>Identity</td></tr><tr><td>Gu et al. (2018)</td><td>Subword</td><td>pretrain-Lookup</td><td> joint-Lookup + Latent</td></tr><tr><td>Ataman &amp; Federico (2018)</td><td>Word</td><td>character n-gram</td><td>Identity</td></tr><tr><td>SDE</td><td>Word</td><td>character n-gram</td><td>Identity + Latent</td></tr></table>
+
+related languages through the character $n$ -gram embedding while preserving the semantic meaning of lexicons through a shared latent embedding.
+
+# 3.2 DETAILS OF SOFT DECOUPLED ENCODING
+
+![](images/b6cfa999fd5ec2a3b7c413037a0c97ab104e7c23f697bbcbbda8f1ea70dcf02b.jpg)  
+Figure 2: SDE computes the embedding for the word “puppy”. Both character $n$ -grams embeddings and latent semantic embeddings are shared among all languages.
+
+As demonstrated in Figure 2, given a word $w$ in a multilingual corpus from language $L _ { i }$ , SDE constructs the embedding of $w$ in three phases.
+
+Lexical Embedding. We maintain an embedding matrix $\mathbf { W } _ { c } \in \mathbb { R } ^ { C \times D }$ , where $D$ is the embedding dimension and $C$ is the number of $n$ -grams in our vocabulary. Out-of-vocab $n$ -grams are mapped to a designated token $\langle { \mathrm { u n k } } \rangle$ . $\mathbf { W } _ { c }$ is shared among all languages. Following Wieting et al. (2016), for each word $w$ , we first compute the bag of character $n$ -grams of $w$ , denoted by $\boldsymbol { \mathrm { B o N } } ( \boldsymbol { w } )$ , which is a sparse vector whose coordinates are the appearance counts of each character $n$ -gram in $w$ . For instance, the characters $n$ -grams with $n = 1 , 2 , 3 , 4$ of the word “puppy” are shown in Figure 2. We then look up and add the rows of $\mathbf { W } _ { c }$ according to their corresponding counts, and apply a tanh activation function on the result
+
+$$
+c ( w ) = \operatorname { t a n h } ( \mathbf { B o N } ( w ) \cdot \mathbf { W } _ { \mathrm { c } } ) .
+$$
+
+Language-specific Transformation. To account for spelling shifts between languages (c.f. Section 3), we apply an language-specific transformation to normalize away these differences. We use a simple fully-connected layer for this transformation. In particular, for language $L _ { i }$ , we have
+
+$$
+\begin{array} { r } { c _ { i } ( w ) = \operatorname { t a n h } ( c ( w ) \cdot { \bf W } _ { L _ { i } } ) , } \end{array}
+$$
+
+$\mathbf { W } _ { L _ { i } } \in \mathbb { R } ^ { D \times D }$ is the transformation matrix specific to language $L _ { i }$
+
+Latent Semantic Embedding. Finally, to model the shared semantics of words among languages, we employ an embedding matrix $\mathbf { W } _ { s } \in \mathbb { R } ^ { S \times D }$ , where $S$ is the number of core semantic concepts we assume a language can express. Similar to the lexical embedding matrix $\mathbf { W } _ { c }$ , the semantic embedding matrix ${ \mathbf W _ { s } }$ is also shared among all languages.
+
+For each word $w$ , its language-specific embedding $c _ { i } ( w )$ is passed as a query for an attention mechanism (Luong et al., 2015) to compute a weighted sum over the latent embeddings
+
+$$
+e _ { \mathrm { l a t e n t } } ( \boldsymbol { w } ) = \operatorname { S o f t m a x } ( c _ { i } ( \boldsymbol { w } ) \cdot \mathbf { W } _ { s } ^ { \top } ) \cdot \mathbf { W } _ { s } .
+$$
+
+Finally, to ease the optimization of our model, we follow Vaswani et al. (2017) and add the residual connection from $c _ { i } ( w )$ into $e _ { \mathrm { l a t e n t } } ( w )$ , forming the Soft Decoupled Encoding embedding of $w$
+
+$$
+e _ { \mathrm { S D E } } ( w ) = e _ { \mathrm { l a t e n t } } ( w ) + c _ { i } ( w ) .
+$$
+
+# 4 EXPERIMENT
+
+We build upon a standard seq2seq NMT model for all experiments. Except for the experiments in Section 4.6, we run each experiment with 3 different random seeds, and conduct significance tests for the results using the paired bootstrap (Clark et al., 2011).
+
+# 4.1 DATASETS
+
+We use the 58-language-to-English TED corpus for experiments. Following the settings of prior works on multilingual NMT (Neubig & Hu, 2018; Qi et al., 2018), we use three low-resource language datasets: Azerbaijani (aze), Belarusian (bel), Galician (glg) to English, and a slightly higher-resource dataset, namely Slovak (slk) to English. Each lowresource language is paired with a related
+
+<table><tr><td>LRL</td><td>Train</td><td>Dev</td><td>Test</td><td>HRL</td><td>Train</td></tr><tr><td>aze</td><td>5.94k</td><td>671</td><td>903</td><td>tur</td><td>182k</td></tr><tr><td>bel</td><td>4.51k</td><td>248</td><td>664</td><td>rus</td><td>208k</td></tr><tr><td>glg</td><td>10.0k</td><td>682</td><td>1007</td><td>por</td><td>185k</td></tr><tr><td>slk</td><td>61.5k</td><td>2271</td><td>2445</td><td>ces</td><td>103k</td></tr></table>
+
+Table 2: Statistics of our datasets. LRL and HRL mean Low-Resource and High-Resource Language.
+
+high-resource language: Turkish (tur), Russian (rus), Portuguese (por), and Czech (ces) respectively.   
+Table 2 shows the statistics of each dataset.
+
+# 4.2 BASELINES
+
+For the baseline, we use the standard lookup embeddings for three granularities of lexical units: (1) word: with a fixed word vocabulary size of 64,000 for the concatenated bilingual data; (2) subjoint: with BPE of 64,000 merge operations on the concatenated bilingual data; and (3) sub-sep: with BPE separately on both languages, each with 32,000 merge operations, effectively creating a vocabulary of size 64,000. We use all three settings to compare their performances and to build a competitive baselines. We also implement the latent embedding method of Gu et al. (2018). We use 32,000 character $n$ -gram with $n = \{ 1 , 2 , 3 , 4 , 5 \}$ from each language and a latent embedding size of 10,000.
+
+# 4.3 RESULTS
+
+Table 3 presents the results of SDEand of other baselines. For the three baselines using lookup, subsep achieves the best performance for three of the four languages. Sub-joint is worse than sub-sep although it allows complete sharing of lexical units between languages, probably because sub-joint leads to over-segmentation for the low-resource language. Our reimplementation of universal encoder (Gu et al., 2018) does not perform well either, probably because the monolingual embedding is not trained on enough data, or the hyperparamters for their method are harder to tune. Meanwhile, SDE outperforms the best baselines for all four languages, without using subword units or extra monolingual data.
+
+Table 3: BLEU scores on four language pairs. Statistical significance is indicated with $\ast ~ ( p ~ <$ 0.0001) and $\dag \left( p < 0 . 0 5 \right)$ , compared with the best baseline.   
+
+<table><tr><td>Lex Unit</td><td>Model</td><td>aze</td><td>bel</td><td>glg</td><td>slk</td></tr><tr><td>Word</td><td>Lookup</td><td>7.66</td><td>13.03</td><td>28.65</td><td>25.24</td></tr><tr><td>Sub-joint</td><td>Lookup</td><td>9.40</td><td>11.72</td><td>22.67</td><td>24.97</td></tr><tr><td>Sub-sep</td><td>Lookup (Neubig &amp; Hu,2018)2</td><td>10.90</td><td>16.17</td><td>28.10</td><td>28.50</td></tr><tr><td>Sub-sep</td><td>UniEnc (Gu et al., 2018)3</td><td>4.80</td><td>8.13</td><td>14.58</td><td>12.09</td></tr><tr><td>Word</td><td>SDE</td><td>11.82*</td><td>18.71*</td><td>30.30*</td><td>28.77+</td></tr></table>
+
+Table 4: BLEU scores after removing each component from SDE-com. Statistical significance is indicated with $\ast \ ( p \_ { \mathrm { ~ \scriptsize ~ < ~ } }$ 0.0001) and $\dagger$ $( p < 0 . 0 0 5 )$ , compared with the full model in the first row.   
+
+<table><tr><td>Model</td><td>aze</td><td>bel</td><td>glg</td><td>slk</td></tr><tr><td>SDE</td><td>11.82</td><td>18.71</td><td>30.30</td><td>28.77</td></tr><tr><td>-Language Specific Transform</td><td>12.89*</td><td>18.13†</td><td>30.07</td><td>29.16†</td></tr><tr><td>-Latent Semantic Embedding</td><td>7.77*</td><td>15.66*</td><td>29.25*</td><td>28.15*</td></tr><tr><td>-Lexical Embedding</td><td>4.57*</td><td>8.03*</td><td>13.77*</td><td>7.08*</td></tr></table>
+
+![](images/a77f49e7bb56d8677d4f1c6dfc9459a272c6278164233a8f215482462bb57023.jpg)  
+Figure 3: Percentage of words by the edit distance from the matching words in the highresource language.
+
+# 4.4 ABLATION STUDIES
+
+We next ablate various features of SDE by removing each of the three key components, and show the results in Table 4. Removing the latent semantic embedding and lexical embedding consistently harms the performance of the model. The effect of the language specific transformation is smaller and is language dependent. Removing the language specific transformation does not lead to significant difference for glg. However, it leads to a 0.8 gain in BLEU for aze, a 0.3 gain for slk, but about a 0.6 decrease for bel. A further inspection of the four language pairs shows that the language specific transform is more helpful for training on languages with fewer words of the same spelling. To quantify this, we extract bilingual dictionaries of the low-resource languages and their paired high-resource languages, and measure the edit distance between the character strings of the aligned words. We use FastAlign (Dyer et al., 2013) to extract aligned words between the source language and English from the parallel training data, then match the English side of two related languages to get their dictionary. Figure 3 shows the percentage of the word pairs grouped by their edit distance. Among the four languages, bel has the lowest percentage of words that are exactly the same with their corresponding words in the high-resource language (0 edit distance), indicating that the language specific transform is most important for divergent languages.
+
+# 4.5 EFFECT OF SUBWORDS
+
+Although using subwords in NMT can eliminate unknown words and control the vocabulary size, it might not be optimal for languages with rich morphology (Ataman & Federico, 2018). We also show in Table 3 that certain choices when using subwords on multilingual data (e.g. whether to train the segmentation on the concatenated multilingual data or separately) have a large effect on the performance of the model. SDE achieves superior performance without using subwords, so it can avoid the risk of sub-optimal segmentation. Still, we test SDE with subwords to study its effect on our framework. The results are shown in Table 5. We test two methods of using subwords: 1)
+
+<table><tr><td>Lex Unit</td><td>Model</td><td>aze</td><td>bel</td><td>glg</td><td>slk</td></tr><tr><td>Word</td><td>SDE</td><td>11.82</td><td>18.71</td><td>30.30</td><td>28.77</td></tr><tr><td>Sub-sep</td><td>SDE</td><td>12.37t</td><td>16.29*</td><td>28.94*</td><td>28.35t</td></tr><tr><td>Word</td><td>SDE-sub</td><td>12.03</td><td>18.16t</td><td>31.16*</td><td>28.86</td></tr></table>
+
+Table 5: BLEU scores on four language pairs. Statistical significance is indicated with $\ast ~ ( p ~ <$ 0.0001) and $\dag \ ( p < 0 . 0 0 5 )$ , compared with the setting in row 1.
+
+we use sub-sep as lexical units, and encode its lexical representation using the character $n$ -grams of the subwords; 2) we use words as lexical units, but use its subword pieces instead of the character $n$ -grams to construct its lexical representation. We use SDE-sub to indicate the second way of using subwords. When using SDE with sub-sep as lexical units, the performance slightly increases for aze, but decreases for the other three language. Therefore, it is generally better to directly use words as lexical units for SDE. When we use words as lexical units but replace character $n$ -gram with subwords, the performance on two of the languages doesn’t change significantly, while the performance decreases for bel and increases for glg.
+
+We also examine the performance of SDE and the best baseline sub-sep with different vocabulary size and found that SDE is also competitive with a small character $n$ -gram vocabulary of size 8K. Details can be found in Appendix A.2.
+
+# 4.6 TRAINING ON ALL LANGUAGES
+
+To further compare SDE’s ability to generalize to different languages, we train both SDE and sub-sep on the low-resource languages paired with all four high-resource languages. The results are listed in Table 6. For bel, SDE trained on all languages is able to improve over just training with bilingual data by around 0.6 BLEU. This is the best result on bel, with around 3 BLEU over the best baseline. The performance of sub-sep, on the other hand, decreases by
+
+Table 6: BLEU scores for training with all four highresource languages.   
+
+<table><tr><td rowspan="2">Lex Unit</td><td rowspan="2">Model</td><td colspan="2">aze</td><td colspan="2">bel</td></tr><tr><td>bi</td><td>all</td><td>bi</td><td>all</td></tr><tr><td>Sub-sep</td><td>Lookup</td><td>11.25</td><td>8.10</td><td>16.53</td><td>15.16</td></tr><tr><td>Word</td><td>SDE</td><td>12.25</td><td>12.09</td><td>19.08</td><td>19.69</td></tr></table>
+
+around 1.5 BLEU when training on all languages for bel. The performance of both methods decreases for aze when using all languages. SDE only slightly loses 0.1 BLEU while sub-sep loses over 3 BLEU.
+
+# 4.7 WHY DOES SDE WORK BETTER?
+
+The SDE framework outperforms the strong sub-sep baseline because it avoids sub-optimal segmentation of the multilingual data. We further inspect the improvements by calculating the word F-measure of the translated target words based on two properties of their corresponding source words: 1) the number of subwords they were split into; 2) the edit distance between their corresponding words in the related high-resource language. From Figure 4 left, we can see that SDE is better at predicting words that were segmented into a large number of subwords. Figure 4 right shows that the gain peaks on the second bucket for 2 languages and the first bucket for bel and slk, which implies that SDE shows more improvements for words with small but non-zero edit distance from the high-resource language. This is intuitive: words similar in spelling but with a few different characters can be split into very different subword segments, while SDE can leverage the lexical similarities of word pairs with slightly different spelling.
+
+![](images/011c4c073a6bedd7a758b9eb801af6ee4560048fff80f6f9d390941f680eaebe.jpg)  
+Figure 4: Gain in word F-measure of SDE over sub-sep. Left: the target words are bucketed by the number of subword pieces that their corresponding source words are segmented into. Right: the target words are bucketed by the edit distance between their source words and the corresponding words in the high resource language.
+
+# 4.8 QUALITATIVE ANALYSIS
+
+Table 7 lists a few translations for both sub-sep and SDE. We can see that SDE is better at capturing functional words like “if” and “would”. Moreover, it translates “climatologist” to a related word “weather”, probably from the prefix “climat” in glg, while sub-sep gives the totally unrelated translation of “college friend”. Some examples of bilingual lexicons that can be better captured by SDE can be found in Appendix A.3.
+
+Table 7: Examples of glg to eng translations.   
+
+<table><tr><td rowspan=1 colspan=1>glg</td><td rowspan=1 colspan=1>eng</td><td rowspan=1 colspan=1>sub-sep</td><td rowspan=1 colspan=1>SDE</td></tr><tr><td rowspan=1 colspan=1>Pero non temos a tec-noloxia para resolveriso, temos?</td><td rowspan=1 colspan=1>Butwe don&#x27;t havea technology to solvethat, right?</td><td rowspan=1 colspan=1>But we don&#x27;t havethe technology to solvethat, we have?</td><td rowspan=1 colspan=1>But we don&#x27;t havethe technology to solvethat, do we?</td></tr><tr><td rowspan=1 colspan=1>Se queres saber sobreo clima,preguntas a unclimatologo.</td><td rowspan=1 colspan=1>If you want to knowabout climate,you ask a climatologist.</td><td rowspan=1 colspan=1>If you want to knowabout climate,you&#x27;reasking a college friend.</td><td rowspan=1 colspan=1>If you want to knowabout climate,they askfor a weather.</td></tr><tr><td rowspan=1 colspan=1>Non é dicir que si</td><td rowspan=2 colspan=1>It&#x27;s not to say that if wehad all the money inthe world,we wouldn&#x27;twant to do it.</td><td rowspan=2 colspan=1>It&#x27;s not to say that wehad all the money inthe world,we didn&#x27;twant to do it.</td><td rowspan=2 colspan=1>It&#x27;s not to say that if wehad all the money inthe world, we wouldn&#x27;twant to do it.</td></tr><tr><td rowspan=1 colspan=1>tivesemos todo  0dineiro do mundo,nono quereriamos facer.</td></tr></table>
+
+# 5 RELATED WORKS
+
+In multilingual NMT, several approaches have been proposed to enhance parameter sharing of lexical representations. Zoph et al. (2016) randomly assigns embedding of a pretrained NMT model to the vocabulary of the language to adapt, which shows improvements over retraining the new embeddings from scratch. Nguyen & Chiang (2018) propose to match the embedding of the word piece that overlaps with the vocabulary of the new language. When training directly on concatenated data, it is also common to have a shared vocabulary of multilingual data (Neubig & Hu, 2018; Qi et al., 2018). Gu et al. (2018) propose to enhance parameter sharing in lexical representation by a latent embedding space shared by all languages.
+
+Several prior works have utilized character level embeddings for machine translation (Cherry et al., 2018; Lee et al., 2017; Ataman & Federico, 2018), language modeling (Kim et al., 2016; Jozefowicz ´ et al., 2016), and semantic parsing (Yih et al., 2014). Specifically for NMT, fully character-level NMT can effectively reduce the vocabulary size while showing improvements for mulitlingual NMT (Lee et al., 2017), but it often requires much longer to train (Cherry et al., 2018). Ataman & Federico (2018) shows that character $n$ -gram encoding of words can improve over BPE for morphologically rich languages.
+
+# 6 CONCLUSION
+
+Existing methods of lexical representation for multilingual NMT hinder parameter sharing between words that share similar surface forms and/or semantic meanings. We show that SDE can intelligently leverage the word similarities between two related languages by softly decoupling the lexical and semantic representations of the words. Our method, used without any subword segmentation, shows significant improvements over the strong multilingual NMT baseline on all languages tested.
+
+Acknowledgements: The authors thank David Mortensen for helpful comments, and Amazon for providing GPU credits. This material is based upon work supported in part by the Defense Advanced Research Projects Agency Information Innovation Office (I2O) Low Resource Languages for Emergent Incidents (LORELEI) program under Contract No. HR0011-15-C0114. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation here on.
+
+# REFERENCES
+
+Duygu Ataman and Marcello Federico. Compositional representation of morphologically-rich input for neural machine translation. ACL, 2018.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015.
+
+Daniel Chandler. Semiotic: The Basics. 2007.
+
+Colin Cherry, George Foster, Ankur Bapna, Orhan Firat, and Wolfgang Macherey. Revisiting character-based neural machine translation with capacity and compression. CoRR, 2018.
+
+Jonathan Clark, Chris Dyer, Alon Lavie, and Noah Smith. Better hypothesis testing for statistical machine translation: Controlling for optimizer instability. In ACL, 2011.
+
+Chris Dyer, Victor Chahuneau, and Noah A. Smith. A simple, fast, and effective reparameterization of IBM model 2. NAACL, 2013.
+
+Orhan Firat, Kyunghyun Cho, and Yoshua Bengio. Multi-way, multilingual neural machine translation with a shared attention mechanism. NAACL, 2016.
+
+Algirdas Julien Greimas. Structural semantics: An attempt at a method. University of Nebraska Press, 1983.
+
+Jiatao Gu, Hany Hassan, Jacob Devlin, and Victor O. K. Li. Universal neural machine translation for extremely low resource languages. NAACL, 2018.
+
+Melvin Johnson, Mike Schuster, Quoc V. Le, Maxim Krikun, Yonghui Wu, Zhifeng Chen, Nikhil Thorat, Fernanda Viegas, Martin Wattenberg, Greg Corrado, Macduff Hughes, and Jeffrey Dean. ´ Google’s multilingual neural machine translation system: Enabling zero-shot translation. TACL, 2016.
+
+Rafal Jozefowicz, Oriol Vinyals, Mike Schuster, Noam Shazeer, and Yonghui Wu. Exploring the ´ limits of language modeling. Arxiv, 2016.
+
+Yoon Kim, Yacine Jernite, David Sontag, and Alexander M. Rush. Character-aware neural language models. AAAI, 2016.
+
+Taku Kudo. Subword regularization: Improving neural network translation models with multiple subword candidates. ACL, 2018.   
+Jason Lee, Kyunghyun Cho, and Thomas Hofmann. Fully character-level neural machine translation without explicit segmentation. TACL, 2017.   
+Minh-Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attentionbased neural machine translation. In EMNLP, 2015.   
+Graham Neubig and Junjie Hu. Rapid adaptation of neural machine translation to new languages. EMNLP, 2018.   
+Toan Q. Nguyen and David Chiang. Transfer learning across low-resource, related languages for neural machine translation. In NAACL, 2018.   
+Ye Qi, Devendra Singh Sachan, Matthieu Felix, Sarguna Padmanabhan, and Graham Neubig. When and why are pre-trained word embeddings useful for neural machine translation? NAACL, 2018.   
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In ACL, 2016.   
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In NIPS, 2014.   
+L.J.P. van der Maaten and G.E. Hinton. Visualizing high-dimensional data using t-SNE. Journal of Machine Learning Research, 2008.   
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NIPS, 2017.   
+John Wieting, Mohit Bansal, Kevin Gimpel, and Karen Livescu. Charagram: Embedding words and sentences via character n-grams. EMNLP, 2016.   
+Wen-tau Yih, Xiaodong He, and Christopher Meek. Semantic parsing for single-relation question answering. ACL, 2014.   
+Barret Zoph, Deniz Yuret, Jonathan May, and Kevin Knight. Transfer learning for low resource neural machine translation. EMNLP, 2016.
+
+# A APPENDIX
+
+A.1 TRAINING DETAILS
+
+• We use a 1-layer long-short-term-memory (LSTM) network with a hidden dimension of 512 for both the encoder and the decoder.   
+• The word embedding dimension is kept at 128, and all other layer dimensions are set to 512.   
+We use a dropout rate of 0.3 for the word embedding and the output vector before the decoder softmax layer. The batch size is set to be 1500 words. We evaluate by development set BLEU score for every 2500 training batches. For training, we use the Adam optimizer with a learning rate of 0.001. We use learning rate decay of 0.8, and stop training if the model performance on development set doesn’t improve for 5 evaluation steps.
+
+# A.2 EFFECT OF VOCABULARY SIZE
+
+We examine the performance of SDE and the best baseline sub-sep, with a character $n$ -gram vocabulary and sub-word vocabulary respectively, of size of 8K, 16K, and 32K. We use character $n$ -gram of $n = \{ 1 , 2 , 3 , 4 \}$ for 8K and 16K vocabularies, and $n = \{ 1 , 2 , 3 , 4 , 5 \}$ for the 32K vocabulary. Figure 5 shows that for all four languages, SDE outperforms sub-sep with all three vocabulary sizes. This shows that SDE is also competitive with a relatively small character $n$ -gram vocabulary.
+
+![](images/dc919fe21aad9f9bce8ae0d505aae14bb5fa3c69349c759628e009b0a17e6f29.jpg)  
+Figure 5: Performance on three different vocabulary size (results of a single random seed).
+
+# A.3 EXAMPLE BILINGUAL WORDS
+
+Table 8 lists some words and their subwords from bel and its related language rus. We can see that subwords fail to capture all the lexical similarities between these words, and sometimes the word pairs are segmented into different number of pieces.
+
+Table 8: Bilingual word pairs and their subword pieces.   
+
+<table><tr><td colspan="2">bel</td><td colspan="2">rus</td><td rowspan="2">eng</td></tr><tr><td>word</td><td>subword</td><td>word</td><td>subword</td></tr><tr><td>ΦiHaHcaBbII</td><td>diHaHcaBbI I</td><td>ΦHHaHCOBbIX</td><td>ΦHHaHCOBbI X</td><td>financial</td></tr><tr><td>CTaIbIéH</td><td>CTaJIbI éH</td><td>CTaJINOH</td><td>CTaJINOH</td><td>stadium</td></tr><tr><td>p03HbIX</td><td>p03HbI X</td><td>pa3HbIX</td><td>pa3HbI X</td><td>different</td></tr><tr><td>Iaka3aub</td><td>Haka3a Ib</td><td>IOKa3aTb</td><td>HOka3aTb</td><td>show</td></tr></table>
+
+# A.4 ANALYSIS OF ATTENTION OVER LATENT EMBEDDING SPACE
+
+In this section we compare the attention distribution over the latent embedding space of related languages, with the intuition that words that mean the same thing should have similar attention distributions. We calculate the KL divergence of the attention distribution for word pairs in both the LRL and HRL. Figure 6 shows that the lowest KL divergence is generally on the diagonals representing words with identical meanings, which indicates that similar words from two related languages
+
+![](images/3054732b90341671e9be359ad64e880509e24178447ce3fc6c8820a4f62774e7.jpg)
+
+![](images/c8d32e289cdae151e52a7b40a1f0fc623ed1f168cddf391beaec0267e7d1a8af.jpg)  
+Figure 6: KL divergence of attention over latent embedding space between words from two related languages. Word pairs that match at the diagonal have similar meanings. Left: bel-rus. Right: glg-por.
+
+<table><tr><td>glg</td><td>eng</td><td>por</td><td>eng</td></tr><tr><td>cando</td><td>when</td><td>quando</td><td>when</td></tr><tr><td></td><td>label</td><td>caindo r6tulo</td><td>failing down</td></tr><tr><td>etiqueta</td><td></td><td></td><td>label</td></tr><tr><td></td><td></td><td>riqueza</td><td>wealth</td></tr></table>
+
+Table 9: Words in glg-por that have the same meaning but different spelling, or similar spelling but different meaning.
+
+tend to have similar attention over the latent embedding space. Note that this is the case even for words with different spellings. For example, Figure 6 right shows that the KL divergence between the glg word “musicos” (meaning “musicians”), and the por word of the closet meaning among the ´ words shown here, “jogadores” (meaning “players”), is the smallest, although their spellings are quite different.
+
+# A.5 ANALYSIS OF WORD VECTORS FROM SDE
+
+In this section, we qualitatively examine the location of word vectors at different stages of SDE. We reduce the word vectors to two dimensions using t-SNE (van der Maaten & Hinton, 2008). In particular, we focus on two groups of words shown in Table 9 from glg-por, where each word from glg is paired with two words from por, one with the same meaning but different spelling, while the other has similar spelling but different meaning. Figure 7 left shows the embeddings derived from the character $n$ -grams. At this stage, the word “cando” is closer to “caindo”, which has a different meaning, than “quando”, which has the same meaning but a slightly more different spelling. The word “etiqueta” lies in the middle of “rotulo” and “riqueza”. After the whole encoding process, the ´ location of the words are shown in Figure 7 right. At the final stage, the word “cando” moves closer to “quando”, which has the same meaning, than “caindo”, which is more similar in spelling. The word “etiqueta” is also much closer to “rotulo”, the word with similar meaning, and grows further ´ apart from “riqueza”.
+
+![](images/786f8a080f738703196e453dbdefef629893c04b20e62e084b0708e7d96b8388.jpg)  
+Figure 7: T-SNE visualizations of the embeddings of words in Table 9 encoded after the character $n$ -gram embedding stage $( L e f t )$ , or after the full process of SDE(Right). Words of the same color have similar meanings, and the language code of the word is placed in the parenthesis. It can be seen that the character embedding stage is more sensitive to lexical similarity, while the full SDEmodel is more sensitive to similarity in meaning.

parse/train/Skeke3C5Fm/Skeke3C5Fm_content_list.json

@@ -0,0 +1,1515 @@
+[
+    {
+        "type": "text",
+        "text": "MULTILINGUAL NEURAL MACHINE TRANSLATION WITH SOFT DECOUPLED ENCODING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            782,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xinyi Wang1, Hieu Pham1,2, Philip Arthur3, and Graham Neubig1 ",
+        "bbox": [
+            184,
+            167,
+            640,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Language Technology Institute, Carnegie Mellon University, Pittsburgh, PA 15213, USA 2Google Brain, Mountain View, CA 94043, USA   \n3Monash University, Clayton VIC 3800, Australia   \n{xinyiw1,hyhieu,gneubig}@cs.cmu.edu,philip.arthur@monash.edu ",
+        "bbox": [
+            184,
+            196,
+            772,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            291,
+            544,
+            306
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Multilingual training of neural machine translation (NMT) systems has led to impressive accuracy improvements on low-resource languages. However, there are still significant challenges in efficiently learning word representations in the face of paucity of data. In this paper, we propose Soft Decoupled Encoding (SDE), a multilingual lexicon encoding framework specifically designed to share lexicallevel information intelligently without requiring heuristic preprocessing such as pre-segmenting the data. SDE represents a word by its spelling through a character encoding, and its semantic meaning through a latent embedding space shared by all languages. Experiments on a standard dataset of four low-resource languages show consistent improvements over strong multilingual NMT baselines, with gains of up to 2 BLEU on one of the tested languages, achieving the new state-of-the-art on all four language pairs1. ",
+        "bbox": [
+            233,
+            320,
+            764,
+            487
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            334,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Multilingual Neural Machine Translation (NMT) has shown great potential both in creating parameter-efficient MT systems for many languages (Johnson et al., 2016), and in improving translation quality of low-resource languages (Zoph et al., 2016; Firat et al., 2016; Gu et al., 2018; Neubig & Hu, 2018; Nguyen & Chiang, 2018). Despite the success of multilingual NMT, it remains a research question how to represent the words from multiple languages in a way that is both parameter efficient and conducive to cross-lingual generalization. The standard sequence-to-sequence (seq2seq) NMT model (Sutskever et al., 2014) represents each lexical unit by a vector from a look-up table, making it difficult to share across different languages with limited lexicon overlap. This problem is particularly salient when translating low-resource languages, where there is not sufficient data to fully train the word embeddings. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Several methods have been proposed to alleviate this data sparsity problem in multilingual lexical representation. The current de-facto standard method is to use subword units (Sennrich et al., 2016; Kudo, 2018), which split up longer words into shorter subwords to allow for generalization across morphological variants or compounds (e.g. “un/decide/d” or “sub/word”). These can be applied to the concatenated multilingual data, producing a shared vocabulary for different languages, resulting in sharing some but not all subwords of similarly spelled words (such as “traduccion” in Spanish and ´ “traduc¸ao” in Portuguese, which share the root “tradu-”). However, subword-based preprocessing ˜ can produce sub-optimal segmentations for multilingual data, with semantically identical and similarly spelled languages being split into different granularities (e.g. “traduccion” and “tradu/c¸ ´ ao”) ˜ leading to disconnect in the resulting representations. This problem is especially salient when the high-resource language dominates the training data (see empirical results in Section 4). ",
+        "bbox": [
+            174,
+            686,
+            825,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose Soft Decoupled Encoding (SDE), a multilingual lexicon representation framework that obviates the need for segmentation by representing words on a full-word level, but can nonetheless share parameters intelligently, aiding generalization. Specifically, SDE softly decouples the traditional word embedding into two interacting components: one component represents how the word is spelled, and the other component represents the word’s latent meaning, which is shared over all languages present at training time. We can view this representation as a decomposition of language-specific realization of the word’s form (i.e. its spelling) and its language-agnostic semantic function. More importantly, our decoupling is done in a soft manner to preserve the interaction between these two components. ",
+        "bbox": [
+            176,
+            845,
+            823,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/85e9834e246cc102ea4d838dff01ce7b44969cb92c4d5fe67cd4bf15c51a0c1f.jpg",
+        "image_caption": [
+            "Figure 1: Three steps to compute the lexical representations for the input sequence “a cute puppy”, using various lexical unit segmentations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            98,
+            794,
+            244
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            324,
+            825,
+            393
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SDE has three key components: 1) an encoding of a word using character $n$ -grams (Wieting et al., 2016); 2) a language specific transform for the character encoding; 3) a latent word embedding constructed by using the character encoding to attend to a shared word embedding space, inspired by Gu et al. (2018). Our method can enhance lexical-level transfer through the shared latent word embedding while preserving the model’s capacity to learn specific features for each language. Moreover, it eliminates unknown words without any external preprocessing step such as subword segmentation. ",
+        "bbox": [
+            174,
+            401,
+            825,
+            484
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We test SDE on four low-resource languages from a multilingual TED corpus (Qi et al., 2018). Our method shows consistent improvements over multilingual NMT baselines for all four languages, and importantly outperforms previous methods for multilingual NMT that allow for more intelligent parameter sharing but do not use a two-step process of character-level representation and latent meaning representation (Gu et al., 2018). Our method outperforms the best baseline by about 2 BLEU for one of the low-resource languages, achieving new state-of-the-art results on all four language pairs compared to strong multi-lingually trained and adapted baselines (Neubig & Hu, 2018). ",
+        "bbox": [
+            174,
+            492,
+            825,
+            589
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 LEXICAL REPRESENTATION FOR MULTILINGUAL NMT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            621,
+            661,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first revisit the 3-step process of computing lexical representations for multilingual NMT, which is illustrated in Figure 1. Then, we discuss various design choices for each step, as well as the desiderata of an ideal lexical representation for multilingual NMT. ",
+        "bbox": [
+            174,
+            660,
+            823,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 LEXICAL UNIT SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            732,
+            433,
+            746
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The first step to compute the neural representation for a sentence is to segment the sentence into lexical units. There are three popular options with different granularities: ",
+        "bbox": [
+            174,
+            762,
+            823,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Word-based method splits an input sequence into words, often based on white spaces or punctuation. This is perhaps the natural choice for lexical unit segmentation. Early work in NMT all employ this method (Sutskever et al., 2014; Bahdanau et al., 2015). ",
+        "bbox": [
+            215,
+            808,
+            825,
+            851
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Character-based method splits an input sequence into characters (Lee et al., 2017). ",
+        "bbox": [
+            214,
+            866,
+            782,
+            881
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Subword-based method splits each word into pieces from a small vocabulary of frequently occurring patterns (Sennrich et al., 2016; Kudo, 2018). ",
+        "bbox": [
+            217,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 EMBEDDING LOOK-UP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            372,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After a sentence is segmented into lexical units, NMT models generally look up embeddings from a dictionary to turn each lexical unit into a high-dimensional vector. In the context of multilingual NMT, the lexical unit segmentation method affects this dictionary in different ways. ",
+        "bbox": [
+            176,
+            136,
+            823,
+            178
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In word-based segmentation, since the number of unique words for each language is unbounded, while computer memory is not, previous work, e.g. Sutskever et al. (2014), resorts to a fixed-size vocabulary of the most frequent words, while mapping out-of-vocabulary words to an $\\langle { \\mathrm { u n k } } \\rangle$ token. For multilingual NMT settings, where multiple languages are processed, the number of words mapped to $\\langle { \\mathrm { u n k } } \\rangle$ significantly increases. Moreover, different languages, even related languages, have very few words that have exactly the same spelling, which leads to the same concept being represented by multiple and independent parameters. This disadvantage hurts the translation model’s ability to learn the same concept in multiple languages. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            296
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Meanwhile, character-based segmentation can effectively reduce the vocabulary size, while maximizing the potential for parameter sharing between languages with identical or similar character sets. However, character segmentation is based on the strong assumption that neural networks can infer meaningful semantic boundaries and compose characters into meaningful words. This puts a large amount of pressure on neural models, requiring larger model sizes and training data. Additionally, training character-based NMT systems is often slow, due to the longer character sequences (Cherry et al., 2018). ",
+        "bbox": [
+            174,
+            303,
+            825,
+            400
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Subword-based segmentation is a middle ground between word and character segmentation. However, in multilingual translation, the subword segmentation can be sub-optimal, as the subwords from high-resource languages, i.e. languages with more training data, might dominate the subword vocabulary, so that the words in low-resource language can be split into extremely small pieces. ",
+        "bbox": [
+            176,
+            407,
+            825,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Therefore, existing methods for lexical unit segmentation lead to difficulties in building an effective embedding look-up strategy for multilingual NMT. ",
+        "bbox": [
+            174,
+            470,
+            821,
+            500
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 OPTIONAL ENCODING TRANSFORMATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            532,
+            513,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Most commonly, the embedding vectors looked up from the embedding table are used as the final lexical representation. However, it is also possible to have multiple versions of embeddings for a single lexicon and combine them through operations such as attentional weighted sum (Gu et al., 2018). Without loss of generality, we can assume there is always a transformation applied to the embedding vectors, and models that do not use such a transformation can be treated as using the identity transformation. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 DESIDERATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            303,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To efficiently utilize parameters for multilingual NMT, the lexical representation should have two properties. First, for maximal accuracy, the lexical representation should be able to accurately represent words in all of the languages under consideration. Second, for better cross-lingual learning and generalization, such a representation should maximize the sharing of parameters across languages. ",
+        "bbox": [
+            176,
+            713,
+            823,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "These two conflicting objectives are difficult to achieve through existing methods. The most common method of using lookup embeddings can only share information through lexical units that overlap between the languages. Subword segmentation strikes a middle ground, but has many potential problems for multilingual NMT, as already discussed in Section 2.2. Although Gu et al. (2018)’s method of latent encoding increases lexical level parameter sharing, it still relies on subwords as its fundamental units, and thus inherits the previously stated problems of sub-word segmentation. We also find in experiments in Section 4 that it is actually less robust than simple lookup when large monolingual data to pre-train embeddings is not available, which is the case for many low-resourced languages. ",
+        "bbox": [
+            174,
+            776,
+            823,
+            902
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Next, in Section 3, we propose a novel lexical representation strategy that achieves both desiderata. ",
+        "bbox": [
+            173,
+            909,
+            818,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 SOFT DECOUPLED ENCODING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            455,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the conflict between sharing lexical features and preserving language specific properties, we propose SDE, a general framework to represent lexical units for multilingual NMT. Specifically, following the linguistic concept of the “arbitrariness of the sign” (Chandler, 2007), SDE decomposes the modeling of each word into two stages: (1) modeling the language-specific spelling of the word, and (2) modeling the language-agnostic semantics of the word. This decomposition is based on the need for distinguished treatments between a word’s semantics and its spelling. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Semantic representation is language-agnostic. For example, the English “hello” and the French “bonjour” deliver the same greeting message, which is invariant with respect to the language. SDE shares such semantic representations among languages by querying a list of shared concepts, which are loosely related to the linguistic concept of “sememes” (Greimas, 1983). This design is implemented using an attention mechanism, where the query is the lexical unit representation, and the keys and the values come from an embedding matrix shared among all languages. ",
+        "bbox": [
+            173,
+            223,
+            825,
+            308
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Meanwhile, the word spellings are more sophisticated. Here, we identify two important observations about word spellings. First, words in related languages can have similar spellings, e.g. the English word “color” and the French word “coleur”. In order to effectively share parameters among languages, a word spelling model should utilize this fact. Second, and not contradicting the first point, related languages can also exhibit consistent spelling shifts. For instance, “Christopher”, a common name in English, has the spelling “Krystof” in Czech. This necessitates a learnable rule to ˇ convert the spelling representations between such pairs of words in related languages. To account for both points, we use a language-specific transformation on top of a first encoding layer based on character $n$ -grams. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXISTING METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            357,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Before we describe our specific architecture in detail (Section 3.2), given these desiderata discussed above, we summarize the designs of several existing methods for lexical representation and our proposed SDE framework in Table 1. Without a preprocessing step of subword segmentation, SDE can capture the lexical similarities of two ",
+        "bbox": [
+            174,
+            482,
+            354,
+            660
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/32fae492730378e5352592914b211aa940ef634d706a10486f1409faa68ddbb6.jpg",
+        "table_caption": [
+            "Table 1: Methods for lexical representation in multilingual NMT. joint-Lookup means the lookup table is jointly trained with the whole model. pretrain-Lookup means the lookup table is trained independently on monolingual data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Lex Unit</td><td>Embedding</td><td>Encoding</td></tr><tr><td>Johnson et al. (2016)</td><td>Subword</td><td> joint-Lookup</td><td>Identity</td></tr><tr><td>Lee et al. (2017)</td><td>Character</td><td> joint-Lookup</td><td>Identity</td></tr><tr><td>Gu et al. (2018)</td><td>Subword</td><td>pretrain-Lookup</td><td> joint-Lookup + Latent</td></tr><tr><td>Ataman &amp; Federico (2018)</td><td>Word</td><td>character n-gram</td><td>Identity</td></tr><tr><td>SDE</td><td>Word</td><td>character n-gram</td><td>Identity + Latent</td></tr></table>",
+        "bbox": [
+            367,
+            498,
+            825,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "related languages through the character $n$ -gram embedding while preserving the semantic meaning of lexicons through a shared latent embedding. ",
+        "bbox": [
+            173,
+            661,
+            823,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 DETAILS OF SOFT DECOUPLED ENCODING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            513,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b6cfa999fd5ec2a3b7c413037a0c97ab104e7c23f697bbcbbda8f1ea70dcf02b.jpg",
+        "image_caption": [
+            "Figure 2: SDE computes the embedding for the word “puppy”. Both character $n$ -grams embeddings and latent semantic embeddings are shared among all languages. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            733,
+            826,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As demonstrated in Figure 2, given a word $w$ in a multilingual corpus from language $L _ { i }$ , SDE constructs the embedding of $w$ in three phases. ",
+        "bbox": [
+            173,
+            852,
+            823,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lexical Embedding. We maintain an embedding matrix $\\mathbf { W } _ { c } \\in \\mathbb { R } ^ { C \\times D }$ , where $D$ is the embedding dimension and $C$ is the number of $n$ -grams in our vocabulary. Out-of-vocab $n$ -grams are mapped to a designated token $\\langle { \\mathrm { u n k } } \\rangle$ . $\\mathbf { W } _ { c }$ is shared among all languages. Following Wieting et al. (2016), for each word $w$ , we first compute the bag of character $n$ -grams of $w$ , denoted by $\\boldsymbol { \\mathrm { B o N } } ( \\boldsymbol { w } )$ , which is a sparse vector whose coordinates are the appearance counts of each character $n$ -gram in $w$ . For instance, the characters $n$ -grams with $n = 1 , 2 , 3 , 4$ of the word “puppy” are shown in Figure 2. We then look up and add the rows of $\\mathbf { W } _ { c }$ according to their corresponding counts, and apply a tanh activation function on the result ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            102,
+            825,
+            186
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cac862af2a3e6a67b37ce0f12b3c0be086b1f5fbf47a142fbda6c793b5166777.jpg",
+        "text": "$$\nc ( w ) = \\operatorname { t a n h } ( \\mathbf { B o N } ( w ) \\cdot \\mathbf { W } _ { \\mathrm { c } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            188,
+            596,
+            205
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Language-specific Transformation. To account for spelling shifts between languages (c.f. Section 3), we apply an language-specific transformation to normalize away these differences. We use a simple fully-connected layer for this transformation. In particular, for language $L _ { i }$ , we have ",
+        "bbox": [
+            174,
+            213,
+            825,
+            256
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/723d6ad69df3c6cda993e89dd20e705c42db0c1ddd5b79489cf86032e1faf3af.jpg",
+        "text": "$$\n\\begin{array} { r } { c _ { i } ( w ) = \\operatorname { t a n h } ( c ( w ) \\cdot { \\bf W } _ { L _ { i } } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            257,
+            589,
+            275
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { W } _ { L _ { i } } \\in \\mathbb { R } ^ { D \\times D }$ is the transformation matrix specific to language $L _ { i }$ ",
+        "bbox": [
+            176,
+            276,
+            663,
+            291
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Latent Semantic Embedding. Finally, to model the shared semantics of words among languages, we employ an embedding matrix $\\mathbf { W } _ { s } \\in \\mathbb { R } ^ { S \\times D }$ , where $S$ is the number of core semantic concepts we assume a language can express. Similar to the lexical embedding matrix $\\mathbf { W } _ { c }$ , the semantic embedding matrix ${ \\mathbf W _ { s } }$ is also shared among all languages. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            362
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For each word $w$ , its language-specific embedding $c _ { i } ( w )$ is passed as a query for an attention mechanism (Luong et al., 2015) to compute a weighted sum over the latent embeddings ",
+        "bbox": [
+            171,
+            368,
+            823,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/96986c9a375a1b1a2b8a1642abaf67c05eeb1feb97a2ae7ba75882f368060ca3.jpg",
+        "text": "$$\ne _ { \\mathrm { l a t e n t } } ( \\boldsymbol { w } ) = \\operatorname { S o f t m a x } ( c _ { i } ( \\boldsymbol { w } ) \\cdot \\mathbf { W } _ { s } ^ { \\top } ) \\cdot \\mathbf { W } _ { s } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            398,
+            635,
+            417
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, to ease the optimization of our model, we follow Vaswani et al. (2017) and add the residual connection from $c _ { i } ( w )$ into $e _ { \\mathrm { l a t e n t } } ( w )$ , forming the Soft Decoupled Encoding embedding of $w$ ",
+        "bbox": [
+            173,
+            424,
+            828,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/88776b0f2757f0521389e9df5d6a15964e347f6afa291384abee7af901888235.jpg",
+        "text": "$$\ne _ { \\mathrm { S D E } } ( w ) = e _ { \\mathrm { l a t e n t } } ( w ) + c _ { i } ( w ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            454,
+            598,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            316,
+            505
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We build upon a standard seq2seq NMT model for all experiments. Except for the experiments in Section 4.6, we run each experiment with 3 different random seeds, and conduct significance tests for the results using the paired bootstrap (Clark et al., 2011). ",
+        "bbox": [
+            174,
+            518,
+            825,
+            561
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            578,
+            287,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the 58-language-to-English TED corpus for experiments. Following the settings of prior works on multilingual NMT (Neubig & Hu, 2018; Qi et al., 2018), we use three low-resource language datasets: Azerbaijani (aze), Belarusian (bel), Galician (glg) to English, and a slightly higher-resource dataset, namely Slovak (slk) to English. Each lowresource language is paired with a related ",
+        "bbox": [
+            174,
+            603,
+            450,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/70846a74f498a4109876a07cb11d92525f9d1c927b0ed624cca4c66ef79486dd.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LRL</td><td>Train</td><td>Dev</td><td>Test</td><td>HRL</td><td>Train</td></tr><tr><td>aze</td><td>5.94k</td><td>671</td><td>903</td><td>tur</td><td>182k</td></tr><tr><td>bel</td><td>4.51k</td><td>248</td><td>664</td><td>rus</td><td>208k</td></tr><tr><td>glg</td><td>10.0k</td><td>682</td><td>1007</td><td>por</td><td>185k</td></tr><tr><td>slk</td><td>61.5k</td><td>2271</td><td>2445</td><td>ces</td><td>103k</td></tr></table>",
+        "bbox": [
+            478,
+            611,
+            810,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Statistics of our datasets. LRL and HRL mean Low-Resource and High-Resource Language. ",
+        "bbox": [
+            464,
+            707,
+            823,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "high-resource language: Turkish (tur), Russian (rus), Portuguese (por), and Czech (ces) respectively.   \nTable 2 shows the statistics of each dataset. ",
+        "bbox": [
+            166,
+            742,
+            823,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            786,
+            294,
+            800
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the baseline, we use the standard lookup embeddings for three granularities of lexical units: (1) word: with a fixed word vocabulary size of 64,000 for the concatenated bilingual data; (2) subjoint: with BPE of 64,000 merge operations on the concatenated bilingual data; and (3) sub-sep: with BPE separately on both languages, each with 32,000 merge operations, effectively creating a vocabulary of size 64,000. We use all three settings to compare their performances and to build a competitive baselines. We also implement the latent embedding method of Gu et al. (2018). We use 32,000 character $n$ -gram with $n = \\{ 1 , 2 , 3 , 4 , 5 \\}$ from each language and a latent embedding size of 10,000. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            277,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 3 presents the results of SDEand of other baselines. For the three baselines using lookup, subsep achieves the best performance for three of the four languages. Sub-joint is worse than sub-sep although it allows complete sharing of lexical units between languages, probably because sub-joint leads to over-segmentation for the low-resource language. Our reimplementation of universal encoder (Gu et al., 2018) does not perform well either, probably because the monolingual embedding is not trained on enough data, or the hyperparamters for their method are harder to tune. Meanwhile, SDE outperforms the best baselines for all four languages, without using subword units or extra monolingual data. ",
+        "bbox": [
+            173,
+            128,
+            825,
+            241
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9cd1ebdbc9910092c029b6b91b3cf845cc7377d619fe705f4195468db8f7f8ed.jpg",
+        "table_caption": [
+            "Table 3: BLEU scores on four language pairs. Statistical significance is indicated with $\\ast ~ ( p ~ <$ 0.0001) and $\\dag \\left( p < 0 . 0 5 \\right)$ , compared with the best baseline. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Lex Unit</td><td>Model</td><td>aze</td><td>bel</td><td>glg</td><td>slk</td></tr><tr><td>Word</td><td>Lookup</td><td>7.66</td><td>13.03</td><td>28.65</td><td>25.24</td></tr><tr><td>Sub-joint</td><td>Lookup</td><td>9.40</td><td>11.72</td><td>22.67</td><td>24.97</td></tr><tr><td>Sub-sep</td><td>Lookup (Neubig &amp; Hu,2018)2</td><td>10.90</td><td>16.17</td><td>28.10</td><td>28.50</td></tr><tr><td>Sub-sep</td><td>UniEnc (Gu et al., 2018)3</td><td>4.80</td><td>8.13</td><td>14.58</td><td>12.09</td></tr><tr><td>Word</td><td>SDE</td><td>11.82*</td><td>18.71*</td><td>30.30*</td><td>28.77+</td></tr></table>",
+        "bbox": [
+            217,
+            253,
+            779,
+            363
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/2fd77f232228cb3f42152e94e8b18eea845cbadae2a7617c2fd8f7c975aa3762.jpg",
+        "table_caption": [
+            "Table 4: BLEU scores after removing each component from SDE-com. Statistical significance is indicated with $\\ast \\ ( p \\_ { \\mathrm { ~ \\scriptsize ~ < ~ } }$ 0.0001) and $\\dagger$ $( p < 0 . 0 0 5 )$ , compared with the full model in the first row. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>aze</td><td>bel</td><td>glg</td><td>slk</td></tr><tr><td>SDE</td><td>11.82</td><td>18.71</td><td>30.30</td><td>28.77</td></tr><tr><td>-Language Specific Transform</td><td>12.89*</td><td>18.13†</td><td>30.07</td><td>29.16†</td></tr><tr><td>-Latent Semantic Embedding</td><td>7.77*</td><td>15.66*</td><td>29.25*</td><td>28.15*</td></tr><tr><td>-Lexical Embedding</td><td>4.57*</td><td>8.03*</td><td>13.77*</td><td>7.08*</td></tr></table>",
+        "bbox": [
+            178,
+            440,
+            602,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a77f49e7bb56d8677d4f1c6dfc9459a272c6278164233a8f215482462bb57023.jpg",
+        "image_caption": [
+            "Figure 3: Percentage of words by the edit distance from the matching words in the highresource language. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            620,
+            424,
+            816,
+            537
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            632,
+            352,
+            646
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We next ablate various features of SDE by removing each of the three key components, and show the results in Table 4. Removing the latent semantic embedding and lexical embedding consistently harms the performance of the model. The effect of the language specific transformation is smaller and is language dependent. Removing the language specific transformation does not lead to significant difference for glg. However, it leads to a 0.8 gain in BLEU for aze, a 0.3 gain for slk, but about a 0.6 decrease for bel. A further inspection of the four language pairs shows that the language specific transform is more helpful for training on languages with fewer words of the same spelling. To quantify this, we extract bilingual dictionaries of the low-resource languages and their paired high-resource languages, and measure the edit distance between the character strings of the aligned words. We use FastAlign (Dyer et al., 2013) to extract aligned words between the source language and English from the parallel training data, then match the English side of two related languages to get their dictionary. Figure 3 shows the percentage of the word pairs grouped by their edit distance. Among the four languages, bel has the lowest percentage of words that are exactly the same with their corresponding words in the high-resource language (0 edit distance), indicating that the language specific transform is most important for divergent languages. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.5 EFFECT OF SUBWORDS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            176,
+            375,
+            190
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although using subwords in NMT can eliminate unknown words and control the vocabulary size, it might not be optimal for languages with rich morphology (Ataman & Federico, 2018). We also show in Table 3 that certain choices when using subwords on multilingual data (e.g. whether to train the segmentation on the concatenated multilingual data or separately) have a large effect on the performance of the model. SDE achieves superior performance without using subwords, so it can avoid the risk of sub-optimal segmentation. Still, we test SDE with subwords to study its effect on our framework. The results are shown in Table 5. We test two methods of using subwords: 1) ",
+        "bbox": [
+            173,
+            202,
+            825,
+            300
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4585ae7b9bcb620a6a5d00e2d1fbe32b199486a7722268c69238bad91e673e70.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Lex Unit</td><td>Model</td><td>aze</td><td>bel</td><td>glg</td><td>slk</td></tr><tr><td>Word</td><td>SDE</td><td>11.82</td><td>18.71</td><td>30.30</td><td>28.77</td></tr><tr><td>Sub-sep</td><td>SDE</td><td>12.37t</td><td>16.29*</td><td>28.94*</td><td>28.35t</td></tr><tr><td>Word</td><td>SDE-sub</td><td>12.03</td><td>18.16t</td><td>31.16*</td><td>28.86</td></tr></table>",
+        "bbox": [
+            302,
+            313,
+            694,
+            388
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 5: BLEU scores on four language pairs. Statistical significance is indicated with $\\ast ~ ( p ~ <$ 0.0001) and $\\dag \\ ( p < 0 . 0 0 5 )$ , compared with the setting in row 1. ",
+        "bbox": [
+            173,
+            397,
+            821,
+            426
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "we use sub-sep as lexical units, and encode its lexical representation using the character $n$ -grams of the subwords; 2) we use words as lexical units, but use its subword pieces instead of the character $n$ -grams to construct its lexical representation. We use SDE-sub to indicate the second way of using subwords. When using SDE with sub-sep as lexical units, the performance slightly increases for aze, but decreases for the other three language. Therefore, it is generally better to directly use words as lexical units for SDE. When we use words as lexical units but replace character $n$ -gram with subwords, the performance on two of the languages doesn’t change significantly, while the performance decreases for bel and increases for glg. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also examine the performance of SDE and the best baseline sub-sep with different vocabulary size and found that SDE is also competitive with a small character $n$ -gram vocabulary of size 8K. Details can be found in Appendix A.2. ",
+        "bbox": [
+            176,
+            559,
+            825,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.6 TRAINING ON ALL LANGUAGES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            618,
+            436,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further compare SDE’s ability to generalize to different languages, we train both SDE and sub-sep on the low-resource languages paired with all four high-resource languages. The results are listed in Table 6. For bel, SDE trained on all languages is able to improve over just training with bilingual data by around 0.6 BLEU. This is the best result on bel, with around 3 BLEU over the best baseline. The performance of sub-sep, on the other hand, decreases by ",
+        "bbox": [
+            174,
+            643,
+            450,
+            796
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/143c6c449496046c020e4d0df363a408eea59cef4e829cadad8f15a7d45bbab1.jpg",
+        "table_caption": [
+            "Table 6: BLEU scores for training with all four highresource languages. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Lex Unit</td><td rowspan=\"2\">Model</td><td colspan=\"2\">aze</td><td colspan=\"2\">bel</td></tr><tr><td>bi</td><td>all</td><td>bi</td><td>all</td></tr><tr><td>Sub-sep</td><td>Lookup</td><td>11.25</td><td>8.10</td><td>16.53</td><td>15.16</td></tr><tr><td>Word</td><td>SDE</td><td>12.25</td><td>12.09</td><td>19.08</td><td>19.69</td></tr></table>",
+        "bbox": [
+            464,
+            661,
+            823,
+            736
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "around 1.5 BLEU when training on all languages for bel. The performance of both methods decreases for aze when using all languages. SDE only slightly loses 0.1 BLEU while sub-sep loses over 3 BLEU. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            838
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.7 WHY DOES SDE WORK BETTER? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            442,
+            869
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The SDE framework outperforms the strong sub-sep baseline because it avoids sub-optimal segmentation of the multilingual data. We further inspect the improvements by calculating the word F-measure of the translated target words based on two properties of their corresponding source words: 1) the number of subwords they were split into; 2) the edit distance between their corresponding words in the related high-resource language. From Figure 4 left, we can see that SDE is better at predicting words that were segmented into a large number of subwords. Figure 4 right shows that the gain peaks on the second bucket for 2 languages and the first bucket for bel and slk, which implies that SDE shows more improvements for words with small but non-zero edit distance from the high-resource language. This is intuitive: words similar in spelling but with a few different characters can be split into very different subword segments, while SDE can leverage the lexical similarities of word pairs with slightly different spelling. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/011c4c073a6bedd7a758b9eb801af6ee4560048fff80f6f9d390941f680eaebe.jpg",
+        "image_caption": [
+            "Figure 4: Gain in word F-measure of SDE over sub-sep. Left: the target words are bucketed by the number of subword pieces that their corresponding source words are segmented into. Right: the target words are bucketed by the edit distance between their source words and the corresponding words in the high resource language. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            98,
+            763,
+            212
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            311,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.8 QUALITATIVE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            441,
+            387,
+            455
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 7 lists a few translations for both sub-sep and SDE. We can see that SDE is better at capturing functional words like “if” and “would”. Moreover, it translates “climatologist” to a related word “weather”, probably from the prefix “climat” in glg, while sub-sep gives the totally unrelated translation of “college friend”. Some examples of bilingual lexicons that can be better captured by SDE can be found in Appendix A.3. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            537
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ae3451b4a0bd4117836a0d394f3ae30b9c37741aca74e40032ad836dfcd3dea6.jpg",
+        "table_caption": [
+            "Table 7: Examples of glg to eng translations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>glg</td><td rowspan=1 colspan=1>eng</td><td rowspan=1 colspan=1>sub-sep</td><td rowspan=1 colspan=1>SDE</td></tr><tr><td rowspan=1 colspan=1>Pero non temos a tec-noloxia para resolveriso, temos?</td><td rowspan=1 colspan=1>Butwe don&#x27;t havea technology to solvethat, right?</td><td rowspan=1 colspan=1>But we don&#x27;t havethe technology to solvethat, we have?</td><td rowspan=1 colspan=1>But we don&#x27;t havethe technology to solvethat, do we?</td></tr><tr><td rowspan=1 colspan=1>Se queres saber sobreo clima,preguntas a unclimatologo.</td><td rowspan=1 colspan=1>If you want to knowabout climate,you ask a climatologist.</td><td rowspan=1 colspan=1>If you want to knowabout climate,you&#x27;reasking a college friend.</td><td rowspan=1 colspan=1>If you want to knowabout climate,they askfor a weather.</td></tr><tr><td rowspan=1 colspan=1>Non é dicir que si</td><td rowspan=2 colspan=1>It&#x27;s not to say that if wehad all the money inthe world,we wouldn&#x27;twant to do it.</td><td rowspan=2 colspan=1>It&#x27;s not to say that wehad all the money inthe world,we didn&#x27;twant to do it.</td><td rowspan=2 colspan=1>It&#x27;s not to say that if wehad all the money inthe world, we wouldn&#x27;twant to do it.</td></tr><tr><td rowspan=1 colspan=1>tivesemos todo  0dineiro do mundo,nono quereriamos facer.</td></tr></table>",
+        "bbox": [
+            236,
+            551,
+            759,
+            690
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            354,
+            761
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In multilingual NMT, several approaches have been proposed to enhance parameter sharing of lexical representations. Zoph et al. (2016) randomly assigns embedding of a pretrained NMT model to the vocabulary of the language to adapt, which shows improvements over retraining the new embeddings from scratch. Nguyen & Chiang (2018) propose to match the embedding of the word piece that overlaps with the vocabulary of the new language. When training directly on concatenated data, it is also common to have a shared vocabulary of multilingual data (Neubig & Hu, 2018; Qi et al., 2018). Gu et al. (2018) propose to enhance parameter sharing in lexical representation by a latent embedding space shared by all languages. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Several prior works have utilized character level embeddings for machine translation (Cherry et al., 2018; Lee et al., 2017; Ataman & Federico, 2018), language modeling (Kim et al., 2016; Jozefowicz ´ et al., 2016), and semantic parsing (Yih et al., 2014). Specifically for NMT, fully character-level NMT can effectively reduce the vocabulary size while showing improvements for mulitlingual NMT (Lee et al., 2017), but it often requires much longer to train (Cherry et al., 2018). Ataman & Federico (2018) shows that character $n$ -gram encoding of words can improve over BPE for morphologically rich languages. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            318,
+            210
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Existing methods of lexical representation for multilingual NMT hinder parameter sharing between words that share similar surface forms and/or semantic meanings. We show that SDE can intelligently leverage the word similarities between two related languages by softly decoupling the lexical and semantic representations of the words. Our method, used without any subword segmentation, shows significant improvements over the strong multilingual NMT baseline on all languages tested. ",
+        "bbox": [
+            174,
+            226,
+            825,
+            295
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements: The authors thank David Mortensen for helpful comments, and Amazon for providing GPU credits. This material is based upon work supported in part by the Defense Advanced Research Projects Agency Information Innovation Office (I2O) Low Resource Languages for Emergent Incidents (LORELEI) program under Contract No. HR0011-15-C0114. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation here on. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            414
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            435,
+            285,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Duygu Ataman and Marcello Federico. Compositional representation of morphologically-rich input for neural machine translation. ACL, 2018. ",
+        "bbox": [
+            174,
+            459,
+            823,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015. ",
+        "bbox": [
+            174,
+            497,
+            823,
+            526
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Daniel Chandler. Semiotic: The Basics. 2007. ",
+        "bbox": [
+            174,
+            535,
+            478,
+            551
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Colin Cherry, George Foster, Ankur Bapna, Orhan Firat, and Wolfgang Macherey. Revisiting character-based neural machine translation with capacity and compression. CoRR, 2018. ",
+        "bbox": [
+            174,
+            560,
+            823,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Clark, Chris Dyer, Alon Lavie, and Noah Smith. Better hypothesis testing for statistical machine translation: Controlling for optimizer instability. In ACL, 2011. ",
+        "bbox": [
+            173,
+            598,
+            823,
+            627
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chris Dyer, Victor Chahuneau, and Noah A. Smith. A simple, fast, and effective reparameterization of IBM model 2. NAACL, 2013. ",
+        "bbox": [
+            176,
+            637,
+            821,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Orhan Firat, Kyunghyun Cho, and Yoshua Bengio. Multi-way, multilingual neural machine translation with a shared attention mechanism. NAACL, 2016. ",
+        "bbox": [
+            174,
+            675,
+            825,
+            704
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Algirdas Julien Greimas. Structural semantics: An attempt at a method. University of Nebraska Press, 1983. ",
+        "bbox": [
+            174,
+            713,
+            823,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiatao Gu, Hany Hassan, Jacob Devlin, and Victor O. K. Li. Universal neural machine translation for extremely low resource languages. NAACL, 2018. ",
+        "bbox": [
+            171,
+            752,
+            823,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Melvin Johnson, Mike Schuster, Quoc V. Le, Maxim Krikun, Yonghui Wu, Zhifeng Chen, Nikhil Thorat, Fernanda Viegas, Martin Wattenberg, Greg Corrado, Macduff Hughes, and Jeffrey Dean. ´ Google’s multilingual neural machine translation system: Enabling zero-shot translation. TACL, 2016. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            845
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rafal Jozefowicz, Oriol Vinyals, Mike Schuster, Noam Shazeer, and Yonghui Wu. Exploring the ´ limits of language modeling. Arxiv, 2016. ",
+        "bbox": [
+            176,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim, Yacine Jernite, David Sontag, and Alexander M. Rush. Character-aware neural language models. AAAI, 2016. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Taku Kudo. Subword regularization: Improving neural network translation models with multiple subword candidates. ACL, 2018.   \nJason Lee, Kyunghyun Cho, and Thomas Hofmann. Fully character-level neural machine translation without explicit segmentation. TACL, 2017.   \nMinh-Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attentionbased neural machine translation. In EMNLP, 2015.   \nGraham Neubig and Junjie Hu. Rapid adaptation of neural machine translation to new languages. EMNLP, 2018.   \nToan Q. Nguyen and David Chiang. Transfer learning across low-resource, related languages for neural machine translation. In NAACL, 2018.   \nYe Qi, Devendra Singh Sachan, Matthieu Felix, Sarguna Padmanabhan, and Graham Neubig. When and why are pre-trained word embeddings useful for neural machine translation? NAACL, 2018.   \nRico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In ACL, 2016.   \nIlya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In NIPS, 2014.   \nL.J.P. van der Maaten and G.E. Hinton. Visualizing high-dimensional data using t-SNE. Journal of Machine Learning Research, 2008.   \nAshish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NIPS, 2017.   \nJohn Wieting, Mohit Bansal, Kevin Gimpel, and Karen Livescu. Charagram: Embedding words and sentences via character n-grams. EMNLP, 2016.   \nWen-tau Yih, Xiaodong He, and Christopher Meek. Semantic parsing for single-relation question answering. ACL, 2014.   \nBarret Zoph, Deniz Yuret, Jonathan May, and Kevin Knight. Transfer learning for low resource neural machine translation. EMNLP, 2016. ",
+        "bbox": [
+            169,
+            94,
+            828,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 TRAINING DETAILS ",
+        "bbox": [
+            174,
+            133,
+            359,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• We use a 1-layer long-short-term-memory (LSTM) network with a hidden dimension of 512 for both the encoder and the decoder.   \n• The word embedding dimension is kept at 128, and all other layer dimensions are set to 512.   \nWe use a dropout rate of 0.3 for the word embedding and the output vector before the decoder softmax layer. The batch size is set to be 1500 words. We evaluate by development set BLEU score for every 2500 training batches. For training, we use the Adam optimizer with a learning rate of 0.001. We use learning rate decay of 0.8, and stop training if the model performance on development set doesn’t improve for 5 evaluation steps. ",
+        "bbox": [
+            215,
+            155,
+            825,
+            328
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 EFFECT OF VOCABULARY SIZE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            344,
+            434,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We examine the performance of SDE and the best baseline sub-sep, with a character $n$ -gram vocabulary and sub-word vocabulary respectively, of size of 8K, 16K, and 32K. We use character $n$ -gram of $n = \\{ 1 , 2 , 3 , 4 \\}$ for 8K and 16K vocabularies, and $n = \\{ 1 , 2 , 3 , 4 , 5 \\}$ for the 32K vocabulary. Figure 5 shows that for all four languages, SDE outperforms sub-sep with all three vocabulary sizes. This shows that SDE is also competitive with a relatively small character $n$ -gram vocabulary. ",
+        "bbox": [
+            173,
+            369,
+            825,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/dc919fe21aad9f9bce8ae0d505aae14bb5fa3c69349c759628e009b0a17e6f29.jpg",
+        "image_caption": [
+            "Figure 5: Performance on three different vocabulary size (results of a single random seed). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            453,
+            792,
+            541
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.3 EXAMPLE BILINGUAL WORDS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            583,
+            429,
+            598
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 8 lists some words and their subwords from bel and its related language rus. We can see that subwords fail to capture all the lexical similarities between these words, and sometimes the word pairs are segmented into different number of pieces. ",
+        "bbox": [
+            176,
+            609,
+            825,
+            652
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/5679082a5fbfd7d38f478cb79cf03412b19fc12d0d3b78bf71c16295edb46838.jpg",
+        "table_caption": [
+            "Table 8: Bilingual word pairs and their subword pieces. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">bel</td><td colspan=\"2\">rus</td><td rowspan=\"2\">eng</td></tr><tr><td>word</td><td>subword</td><td>word</td><td>subword</td></tr><tr><td>ΦiHaHcaBbII</td><td>diHaHcaBbI I</td><td>ΦHHaHCOBbIX</td><td>ΦHHaHCOBbI X</td><td>financial</td></tr><tr><td>CTaIbIéH</td><td>CTaJIbI éH</td><td>CTaJINOH</td><td>CTaJINOH</td><td>stadium</td></tr><tr><td>p03HbIX</td><td>p03HbI X</td><td>pa3HbIX</td><td>pa3HbI X</td><td>different</td></tr><tr><td>Iaka3aub</td><td>Haka3a Ib</td><td>IOKa3aTb</td><td>HOka3aTb</td><td>show</td></tr></table>",
+        "bbox": [
+            235,
+            664,
+            763,
+            771
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.4 ANALYSIS OF ATTENTION OVER LATENT EMBEDDING SPACE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            828,
+            645,
+            843
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section we compare the attention distribution over the latent embedding space of related languages, with the intuition that words that mean the same thing should have similar attention distributions. We calculate the KL divergence of the attention distribution for word pairs in both the LRL and HRL. Figure 6 shows that the lowest KL divergence is generally on the diagonals representing words with identical meanings, which indicates that similar words from two related languages ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/3054732b90341671e9be359ad64e880509e24178447ce3fc6c8820a4f62774e7.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            558,
+            126,
+            792,
+            277
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/c8d32e289cdae151e52a7b40a1f0fc623ed1f168cddf391beaec0267e7d1a8af.jpg",
+        "image_caption": [
+            "Figure 6: KL divergence of attention over latent embedding space between words from two related languages. Word pairs that match at the diagonal have similar meanings. Left: bel-rus. Right: glg-por. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            116,
+            495,
+            276
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/6b672b28fa8ed6456c2b5998a14c59c6fc4ed164b780ada3db8cc5a063d865b1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>glg</td><td>eng</td><td>por</td><td>eng</td></tr><tr><td>cando</td><td>when</td><td>quando</td><td>when</td></tr><tr><td></td><td>label</td><td>caindo r6tulo</td><td>failing down</td></tr><tr><td>etiqueta</td><td></td><td></td><td>label</td></tr><tr><td></td><td></td><td>riqueza</td><td>wealth</td></tr></table>",
+        "bbox": [
+            348,
+            358,
+            648,
+            449
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 9: Words in glg-por that have the same meaning but different spelling, or similar spelling but different meaning. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            488
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "tend to have similar attention over the latent embedding space. Note that this is the case even for words with different spellings. For example, Figure 6 right shows that the KL divergence between the glg word “musicos” (meaning “musicians”), and the por word of the closet meaning among the ´ words shown here, “jogadores” (meaning “players”), is the smallest, although their spellings are quite different. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            585
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.5 ANALYSIS OF WORD VECTORS FROM SDE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            602,
+            517,
+            616
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section, we qualitatively examine the location of word vectors at different stages of SDE. We reduce the word vectors to two dimensions using t-SNE (van der Maaten & Hinton, 2008). In particular, we focus on two groups of words shown in Table 9 from glg-por, where each word from glg is paired with two words from por, one with the same meaning but different spelling, while the other has similar spelling but different meaning. Figure 7 left shows the embeddings derived from the character $n$ -grams. At this stage, the word “cando” is closer to “caindo”, which has a different meaning, than “quando”, which has the same meaning but a slightly more different spelling. The word “etiqueta” lies in the middle of “rotulo” and “riqueza”. After the whole encoding process, the ´ location of the words are shown in Figure 7 right. At the final stage, the word “cando” moves closer to “quando”, which has the same meaning, than “caindo”, which is more similar in spelling. The word “etiqueta” is also much closer to “rotulo”, the word with similar meaning, and grows further ´ apart from “riqueza”. ",
+        "bbox": [
+            173,
+            628,
+            825,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/786f8a080f738703196e453dbdefef629893c04b20e62e084b0708e7d96b8388.jpg",
+        "image_caption": [
+            "Figure 7: T-SNE visualizations of the embeddings of words in Table 9 encoded after the character $n$ -gram embedding stage $( L e f t )$ , or after the full process of SDE(Right). Words of the same color have similar meanings, and the language code of the word is placed in the parenthesis. It can be seen that the character embedding stage is more sensitive to lexical similarity, while the full SDEmodel is more sensitive to similarity in meaning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            382,
+            790,
+            558
+        ],
+        "page_idx": 12
+    }
+]

parse/train/SyxvSiCcFQ/SyxvSiCcFQ_content_list.json

@@ -0,0 +1,1468 @@
+[
+    {
+        "type": "text",
+        "text": "NEURAL NETWORK COST LANDSCAPES AS QUANTUM STATES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Quantum computers promise significant advantages over classical computers for a number of different applications. We show that the complete loss function landscape of a neural network can be represented as the quantum state output by a quantum computer. We demonstrate this explicitly for a binary neural network and, further, show how a quantum computer can train the network by manipulating this state using a well-known algorithm known as quantum amplitude amplification. We further show that with minor adaptation, this method can also represent the meta-loss landscape of a number of neural network architectures simultaneously. We search this meta-loss landscape with the same method to simultaneously train and design a binary neural network. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            404
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            428,
+            336,
+            444
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Finding a suitable set of weights for a neural network has become one of the most studied problems of modern machine learning. It has presented a significant challenge to computer scientists for whom few successful alternatives to back-propagation are available. It can be difficult to explore very large search spaces efficiently and, worse, optimization may converge to a local minima far from global optimum (Choromanska et al., 2015). Understanding the cost function landscape is also hard, and choosing hyper-parameters and designing neural networks remains mostly a manual process. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As Moore’s law approaches its end, two new computing paradigms have been explored, neuromorphic and quantum computers. Quantum computing is based on quantum bits (or qbits) obeying the laws of quantum physics as opposed to the classical bits of today that are based on classical physics. Note that in physics the term classical is used to mean non-quantum and we use this terminology throughout. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Quantum machine learning aims to find an advantage in applying quantum computing to machine learning. Current research into quantum machine learning falls into one of two catgeories. Some quantum algorithms promise a revolution in machine learning in theory, but contain many gaps in their implementation in practice. In contrast, others are more realistic in their method, but struggle to justify a place amongst the well-established methods of machine learning. ",
+        "bbox": [
+            174,
+            625,
+            823,
+            694
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, it is shown that a quantum computer can output a quantum state that represents the entire cost landscape for a given neural network. The method is shown to be versatile and even able to represent a meta-cost landscape of all possible hyperparameters and parameters. Applying it to the connectivities and weights of a binary neural network and simulating the quantum algorithm on a classical computer, we further show that this landscape state can be used for training and metatraining the binary neural network for a small toy problem using quantum amplitude amplification, a standard quantum algorithm. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            810,
+            344,
+            827
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2.1 BINARY NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            419,
+            856
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Binary Neural Networks (BNNs) are neural networks with weights and activations restricted to taking only binary values, usually $\\pm 1$ . The greatest advantage of BNNs is in their deployment as using binary provides great advantages in compression and inference time, as well as computational efficiency through the use of bitwise operations. On the other hand they are relatively tricky to train as the sign function has a derivative of zero nearly everywhere, the search space is discrete, and alternative training methods take significantly longer than non-binarized neural networks. Nonetheless, BNNs have achieved state-of-the-art performance on smaller datasets such as MNIST and CIFAR10 (Courbariaux et al., 2016) but initially suffered when applied to larger datasets such as ImageNet. A popular approach to solving this issue has been to relax the binarisation constraints. This has been achieved by using multiple binary activations (Lin et al., 2017) or by introducing scale factors (Rastegari et al., 2016), both of which result in improvements in accuracy. On the other hand, it has been argued that a better training strategy for BNNs is sufficient to achieve high accuracy on large datasets without compromising on the pure binary nature (Tang et al., 2017). After investigating the accuracy failures of the previous methods, a number of improvements to the BNN training process have been suggested such as changing the activation function, lowering the learning rate and using a different regularization term. These changes helped achieve both high accuracy and high compression rates on ImageNet. Again, this solution is not entirely ideal, as training BNNs is already relatively slow, and a lower learning rate exacerbates this issue. Between the efficient deployment, discrete search space, slow training and relatively small problem size (near-term quantum computers favor problems that require fewer bits), training a binary neural network represents an ideal test case for a quantum computer. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            104,
+            825,
+            339
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, BNNs have been suggested as a candidate for efficient hybrid architectures through transfer learning. The idea is that a BNN pretrained on ImageNet may be used as a feature extractor for other datasets by retraining a final non-binarised layer. In this way, a hybrid hardware-software architecture can implement the binary part using efficient hardware and the non-binary final layer in software (Leroux et al., 2017). ",
+        "bbox": [
+            174,
+            339,
+            823,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 QUANTUM MACHINE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            425,
+            439,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Quantum computers use quantum bits, manipulated with quantum gates in quantum circuits according to quantum algorithms. The advantage of quantum computers over classical computers is that certain quantum algorithms show significantly improved computational complexity compared to the best known classical algorithms. Such improved scaling, combined with the exponentially growing computational power of qubits suggests that (large, error-free) quantum computers would be able to easily handle and process very large amounts of data. Most relevant to this paper is the quantum search algorithm known as Grover’s algorithm (Grover, 1996), itself a specific case of another algorithm known as quantum amplitude amplification (Brassard et al., 2002). These algorithms can√ search for an element of an unstructured dataset of size $N$ in $O ( { \\sqrt { N } } )$ operations, over the classical $O ( N )$ . It is important to keep in mind that these are compared to the best-known classical algorithms, and not that they are better than all possible classical algorithms. A recent paper (Tang, 2018) has challenged the presumed superiority of a quantum recommendation algorithm with a new classical algorithm inspired by the quantum method that shows similar scaling. In our case, the optimality of Grover’s algorithm has been proven (Zalka, 1999) and so the assumption of its inherent advantage is robust. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            660
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Some quantum algorithms are able to efficiently perform $k$ -means clustering (Lloyd et al., 2013) and solve linear systems of equations (Harrow et al., 2009), among other such achievements (see Ciliberto et al. (2018) for a review). All of these algorithms require the classical data to be encoded into an accessible quantum form of RAM known as a qRAM. Although there is some work on how this might be done (Giovannetti et al., 2008) it is not known to even be possible to construct a qRAM in an efficient manner for a completely general dataset. To many, this is a significant drawback that cannot be ignored, and places a heavy burden on the feasibility of these methods. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            757
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An alternative approach has been to mimic the progress of classical machine learning by using methods classically known to work. Many have taken to using classical computers to train parametrized quantum circuits to perform classification (Stoudenmire & Schwab, 2016a) or to learn generative models (Dallaire-Demers & Killoran, 2018). Some, but not all, of these circuits mimic neural networks in that they are layered and try to utilize non-linearities Killoran et al. (2018). The biggest issue with this approach is the lack of an efficient algorithm for training quantum circuits and so current methods are akin to black box optimization. The motivation is that the output of quantum circuits are known to be impossible to efficiently simulate with classical computers and could therefore provide superior performance on that basis. A slightly different approach to training a perceptron using quantum amplitude amplification has been explored before and its complexity studied compared to classical methods (Kapoor et al., 2016). Previous work has demonstrated and experimentally implemented the use of quantum hardware to perform binary classification, (Neven et al., ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2009) but this is not the same as the method proposed in this paper, as this work is based on a different, more general gate-based form of quantum computation as opposed to the quantum annealing devices of the former. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 QUANTUM COMPUTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            169,
+            403,
+            185
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Quantum computing follows the structure of classical computing very closely. Quantum bits, or qubits, are the fundamental unit of quantum information. Their values are manipulated by applying quantum (logic) gates to them in the form of quantum circuits. ",
+        "bbox": [
+            176,
+            202,
+            821,
+            243
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Qubits are challenging to manufacture in practice due to the noise-sensitive nature of quantum properties. The biggest such device in existence today contains just 72 highly imperfect qubits, but it is worth noting that progress has advanced at a particularly rapid pace over the past few years and a number are available for public access on the cloud. In addition, simulating the behaviour of qubits using classical computers is difficult, requiring exponentially increasing resources as the number of qubits increases - with an upper limit of 50 (perfect) qubits often cited for the most powerful supercomputers. Therefore, quantum algorithms are almost always defined in terms of their circuit implementation, as opposed to the higher level abstraction of classical algorithms. ",
+        "bbox": [
+            174,
+            244,
+            825,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 QUBITS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            375,
+            267,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Qubits are the unit of quantum information and are fundamentally different to classical bits. Whilst classical bits are completely described as being in one of two states, either 0 or 1, the state of a qubit cannot be fully described by just a single number. It can be in the 0 state, the 1 state or a quantum superposition of both. Mathematically the state of a qubit is a two dimensional vector with complex elements and a unit norm. We can write a general form for this vector as $( \\alpha \\beta e ^ { i \\phi } ) ^ { T } \\equiv$ $\\alpha \\left| 0 \\right. + \\beta e ^ { i \\phi } \\left| 1 \\right.$ with $| \\alpha | ^ { 2 } + | \\beta | ^ { 2 } = 1$ , $\\mathbf { \\Psi } | 0 \\rangle \\equiv \\left( 1 \\begin{array} { l l } { 0 } & { 0 } \\end{array} \\right) ^ { T }$ , ${ \\left| 1 \\right. } \\equiv { \\left( 0 \\begin{array} { l l } { 1 } \\end{array} \\right) } ^ { T }$ . Here $\\alpha$ and $\\beta$ are the probability amplitudes of the zero state $| 0 \\rangle$ and the one state $| 1 \\rangle$ respectively. Qubits cannot be simply read out as classical bits are, but are instead measured. Measurement is a unique feature of quantum mechanics. If the qubit given above is measured, it will be found in the zero state with probability $| \\alpha | ^ { 2 }$ , outputting a value of 0, and the one state with probability $| \\beta | ^ { 2 }$ outputting a value of 1. Therefore measurement of a qubit state always produces a binary outcome, no matter the actual state itself. Measurement is fundamentally indeterministic, probabilistic and irreversible. Upon measurement, the original state is lost along with the values of $\\alpha$ and $\\beta$ as the qubit collapses to the state $| 0 \\rangle$ or $| 1 \\rangle$ corresponding to the measurement outcome. As a result, the values $\\alpha$ and $\\beta$ cannot be obtained without repeated measurements of many identical copies of the state. Here $\\phi$ is a phase that does not affect measurement outcome, but can be manipulated with quantum gates and play a role in quantum algorithms. Part of the power of quantum computing is the ability to harness superposition to parallelize certain computations and processes. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An important feature of qubits is the way in which they are combined. $N$ qubits are collectively described by a complex vector of unit norm in a similar way as the above, but the length of this vector is given by $2 ^ { N }$ . It is this exponential scaling that makes even modest numbers of qubits unfeasible to simulate on a classical computer. ",
+        "bbox": [
+            176,
+            655,
+            823,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 QUANTUM GATES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            339,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In both classical and quantum computing, gates manipulate the states of bits and qubits. As complex vectors, qubit states are transformed into one another by applying complex matrices called operators or simply, quantum gates. This transformation follows the rules of linear algebra and a state $| \\psi \\rangle$ is transformed into a different state $| \\phi \\rangle$ by a gate $U$ according to the matrix transformation $| \\phi \\rangle =$ $U \\left| \\psi \\right.$ . In order to maintain the stringent requirement of a unit norm, these matrices are restricted to being unitary. A unitary matrix is defined as any square matrix who’s inverse is its complex conjugate transpose. Unitarity implies that every quantum gate is reversible, in a manner similar to reversible computing. This fundamental difference in the kinds of operations that can be performed on qubits compared to classical bits is part of the power of quantum computing, but can make analogies to classical computing difficult. Many quantum operations have no classical analogue and conversely, certain simple classical operations (e.g copying the state of a general qubit) are impossible in quantum computing. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "COMMON GATES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            294,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Just as in classical computing, small sets of quantum gates are universal in that they can be combined to generate any other. It transpires that a small set of quantum gates are sufficient to our work and we choose to list them here, both in terms of their actions and their matrix forms. ",
+        "bbox": [
+            174,
+            127,
+            823,
+            170
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The X (NOT) gate flips the state of a qubit from $| 1 \\rangle$ to $| 0 \\rangle$ and vice versa. For qubits in superposition, it swaps the amplitudes of the $| 1 \\rangle$ and $| 0 \\rangle$ states. Its matrix form is ",
+        "bbox": [
+            173,
+            170,
+            821,
+            198
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f58b58f732c5ac7dcfe8a4e04d593a1caf07ff9432b692715fc3679447471b9.jpg",
+        "text": "$$\nX = { \\binom { 0 } { 1 } } \\quad 0 \\quad\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            204,
+            547,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Z gate has no classical analogue and takes the matrix form ",
+        "bbox": [
+            173,
+            244,
+            588,
+            258
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/240b6fc0977d29e395082be77b22bbbc437553812c6737e95490860b6eb0511d.jpg",
+        "text": "$$\nZ = { \\binom { 1 } { 0 } } \\quad { \\overset { 0 } { - } } 1 )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            263,
+            553,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It transforms an arbitrary state $\\alpha \\left| 0 \\right. + \\beta \\left| 1 \\right.$ into the state $\\alpha \\left| 0 \\right. - \\beta \\left| 1 \\right.$ . The probability amplitude of the $| 1 \\rangle$ component has changed sign, but the probabilities associated with measurement outcome, as squares of the probability amplitudes, remain unchanged. Note that this still represents a completely different state. ",
+        "bbox": [
+            173,
+            304,
+            825,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Hadamard $\\mathrm { ( H ) }$ gate also has no classical analogue. It is used to transform qubits from their initial state $| 0 \\rangle$ into the state $\\textstyle { \\frac { 1 } { \\sqrt { 2 } } } \\left| 0 \\right. + { \\frac { 1 } { \\sqrt { 2 } } } \\left| 1 \\right.$ - an equal quantum superposition of 0 and 1. As a matrix it is ",
+        "bbox": [
+            174,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fd461f85a4b2acc1b87819e73781524e306168388df5a16143274cb54f97ff9.jpg",
+        "text": "$$\nH = \\frac { 1 } { \\sqrt { 2 } } \\left( \\begin{array} { c c } { 1 } & { 1 } \\\\ { 1 } & { - 1 } \\end{array} \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            400,
+            568,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The controlled-not (CNOT) gate can be thought of as a generalisation of the classical XOR gate. It performs a NOT gate on a target qubit if a control qubit is in the state $| 1 \\rangle$ . We write this as ",
+        "bbox": [
+            173,
+            436,
+            825,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32ca26dcde21d6aa910b08d46df14a930b5067e292ff5660d5a90d52b9383a4f.jpg",
+        "text": "$$\nC N O T = \\left( \\begin{array} { c c c c } { { 1 } } & { { 0 } } & { { 0 } } & { { 0 } } \\\\ { { 0 } } & { { 1 } } & { { 0 } } & { { 0 } } \\\\ { { 0 } } & { { 0 } } & { { 0 } } & { { 1 } } \\\\ { { 0 } } & { { 0 } } & { { 1 } } & { { 0 } } \\end{array} \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            472,
+            593,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that controlled gates can be extended both to arbitrary gates (e.g. CZ) and to arbitrary numbers of control qubits (e.g. CCCNOT). ",
+        "bbox": [
+            173,
+            536,
+            823,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            282,
+            601
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The main advantage of qubits over classical bits is their ability to be placed and processed in quantum superpositions of states. The key to our method is to use superposition to parallelize the processing of weights in a way not possible classically. Our scheme proceeds as follows: ",
+        "bbox": [
+            174,
+            616,
+            823,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "General Scheme ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            666,
+            290,
+            679
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Step 1: The weights are represented in some way by the quantum state of a set of qubits. Setting those qubits into a state that represents an equal superposition of every possible set of weights allows them to define the domain. ",
+        "bbox": [
+            176,
+            680,
+            823,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Step 2: We then build a quantum circuit analogue of the neural network $U _ { Q N N }$ that takes in a given set of weights (encoded within qubits as above) and an empty register, and outputs onto the register the corresponding accuracy according to the chosen neural network i.e $U _ { Q N N } ( w , 0 ) = ( w , a c \\bar { c } _ { w } )$ . ",
+        "bbox": [
+            174,
+            722,
+            823,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Step 3: Since $U _ { Q N N }$ is a quantum circuit, inputting weights in superposition form allows them to be processed in parallel. Thus by using the domain-defining qubits as the weights input to $U _ { Q N N }$ the output will be a superposition correlating all possible weights to their corresponding accuracies. This is what we refer to as the landscape state. We can write this as ",
+        "bbox": [
+            174,
+            763,
+            825,
+            818
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3c059636bf1cd03897cf69f988413d2647a287b597f2fa3dd39b844f2f822f23.jpg",
+        "text": "$$\n\\frac { 1 } { \\sqrt { W } } \\sum _ { w \\in \\mathbb { W } } ( w , O _ { w } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            824,
+            562,
+            862
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { W }$ is the set of all possible weights, $W$ is its size and $O _ { w }$ the accuracy of the neural network given the set of weights $w$ . This is a single quantum state representing the entire landscape of the neural network by correlating every possible set of weights with its resultant accuracy. In the language of quantum physics the weights and the accuracies are entangled. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a2937bee2c3ef997891eac9f6227c01431afd44a5fd50b15251c85df700526e.jpg",
+        "image_caption": [
+            "Figure 1: The structure of the BNN we are training. It has a total of eight binary weights. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            297,
+            102,
+            705,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This method can be adapted in many ways. For example, if just a single weight is set it to superposition and the rest kept to a given value, then the output is the cost landscape of just that one weight conditional on the value of the others. We are not limited to only setting weights in superposition. We note that a meta-neural network with the presence/absence of the connections within the neural network themselves represented by binary parameters can also be created. These meta-parameters can also be encoded in qubits, formed into a quantum circuit and set to superposition. If we set both the weights and the connection meta-parameters to superposition then the output state of the quantum circuit contains an entire meta-cost landscape of every possible weight with every possible connectivity of a neural network simultaneously correlated with the respective accuracy. ",
+        "bbox": [
+            173,
+            262,
+            825,
+            388
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXAMPLE: TRAINING A BINARY NEURAL NETWORK",
+        "text_level": 1,
+        "bbox": [
+            173,
+            404,
+            583,
+            419
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate our method by generating the landscape state for a small binary neural network on simple toy problems and use it to train the network. The advantage of binary neural networks is that each weight can be naturally represented by just one qubit and so are therefore a suitable demonstration given the fundamentally small number of qubits that can be simulated on a nonquantum device. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 PROBLEM STATEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            517,
+            370,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We construct two toy problems, both of which are a binary classification on three binary features $x _ { i } \\in \\{ - 1 , 1 \\}$ of eight data points corresponding to every $2 ^ { 3 }$ arrangement of those features. In problem 1, the label is given by the function ",
+        "bbox": [
+            173,
+            542,
+            825,
+            584
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8fe49b8323b3848c51ca9d6af2fbd49dd4d6814fedc3a9d5e2149b2b89af36d.jpg",
+        "text": "$$\ny ( x _ { 1 } , x _ { 2 } , x _ { 3 } ) = s i g n ( x _ { 3 } x _ { 1 } + x _ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            589,
+            612,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and for problem 2 the label is given by ",
+        "bbox": [
+            174,
+            611,
+            429,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd13cacd43db12603c8ec14c0506bb6bf062377ddbd16ff4dcbd58ad32910b12.jpg",
+        "text": "$$\ny ( x _ { 1 } , x _ { 2 } , x _ { 3 } ) = s i g n ( x _ { 1 } + x _ { 2 } + x _ { 3 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            630,
+            622,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In both cases we define the sign function as: ",
+        "bbox": [
+            174,
+            652,
+            464,
+            666
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/81ce872814994d306c13caa1db7fb3a7992ef657153c819d097426073472aa6c.jpg",
+        "text": "$$\ns i g n ( x ) = { \\left\\{ \\begin{array} { l l } { 1 , } & { { \\mathrm { i f ~ } } x \\geq 0 . } \\\\ { - 1 , } & { { \\mathrm { o t h e r w i s e } } . } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            672,
+            596,
+            708
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We choose to implement the BNN given in figure 1 meaning that we are aiming to find eight binary weights. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 CONSTRUCTING THE QUANTUM BINARY NEURAL NETWORK (QBNN) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            704,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To construct a quantum circuit equivalent to the BNN, henceforth known as the Quantum Binary Neural Network (QBNN), every operation in the implementation of a BNN must be mapped to a quantum equivalent. Below we detail each of these and their quantum implementation. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Representing Numerical Values ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            832,
+            395,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Representing numerical values with qubits is already well established in the literature (Stoudenmire & Schwab, 2016b). Other parts of our construction are, however, incompatible with non-binary input and so we restrict ourselves to the simple case of a binary data input. In this case, the qubit states $| 1 \\rangle$ and $| 0 \\rangle$ represent the values $+ 1 , - 1$ respectively. In a quantum circuit, all qubits begin in the $| 0 \\rangle$ state and need only an application of a single NOT gate to be set to $| 1 \\rangle$ where appropriate. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c31900540573f5a4126b72f693124b1d977ebb8d07f4d240808d6099b0419e9a.jpg",
+        "image_caption": [
+            "Figure 2: A quantum circuit (right) corresponding to the neuron (left). Quantum circuits are read from left to right just like classical computing circuits. The first group of operations on the weights are initialising them into a superposition of all their values using Hadamard gates (red). The first group of operations on the inputs are encoding the features onto the qubits (blue). They are either blank (if the input values are already -1) or NOT gates if the desired input values are 1. The following three quantum operations are the anti-CNOT gates that weight each input according to its corresponding weight (green). The final set of operations (purple) are a combination of multi-qubit, controlled and anti-controlled NOT gates that together correspond to the sign function. They can be seen to flip the state of the ancilla qubit to $+ 1$ if either all the weighted input values are in the state $+ 1$ , or if any two of them are in the state $+ 1$ . Ancilla qubits are additional ’helper’ qubits. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            104,
+            826,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Multiplying values by binary weights ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            450,
+            433,
+            464
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given two qubits representing binary values $\\pm 1$ as described above, we can multiply them using an anti-CNOT gate. An anti-CNOT gate applies a NOT gate to a target qubit if the control qubit is in the state $| 0 \\rangle$ instead of $| 1 \\rangle$ . Its truth table is identical to an XNOR gate and outputs $| 1 \\rangle$ if both input values are equal, and $| 0 \\rangle$ otherwise. This truth table matches the truth table of multiplying two binary values and thus performs the same function. It can be constructed using two NOT gates and a CNOT gate. Qubits that encode weights must always be used as control qubits to preserve the values they encode. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            560
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementing the Activation Function ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            442,
+            582
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since the sign function is highly non-linear, it poses the greatest challenge to translate to the linear algebra-based language of quantum mechanics. Generally, the problem can be overcome by the addition of extra helper or ’ancilla’ qubits. If we restrict the problem to the special case of binary arguments only, the sign function1 is reduced to finding whether there exist $N / 2$ qubits out of $N$ in state $| 1 \\rangle$ . This can be achieved by constructing a quantum analogue of a classical majority function by replacing AND gates with CCNOT gates and constructing OR gates out of CNOT and NOT gates. The number of gates needed scales as the binomial coefficient $N$ choose $N / 2$ . As an example, figure 2 shows a three input neuron and its quantum circuit implementation. Note that this is just a single neuron, and not our entire network. In practice, it works in the same manner as a classical neural network. The activations of each neuron in one layer are then weighted by their own weight qubits and used as input to the next layer and so on. This whole circuit is what we refer to as the QBNN. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Calculating Accuracy ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            742,
+            326,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For each data point on the training set we must compare the prediction to the label in order to find the accuracy. We initialise a register of qubits to store the predictions. The reversibility of quantum circuits allows us to apply the QBNN for a given data point, store its output value onto its corresponding qubit on the register, perform the same QBNN in reverse order - its inverse - to refresh the other qubits, and continue for the next data point in the training set. This resetting is a common, necessary workaround for small quantum computers and is easily avoided by parallelization given more qubits. For a training set of size $N$ , we obtain a register of $N$ qubits containing the predictions of the QBNN for each of them. Since both the labels and the outputs are binary, we can represent the accuracy of each of these predictions by performing a NOT gate on all the qubits corresponding to a data point with a label of 0. Each qubit in this register will then be in the state $| 1 \\rangle$ if it corresponds to a correctly classified data point and $| 0 \\rangle$ if it does not. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 QUANTUM TRAINING FROM THE LANDSCAPE STATE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            150,
+            576,
+            164
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "By applying the QBNN over the entire training set with the weights initialized in superposition, our circuit output is the cost landscape state. Training the BNN can be seen as a search for a single state within the cost function landscape, for which we use a quantum algorithm known as quantum amplitude amplification. It is not the first time that quantum amplitude amplification has been suggested as a means to train quantum neural networks (Ricks & Ventura, 2004), but they did not construct the actual details of an implementation such as the method of generating a nonlinearity. Quantum amplitude amplification is a technique to amplify the probability amplitudes that correspond to desired state(s) within the superposition and therefore increase the probability of measuring one of these. It works by splitting the space of all states into a ’good’ and a ’bad’ subspace and rotating their relative probabilities when measured. In this case the ’good’ subspace is defined as that which has all the qubits in the prediction register in the state $| 1 \\rangle$ implying that all data points have been correctly classified. It is known that quantum amplitude amplification requires just√ $\\mathcal { \\bar { O } } ( 1 / \\sqrt { a } )$ to search for an entry with an occurrence probability of $a$ (Brassard et al., 2002). Quantum amplitude amplification works by first constructing the amplifying operator, $Q$ . ",
+        "bbox": [
+            173,
+            175,
+            825,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b910cf2a481306e047f9ac50ce2cb83fb93b831c2be9c1f4283771500dafbd07.jpg",
+        "text": "$$\nQ \\equiv - U _ { Q B N N } S _ { 0 } U _ { Q B N N } ^ { - 1 } S _ { \\chi }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            376,
+            604,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The composite operation, $Q$ , is interpreted as a sequence of operations applied from right to left as read in the equation above. $U _ { Q B N N }$ is our entire QBNN circuit (for all data points), and $U _ { Q B N N } ^ { - 1 }$ is its (matrix) inverse. Since quantum gates are reversible, and every gate we have used is self-inverse, we obtain this by applying all of the gates of $U _ { Q B N N }$ in reverse order. The operations $S _ { 0 }$ and $S _ { \\chi }$ reverse the sign of the probability amplitudes of the initial state and the target state(s) respectively. In this case, our target states correspond to those with an accuracy of $1 0 0 \\%$ and $S _ { \\chi }$ is a controlled-Z gate performed on each of the target qubits. Similarly, the initial state of any quantum computer is defined as having all the qubits in the state $| 0 \\rangle$ , and thus we can implement $S _ { 0 }$ by first applying a NOT gate to each qubit and then applying the same controlled-Z gates as for $S _ { \\chi }$ . ",
+        "bbox": [
+            174,
+            402,
+            825,
+            530
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 is a pictorial representation of how quantum amplitude amplification changes the probability distribution of the measured weights. If we write the initial probability of obtaining the correct weights by random as $p$ and the number of successive applications of operator $Q$ to be $k$ , it can be shown that the probability of obtaining the optimal weights when measuring the circuit after $k$ amplifications is ",
+        "bbox": [
+            174,
+            530,
+            825,
+            598
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f379ecb6ac89572625b710590b91317455ba52eca18093bfd3508ae96ab3733.jpg",
+        "text": "$$\n\\sin ^ { 2 } ( 2 k + 1 ) \\theta\n$$",
+        "text_format": "latex",
+        "bbox": [
+            450,
+            597,
+            547,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $p$ and $\\theta$ obey the relation $p = \\sin ^ { 2 } \\theta$ (Brassard et al., 2002). The probability of success is therefore highly periodic in $k$ . The problem of training the BNN essentially reduces to a probabilistic search on this one hyper-parameter and its regular periodic landscape. The location of the first maximum, i.e of $k ^ { * }$ , is inversely proportional to $\\theta$ and hence to the probability of obtaining the weights by random. In other words, a harder problem with more weights to search requires a greater number of quantum amplifications to find. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In practical terms the landscape state is a set of 8 weight qubits and 8 prediction qubits. After the search, at the end of the entire process, all the qubits are measured. If the prediction qubits are all in the state $| 1 \\rangle$ the training was a success and the appropriate weights can be simply read off their corresponding qubits. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            760
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            281,
+            796
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We constructed and simulated the QBNN and quantum amplitude amplification circuits on the projectQ framework (Steiger et al., 2018). The use of an actual quantum computer was not possible as the number of gates used during the computation (called circuit depth) exceeds the maximum possible circuit depth for the current generation of imperfect noisy qubits. Furthermore, we use more qubits than are available on current publicly accessible quantum hardware. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            882
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For each of the two problems defined, we plotted the probability of obtaining an optimal set of weights against the number of iterations of the quantum amplitude amplification and obtained results, shown in figure 4, that match well with the expected periodic behavior described in equation 3. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f372c50b5bf5b5fcce3e8c6b52288ce7ff503e3317ea2d9bf6683007e4bdc67a.jpg",
+        "image_caption": [
+            "Figure 3: The change in the probability distribution of output weights under quantum amplitude amplification after $k$ iterations where (a) $k = 0$ , i.e random , (b) $k$ is sub-optimal (c) $k$ is near optimal. The black data point represents the optimal configuration. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            261,
+            113,
+            728,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This confirms that a quantum search of the landscape state can indeed be used to train a BNN in exactly the manner as predicted theoretically. We emphasize here that every reference to finding optimal weights means that the BNN has been trained to an accuracy of $1 0 0 \\%$ on the training data. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            498
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/dfb3e5011e745d40c6216e8192bab9b7fbb36ca403cf55a83aafb4aaa792b9e7.jpg",
+        "image_caption": [
+            "Figure 4: A plot showing the relationship between the probability of obtaining an optimal set of weights against the number of quantum amplifications, $k$ , for problem 1 (a) and problem 2 (b). Each point represents a simulation of 50 separate runs of the algorithm at the given $k$ and the probability of success of those 50 runs. The error bars represent $9 5 \\%$ confidence intervals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            529,
+            813,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to demonstrate the performance of this method in actual training, we follow the simple algorithm described in Brassard et al. (2002) for probing this landscape. This simple algorithm begins with $n = 0$ and chooses a random integer $k$ of quantum amplifications between 0 and $n , ~ n$ increases by 1 until the training succeeds. In our experiment, we perform 100 runs of this algorithm and present in figure 5 a cumulative plot of the proportion of these runs that were successful against the number of iterations this algorithm required. We find that training succeeds with a probability over $9 0 \\%$ after just 5 steps for the first problem and 6 steps for the second. In order to compare this to a classical search, we search the entire space of $2 ^ { 8 } = \\bar { 2 } 5 6$ possible sets of weights and find that there are eight and four correct sets of weights (giving $1 0 0 \\%$ accuracy) for the first and second problem respectively. Statistically, if these weights were to be searched through the analogous classical brute force search, one would find that it requires 28 and 57 steps respectively to succeed with a confidence over $9 0 \\%$ . This matches our expectation of a quadratic speedup of the quantum search over the classical. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4d510aebbe57e6f7a59ac38e2c64f5f2a867466400e7d8cbd1e3cf55a1b1901a.jpg",
+        "image_caption": [
+            "Figure 5: A plot comparing the scaling of a quantum search algorithm over a classical one. The quantum data is the cumulative probability of success over 100 runs of the algorithm. Classical results are analytically derived from the known probability of obtaining a solution by random search. The superior scaling of the quantum algorithm becomes more prominent for harder problems. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            117,
+            813,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            383,
+            825,
+            425
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.1 QUANTUM METATRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            443,
+            403,
+            457
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We then construct a more complex QBNN which can incorporate meta-training by introducing a set of binary indicators that correspond to the presence or absence of a set of connections within the BNN and encode these within qubits in the exact same way as was done with the weights. With the weights and connection parameters both set to superpositions, the output of this circuit is the meta-cost landscape, where weights, connections and accuracy are all entangled with one another. As before quantum amplitude amplification is used to search for the state with all points correctly classified. Again this has been suggested before, but we present a full circuit implementation of this idea (da Silva et al., 2016). ",
+        "bbox": [
+            174,
+            468,
+            825,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In practice, due to qubit number constraints, we choose to only learn the structure of the first layer of the BNN. The second layer remains fixed. Due to the increased size of the circuit, and the significant increase in computational cost, we did not perform a complete classical search of the space as before but it is clear to see that the space of parameters we are searching has increased and therefore the number of amplifications required has similarly increased. Between 16 and 20 amplifications were found to be sufficient to produce results with a reasonable probability. Figure 6 (a) shows the metaBNN that was used, and (b) and (c) show two solutions to problems 1 and 2 respectively learnt by our meta-QBNN. It is particularly interesting to note that the learned structures of the two BNN solutions seem to match well with their problem definitions (equation 1 and equation 2). Note that due to our circuit construction a neuron that receives no input will always output $- 1$ . ",
+        "bbox": [
+            174,
+            580,
+            825,
+            718
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CONCLUSIONS AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            739,
+            472,
+            755
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We show that quantum superposition can be used to represent many parameters of a neural network at once and efficiently encode entire loss landscapes in a quantum state using just a single run of a quantum circuit. We demonstrate this explicitly for both parameters and hyper-parameters of a BNN, and show that further processing of this state can lead to quantum advantage in training and metatraining. As a training method it possesses significant advantages as it is landscape-independent, has a quadratic speedup over a classical search of the same kind, and would be able to solve statistically neutral problems such as parity problems (Thornton, 1996). It is not, however, without shortcomings. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One potential criticism is the issue of over-fitting. Since our problem is so small, we chose to define a target state as one where the accuracy is $1 0 0 \\%$ on the training set but this is rarely desirable in real machine learning. One solution may be to simply run the quantum algorithm and, upon finding a particular set of weights that represents an overfit, run the algorithm again but with a deselection of that particular set of weights. This can be done by simply changing the sign of the probability amplitude corresponding to that state during each iteration of the quantum amplitude amplification. A similar issue is that regular machine learning typically uses batch learning, whilst our method incorporates the entire dataset at once. This too can be fixed by altering our method to use a different batch of the data for each quantum amplitude amplification iteration. This works since no matter what batch we use, a good set of weights should still be amplified by the circuit. In fact, such an implementation is advantageous since it would allow us to use less qubits which in practical terms are limited in number in the near term. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/2c0abf912fa066bd80f009822f655265b754fbc0bf7a63d44af0519e95400d74.jpg",
+        "image_caption": [
+            "Figure 6: (a) The meta-BNN we train. The dotted lines represent the presence or absence of connections within the first layer. A meta-learned solution to (b) problem 1 and (c) problem 2 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            109,
+            740,
+            356
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            486,
+            825,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A significant limitation in our method is the requirement that the input is binary, and the poor scaling of the activation function. Both of these problems arise completely from our implementation of the sign function, which could either be improved or replaced entirely with a different binary activation function that could be implemented more efficiently on a quantum computer and would be compatible with non-binary input. There has been progress on creating effective non-linear activation functions by so-called repeat-until-success circuits (Cao et al., 2017). An alternative approach would be to use floating point representations as in classical computing and the quantum equivalent of full-adders, but this would require an overhead in the number of qubits that would take us beyond the limit of classical simulation. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, we note that this method scales poorly compared to backpropagation and that the advantage only appears in like for like comparisons of unstructured classical/quantum searches. The cost function landscape is not unstructured and algorithms such as backpropagation take advantage of this. We conjecture that a quantum search method that applies quantum advantage to structured searches, if it exists, can be applied to the cost landscape in place of quantum amplitude amplification. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            805
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finding ways to harness quantum computers to aid classical machine learning methods in a meaningful way remains an open problem and we present the loss landscape state as a plausible candidate towards this goal. Whilst we used the example of quantum training, the most fruitful approach in the short term is to ask whether some property of the state can be used to glean useful information for classical machine learning methods. This might take the form of understanding the roughness of the landscape, identifying certain features, or even choosing an appropriate learning rate. Further work in investigating the relationship between the landscape as a quantum state and its features from a machine learning perspective would be a step forward in this direction. ",
+        "bbox": [
+            174,
+            813,
+            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 was supported by InnovateUK (79852-520140). Concepts and information presented are based on research and are not commercially available. Due to regulatory reasons, the future availability cannot be guaranteed. ",
+        "bbox": [
+            176,
+            133,
+            825,
+            175
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gilles Brassard, Peter Hoyer, Michele Mosca, and Alain Tapp. Quantum amplitude amplification and estimation. Contemporary Mathematics, 305:53–74, 2002. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yudong Cao, Gian Giacomo Guerreschi, and Alan Aspuru-Guzik. Quantum neuron: an elementary ´ building block for machine learning on quantum computers. arXiv preprint arXiv:1711.11240, 2017. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            204
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Anna Choromanska, Yann LeCun, and Gerard Ben Arous. Open problem: The landscape of the loss ´ surfaces of multilayer networks. In Conference on Learning Theory, pp. 1756–1760, 2015. ",
+        "bbox": [
+            169,
+            213,
+            823,
+            243
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Carlo Ciliberto, Mark Herbster, Alessandro Davide Ialongo, Massimiliano Pontil, Andrea Rocchetto, Simone Severini, and Leonard Wossnig. Quantum machine learning: a classical perspective. Proc. R. Soc. A, 474(2209):20170551, 2018. ",
+        "bbox": [
+            176,
+            251,
+            820,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained $\\mathrm { t o } + 1$ or-1. arXiv preprint arXiv:1602.02830, 2016. ",
+        "bbox": [
+            174,
+            303,
+            823,
+            345
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adenilton Jose da Silva, Teresa Bernarda Ludermir, and Wilson Rosa de Oliveira. Quantum per- ´ ceptron over a field and neural network architecture selection in a quantum computer. Neural Networks, 76:55–64, 2016. ",
+        "bbox": [
+            174,
+            353,
+            823,
+            397
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pierre-Luc Dallaire-Demers and Nathan Killoran. Quantum generative adversarial networks. arXiv preprint arXiv:1804.08641, 2018. ",
+        "bbox": [
+            171,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vittorio Giovannetti, Seth Lloyd, and Lorenzo Maccone. Quantum random access memory. Physical review letters, 100(16):160501, 2008. ",
+        "bbox": [
+            169,
+            443,
+            825,
+            472
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lov K Grover. A fast quantum mechanical algorithm for database search. In Proceedings of the twenty-eighth annual ACM symposium on Theory of computing, pp. 212–219. ACM, 1996. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            510
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aram W Harrow, Avinatan Hassidim, and Seth Lloyd. Quantum algorithm for linear systems of equations. Physical review letters, 103(15):150502, 2009. ",
+        "bbox": [
+            171,
+            517,
+            823,
+            546
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Kapoor, Nathan Wiebe, and Krysta Svore. Quantum perceptron models. In Advances in Neural Information Processing Systems, pp. 3999–4007, 2016. ",
+        "bbox": [
+            171,
+            554,
+            823,
+            584
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nathan Killoran, Thomas R Bromley, Juan Miguel Arrazola, Maria Schuld, Nicolas Quesada, and ´ Seth Lloyd. Continuous-variable quantum neural networks. arXiv preprint arXiv:1806.06871, 2018. ",
+        "bbox": [
+            176,
+            592,
+            825,
+            635
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sam Leroux, Steven Bohez, Tim Verbelen, Bert Vankeirsbilck, Pieter Simoens, and Bart Dhoedt. Transfer learning with binary neural networks. arXiv preprint arXiv:1711.10761, 2017. ",
+        "bbox": [
+            174,
+            642,
+            823,
+            672
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaofan Lin, Cong Zhao, and Wei Pan. Towards accurate binary convolutional neural network. In Advances in Neural Information Processing Systems, pp. 345–353, 2017. ",
+        "bbox": [
+            173,
+            680,
+            823,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Seth Lloyd, Masoud Mohseni, and Patrick Rebentrost. Quantum algorithms for supervised and unsupervised machine learning. arXiv preprint arXiv:1307.0411, 2013. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            747
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Harmut Neven, Vasil S Denchev, Marshall Drew-Brook, Jiayong Zhang, William G Macready, and Geordie Rose. Nips 2009 demonstration: Binary classification using hardware implementation of quantum annealing. 2009. ",
+        "bbox": [
+            176,
+            755,
+            825,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, pp. 525–542. Springer, 2016. ",
+        "bbox": [
+            173,
+            806,
+            823,
+            849
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bob Ricks and Dan Ventura. Training a quantum neural network. In Advances in neural information processing systems, pp. 1019–1026, 2004. ",
+        "bbox": [
+            174,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Damian S Steiger, Thomas Haner, and Matthias Troyer. Projectq: an open source software frame- ¨ work for quantum computing. Quantum, 2:49, 2018. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Edwin Stoudenmire and David J Schwab. Supervised learning with tensor networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4799–4807. Curran Associates, Inc., 2016a. URL http://papers.nips.cc/paper/ 6211-supervised-learning-with-tensor-networks.pdf. ",
+        "bbox": [
+            173,
+            103,
+            826,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Edwin Stoudenmire and David J Schwab. Supervised learning with tensor networks. In Advances in Neural Information Processing Systems, pp. 4799–4807, 2016b. ",
+        "bbox": [
+            174,
+            183,
+            821,
+            212
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ewin Tang. A quantum-inspired classical algorithm for recommendation systems. arXiv preprint arXiv:1807.04271, 2018. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            250
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Wei Tang, Gang Hua, and Liang Wang. How to train a compact binary neural network with high accuracy? In AAAI, pp. 2625–2631, 2017. ",
+        "bbox": [
+            173,
+            257,
+            821,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chris Thornton. Parity: the problem that won’t go away. In Conference of the Canadian Society for Computational Studies of Intelligence, pp. 362–374. Springer, 1996. ",
+        "bbox": [
+            174,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christof Zalka. Grovers quantum searching algorithm is optimal. Physical Review A, 60(4):2746, 1999. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            362
+        ],
+        "page_idx": 12
+    }
+]

parse/train/YDGJ5YExiw6/YDGJ5YExiw6.md

@@ -0,0 +1,271 @@
+# Episodic Multi-agent Reinforcement Learning with Curiosity-driven Exploration
+
+Lulu Zheng∗1, Jiarui Chen∗2 3, Jianhao Wang1, Jiamin $\mathbf { H e ^ { 4 \dagger } }$ , $\mathbf { Y u j i n g \ : H u ^ { 3 } }$ , Yingfeng Chen3, Changjie $\mathbf { F a n ^ { 3 } }$ , Yang $\mathbf { G a o ^ { 2 } }$ , Chongjie Zhang1
+
+1Institute for Interdisciplinary Information Sciences, Tsinghua University, China   
+2Department of Computer Science and Technology, Nanjing University, China 3Fuxi AI Lab, NetEase, China 4Department of Computing Science, University of Alberta, Canada zll19@mails.tsinghua.edu.cn chenjiarui@smail.nju.edu.cn wjh19@mails.tsinghua.edu.cn jiamin12@ualberta.ca {huyujing, chenyingfeng01, fanchangjie}@corp.netease.com gaoy@nju.edu.cn chongjie@tsinghua.edu.cn
+
+# Abstract
+
+Efficient exploration in deep cooperative multi-agent reinforcement learning (MARL) still remains challenging in complex coordination problems. In this paper, we introduce a novel Episodic Multi-agent reinforcement learning with Curiosity-driven exploration, called EMC. We leverage an insight of popular factorized MARL algorithms that the “induced" individual Q-values, i.e., the individual utility functions used for local execution, are the embeddings of local actionobservation histories, and can capture the interaction between agents due to reward backpropagation during centralized training. Therefore, we use prediction errors of individual Q-values as intrinsic rewards for coordinated exploration and utilize episodic memory to exploit explored informative experience to boost policy training. As the dynamics of an agent’s individual Q-value function captures the novelty of states and the influence from other agents, our intrinsic reward can induce coordinated exploration to new or promising states. We illustrate the advantages of our method by didactic examples, and demonstrate its significant outperformance over state-of-the-art MARL baselines on challenging tasks in the StarCraft II micromanagement benchmark.
+
+# 1 Introduction
+
+Cooperative multi-agent reinforcement learning (MARL) has great promise to solve many real-world multi-agent problems, such as autonomous cars [1] and robots [2]. These complex applications post two major challenges for cooperative MARL: scalability, i.e., the joint-action space exponentially grows as the number of agents increases, and partial observability, which requires agents to make decentralized decisions based on their local action-observation histories due to communication constraints. Luckily, a popular MARL paradigm, called centralized training with decentralized execution (CTDE) [3], is adopted to deal with these challenges. With this paradigm, agents’ policies are trained with access to global information in a centralized way and executed only based on local histories in a decentralized way. Based on the paradigm of CTDE, many deep MARL methods have been proposed, including VDN [4], QMIX [5], QTRAN [6], and QPLEX [7].
+
+A core idea of these approaches is to use value factorization, which uses neural networks to represent the joint state-action value as a function of individual utility functions, which can be referred to individial $Q$ -values for terminological simplicity. For example, VDN learns a centralized but factorizable joint value function $Q _ { t o t }$ represented as the summation of individual value function $Q _ { i }$ . During execution, the decentralized policies can be easily derived for each agent $i$ by greedily selecting actions with respect to its local value function $Q _ { i }$ . By utilizing this factorization structure, an implicit multi-agent credit assignment is realized because $Q _ { i }$ is represented as a latent embedding and is learned by neural network backpropagation from the total temporal-difference error on the single global reward signal, rather than on a local reward signal specific to agent $i$ . This value factorization technique enables value-based MARL approaches, such as QMIX and QPLEX, to achieve state-ofthe-art performance in challenging tasks such as the StarCraft unit micromanagement [8].
+
+Despite the current success, since only using simple $\epsilon$ -greedy exploration strategy, these deep MARL approaches are found ineffective to solve complex coordination tasks that require coordinated and efficient exploration [7]. Exploration has been extensively studied in single-agent reinforcement learning and many advanced methods have been proposed, including pseudo-counts [9, 10], curiosity [11, 12], and information gain [13]. However, these methods cannot be adopted into MARL directly, due to the exponentially growing state space and partial observability, leaving multi-agent exploration challenging. Recently, only a few works have tried to address this problem. For instance, EDTI [14] uses influence-based methods to quantify the value of agents’ interactions and coordinate exploration towards high-value interactions. This approach empirically shows promising results but, because of the need to explicitly estimate the influence among agents, it is not scalable when the number of agents increases. Another method, called MAVEN [15], introduces a hierarchical control method with a shared latent variable encouraging committed, temporally extended exploration. However, since the latent variable still needs to explore in the space of joint behaviours [15], it is not efficient in complex tasks with large state spaces.
+
+In this paper, we propose a novel multi-agent curiosity-driven exploration method. Curiosity is a type of intrinsic motivation for exploration, which usually uses prediction errors on different spaces (e.g., future observations [12], actions [11], or learnable representation [16]) as a reward signal. Recently, curiosity-driven methods have achieved significant success in single-agent reinforcement learning [12, 17, 18]. However, curiosity-driven methods face a critical challenge in MARL: in which space should we define curiosity? The straightforward method is to measure curiosity on the global observation [12] or joint histories in a centralized way. However, it is inefficient to find structured interaction between agents, which seems too sparse compared with the exponentially growing state space when the number of agents increases. In contrast, if curiosity is defined as the novelty of local observation histories during the decentralized execution, although scalable, it still fails to guide agents to coordinate due to partial observability. Therefore, we find a middle point of centralized curiosity and decentralized curiosity, i.e., utilizing the value factorization of the state-of-the-art multi-agent Q-learning approaches and defining the prediction errors of individual Q-value functions as intrinsic rewards.
+
+The significance of this intrinsic reward is twofold: 1) it provides a novelty measure of joint observation histories with scalability because individual Q-values are latent embeddings (i.e., an effective state abstraction [19]) of observation histories in factorized multi-agent Q-learning (e.g., VDN or QPLEX); and 2) as shown in Figure 1, it captures the influence from other agents due to the implicit credit assignment from global reward signal during centralized training [20], and biases exploration into promising
+
+![](images/e42c0e6c468417fb743373d9abc3431cd767200868d964c89ea960b2f12b26fc.jpg)  
+Figure 1: CTDE Framework
+
+states where strong interdependence may lie between agents. Therefore, with this novel intrinsic reward, our curiosity-driven method enables efficient, diverse, and coordinated exploration for deep multi-agent Q-learning with value factorization.
+
+Besides efficient exploration, another challenge for deep MARL approaches is how to make the best use of experiences collected by the exploration strategy. Prioritized experience replay based on TD errors shows effectiveness in single-agent deep reinforcement learning. However, it does not carry this promise in factorized multi-agent Q-learning, since the projection error induced by value factorization is also fused into the TD error and severally degrades the effectiveness of the TD error as a measure of the usefulness of experiences. To efficiently use promising exploratory experience trajectories, we augment factorized multi-agent reinforcement learning with episodic memory [21, 22]. This memory stores and regularly updates the best returns for explored states. We use the results in the episodic memory to regularize the TD loss, which allows fast latching onto past successful experience trajectories collected by curiosity-driven exploration and greatly improves learning efficiency. Therefore, we call our method Episodic Multi-agent reinforcement learning with Curiosity-driven exploration, called EMC.
+
+We evaluate EMC in didactic examples, and a broad set of StarCraft II micromanagement benchmark tasks [8]. The didactic examples along with detailed visualization illustrate that our proposed intrinsic reward can guide agents’ policies to novel or promising states, thus enabling effectively coordinated exploration. Empirical results on more complicated StarCraft II tasks show that EMC significantly outperforms other multi-agent state-of-the-art baselines.
+
+# 2 Background
+
+# 2.1 Dec-POMDP
+
+A cooperative multi-agent task can be modelled as a Dec-POMDP [23], which is defined by a tuple $G = < \mathcal { T } , \mathcal { S } , \mathcal { A } , P , R , \Omega , O , n , \gamma >$ , where $\mathcal { T }$ is the sets of $n$ agents, $s$ is the global state space, $\mathcal { A }$ is the finite action set, $\gamma \in [ 0 , 1 )$ is the discount factor. We consider a partially observable setting in a Dec-POMDP, i.e., at each timestep, agent $i \in \mathcal { T }$ only has access to the observation $o _ { i } \in \varOmega$ drawn from the observation function $O ( s , i )$ . Besides, each agent has an action-observation history $\tau _ { i } \in \mathcal { T } \equiv \left( \varOmega \times \mathcal { A } \right) ^ { * } \times \varOmega$ and constructs its individual policy to jointly maximize team performance. With each agent $i$ selecting an action $a _ { i } \in { \mathcal { A } }$ , the joint action $\mathbf { \bar { a } } \equiv [ a _ { i } ] _ { i = 1 } ^ { n } \in \mathcal { A } \equiv \mathcal { A } ^ { N }$ leads to a shared reward $r = R ( s , { \pmb a } )$ and the next state $s ^ { \prime }$ according to the transition distribution $P ( s ^ { \prime } | s , \pmb { a } )$ . The formal objective function is to find a joint policy $\pi$ that maximizes a joint value function $V ^ { \pi } ( s ) =$ $\mathbb { E } [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r _ { t } \big | s = s _ { 0 } , \pi ]$ , or a joint action-value function $Q ^ { \pi } ( s , \pmb { a } ) = r \overline { { } } ( s , \pmb { a } ) + \gamma \mathbb { E } _ { s ^ { \prime } } [ V ^ { \pmb { \pi } } ( s ^ { \prime } ) ]$ .
+
+# 2.2 Centralized Training With Decentralized Execution (CTDE)
+
+CTDE is a promising paradigm in deep cooperative multi-agent reinforcement learning [3, 23, 24], where the local agents execute actions only based on local observation histories, while the policies can be trained in centralized manager which has access to global information. During the training process, the whole team cooperate to find the optimal joint action-value function $Q _ { t o t } ^ { * } ( s , \pmb { a } ) =$ $\grave { r } ( s , \pmb { a } ) + \gamma \mathbb { E } _ { s ^ { \prime } } [ \operatorname* { m a x } _ { \pmb { a } ^ { \prime } } Q _ { t o t } ^ { * } ( s ^ { \bar { \prime } } , \pmb { a } ^ { \prime } ) ]$ . Due to partial observability, we use $Q _ { t o t } ( \tau , a ; \theta )$ instead of $Q _ { t o t } ( s , \pmb { a } ; \pmb { \theta } )$ , where $\pmb { \tau } \in \mathcal { T } \equiv \mathcal { T } ^ { N }$ . Then the Q-value neural network will be trained to minimize the following expected TD-error:
+
+$$
+\begin{array} { r } { \mathcal { L } ( \pmb { \theta } ) = \mathbb { E } _ { \tau , a , r , \tau ^ { \prime } \in D } \left[ r + \gamma V ( \pmb { \tau ^ { \prime } } ; \pmb { \theta } ^ { - } ) - Q _ { t o t } ( \pmb { \tau } , \pmb { a } ; \pmb { \theta } ) \right] ^ { 2 } , } \end{array}
+$$
+
+where $D$ is the replay buffer and $\pmb { \theta } ^ { - }$ denotes the parameters of the target network, which is periodically updated by $\pmb \theta$ . And $\operatorname { V } ( \tau ^ { \prime } ; \theta ^ { - } )$ is the one-step expected future return of the TD target. Local agents can only obtain local action-observation history and need inference based on individual Q-value functions $Q _ { i } ( \tau _ { i } , a _ { i } )$ . Therefore, many works have made efforts in finding the factorization structures between joint Q-value functions $Q _ { t o t }$ and individual Q-functions $Q _ { i } ( \tau _ { i } , a _ { i } )$ [4, 5, 7].
+
+# 3 Related Work
+
+Curiosity-driven Exploration Curiosity-driven exploration has been well studied in single-agent reinforcement learning. Previous literature [25, 26] has provided a good summary in this topic. Recently, curiosity-driven methods have made great progress in deep reinforcement learning. For example, some works use pseudo-state counts to get intrinsic rewards [9, 10, 27] instead of countbased methods to get better scalability. Stadie et al. [28] use prediction errors in the feature space of an auto-encoder to measure the novelty of states and encourage exploration. On the other hand, Mohamed and Rezende [29] propose to use empowerment, measured by the information gain based on the entropy of actions, as intrinsic rewards for exploring novel states efficiently. Another informationbased method [13] tries to maximize information gain about the agent’s belief of the environment’s dynamics as an exploration strategy. ICM [11] learns an inverse model which predicts the agent’s action given its current and next states and tries to predict the next state in the learned hidden space by current state and action. RND [12] uses curiosity as intrinsic rewards in a simpler but effective way, which uses a fixed randomly initialized neural network as a representation network and directly predicts the embedding of the next state. Different from these methods, we are the first to propose an advanced curiosity-driven exploration method in MARL setting for diverse and coordinated exploration.
+
+Multi-agent Exploration Although single-agent exploration is extensively studied and has achieved considerable success, few exploration methods were designed for cooperative MARL. Bargiacchiet al. [30] proposes an exploration method that can only be used in repeated single-stage problems. Jaques et al. [31] defines intrinsic reward by “social influence” to encourage agents to choose actions that can influence other agents’ actions. Iqbal and Sha [32] uses various simple exploration methods to learn simultaneously and then put the samples of every method in a shared buffer to achieve the coordinated exploration. Wang et al. [14] use mutual information (MI) to capture the interdependence of the rewards and transitions between agents. MAVEN [15] is the state-of-the-art exploration method in MARL that uses a hierarchical policy to produce a shared latent variable and learns several state-action value functions for each agent. These works, although important, still face the challenge of achieving scalable and effective multi-agent exploration.
+
+Episodic Control Our work is also related to episodic control reinforcement learning, which is usually adopted in single-agent settings for better sample efficiency. Previous works propose to use episodic memory in near-deterministic environment [33–36]. Model-free episodic control [34] uses a completely non-parametric table to keep the best Q-values of state-action pair in a tabular-based memory and uses a $\mathbf { k }$ -nearest-neighbors fashion to find the sequence of actions that so far yielded the highest return from a given start state in the memory. Recently, several extensions have been proposed to integrate episodic control with parametric DQN. Gershman and Daw [37] uses episodic memory to retrieve samples and then average future returns to approximate the action values. EMDQN [21] uses a fixed random matrix as a representation function and uses the projection of states as keys to store the information of episodic memory into a non-parametric model. Using the episodic-memory based target as a regularization term to guide the training process, the performance of EMDQN is significantly improved compared with the original DQN. Despite the fruitful progress made in single-agent episodic reinforcement learning, few works study episodic control in a multi-agent setting. To the best of our knowledge, we are the first to utilize the mechanism of episodic control in deep multi-agent reinforcement learning.
+
+# 4 Episodic Multi-agent Reinforcement Learning with Curiosity-Driven Exploration
+
+In this section, we introduce EMC, a novel episodic multi-agent exploration framework. EMC takes prediction errors of individual Q-value functions as intrinsic rewards for guiding the diverse and coordinated exploration. After collecting informative experience, we leverage an episodic memory to memorize the highly rewarding sequences and use it as the reference of a one-step TD target to boost multi-agent Q-learning. First, we analyze the motivations for predicting individual Q-values, then we introduce the curiosity module for exploration. Finally, we describe how to utilize episodic memory to boost training.
+
+# 4.1 Curiosity-Driven Exploration by Predicting Individual Q-values
+
+As shown in Figure 2, in the paradigm of CDTE, local agents make decisions based on individual Q-value functions, which take local observation histories as inputs, and are updated by the centralized module which has access to global information for training. The key insight is that, different from single-agent cases, individual Q-value functions in MARL are used for both decision-making and embedding historical observations. Furthermore, due to implicit credit assignment by global reward signal during centralized training, individual Q-value functions $Q _ { i } ( \tau _ { i } , \cdot )$ are influenced by environment as well as other agents’ behaviors. More concretely, it has been proved by Wang et al. [20] that, when the joint Q-function Q-functions $Q _ { i }$ , i.e., $\begin{array} { r } { Q _ { t o t } ^ { ( t + 1 ) } ( \pmb { \tau } , \pmb { a } ) = \sum _ { i = 1 } ^ { N } Q _ { i } ^ { ( t + 1 ) } ( \tau _ { i } , a _ { i } ) } \end{array}$ $Q _ { t o t }$ is factorized into linear combination of individual , then $Q _ { i } ^ { ( t + 1 ) } ( \tau _ { i } , a _ { i } )$ has the following closed-form solution:
+
+$$
+Q _ { i } ^ { ( t + 1 ) } ( \tau _ { i } , a _ { i } ) = \underset { ( \tau _ { - i } ^ { \prime } , a _ { - i } ^ { \prime } ) \sim p _ { D } ( \cdot \vert \tau _ { i } ) } { \mathbb { E } } \left[ y ^ { ( t ) } \left( \tau _ { i } \oplus \tau _ { - i } ^ { \prime } , a _ { i } \oplus a _ { - i } ^ { \prime } \right) \right]
+$$
+
+$$
+- \frac { n - 1 } { n } \mathop { \mathbb { E } } _ { \tau ^ { \prime } , a ^ { \prime } \sim p _ { D } ( \cdot | \Lambda ^ { - 1 } ( \tau _ { i } ) ) } \left[ y ^ { ( t ) } \left( \tau ^ { \prime } , a ^ { \prime } \right) \right] + w _ { i } ( \tau _ { i } ) ,
+$$
+
+where $\begin{array} { r } { y ^ { ( t ) } ( \pmb { \tau } , \pmb { a } ) = r + \gamma \mathbb { E } _ { \pmb { \tau } ^ { \prime } } \left[ \operatorname* { m a x } _ { \pmb { a } ^ { \prime } } Q _ { t o t } ^ { ( t ) } \left( \pmb { \tau } ^ { \prime } , \pmb { a } ^ { \prime } \right) \right] } \end{array}$ denotes the expected one-step TD target, and $p _ { D } ( \cdot | \tau _ { i } )$ denotes the conditional empirical probability of $\tau _ { i }$ in the given dataset $D$ . The notation $\tau _ { i } \oplus \tau _ { - i } ^ { \prime }$ denotes $\langle \tau _ { 1 } ^ { \prime } , \dots , \tau _ { i - 1 } ^ { \prime } , \tau _ { i } , \tau _ { i + 1 } ^ { \prime } , \dots , \bar { \tau } _ { n } ^ { \prime } \rangle$ , and $\boldsymbol { \tau } _ { - i } ^ { \prime }$ denotes the elements of all agents except for agent $i$ . $\Lambda ^ { - 1 } ( \tau _ { i } )$ denotes the set of trajectory histories that may share the same latent-state trajectory as $\tau _ { i }$ i . The residue term $\pmb { w } \equiv [ w _ { i } ] _ { i = 1 } ^ { n }$ is an arbitrary function satisfying $\forall \tau \in \mathbf { T }$ , $\scriptstyle \sum _ { i = 1 } ^ { n } w _ { i } ( \tau _ { i } ) = 0$ .
+
+Eq. (2) shows that by linear value factorization, the individual Q-value $Q _ { i } ( \tau _ { i } , a _ { i } )$ is not only decided by local observation histories but also influenced by other agents’ action-observation histories. Thus predicting $Q _ { i }$ can capture both the novelty of states and the interaction between agents and lead agents to explore promising states. Motivated by this insight, in this paper, we use a linear value factorization module separate from the inference module to learn the individual value function $Q _ { i }$ , and use the prediction errors of $Q _ { i }$ as intrinsic rewards to guide exploration. In this paper, we define the prediction errors of individual Q-values as curiosity and propose our curiosity-driven exploration module as follows.
+
+![](images/c9efd746fe71d13035fe0deba3d9c4985e973d4faf27e4788e6e073a18ce01c1.jpg)  
+Figure 2: An overview of EMC’s framework
+
+Figure 2b demonstrates the Curiosity Module, separated from the inference module (Figure 2a). The curiosity module consists of four components: (i) The centralized training part with linear value factorization, which shares the same implementation as VDN [4], but only trained with extrinsic rewards $r ^ { e x t }$ from the environment; (ii) the Target for prediction, i.e., the corresponding individual Q-values ${ Q _ { i } ^ { e x t } }$ , represented by a recurrent Q-network; (iii) Predictor $\widetilde { Q } _ { i } ( \tau _ { i } )$ , which is used for predicting ${ Q _ { i } ^ { e x t } }$ and shares the same network architecture as Target ${ Q _ { i } ^ { e x t } }$ ; and (iv) Distance Function, which measures the distance between ${ Q _ { i } ^ { e x t } }$ and $\widetilde { Q } _ { i }$ , e.g., $L _ { 2 }$ distance. The predictors are trained by minimizing the Mean Squared Error (MSE) of the distance in an end-to-end manner. For stable training, we use the soft-update target [38] of ${ Q _ { i } ^ { e x t } }$ to smooth the outputs of the targets. In general, (ii) is trained with (i) and outputs individual Q-values , while (iii) is trained with (ii) and (iv), and aims to predict the soft-update target of individual Q-values. Motivated by the implicit credit assignment of linear value factorization (Eq. (2)), the curiosity module predicts the individual Q-values $\bar { \big [ Q _ { i } ^ { e x t } \big ] } _ { i = 1 } ^ { n }$ in linear factorization, i.e., $\begin{array} { r } { Q _ { t o t } ^ { e x t } = \sum _ { i = 1 } ^ { N } Q _ { i } ^ { e x t } } \end{array}$ . Then the curiosity-driven intrinsic reward is generated by the following equation:
+
+$$
+r ^ { i n t } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \left. \widetilde { Q } _ { i } ( \tau _ { i } , \cdot ) - Q _ { i } ^ { e x t } ( \tau _ { i } , \cdot ) \right. _ { 2 } ,
+$$
+
+This intrinsic reward is used for the centralized training of the inference module, as shown in Figure 2a:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { i n f e r e n c e } } ( \pmb { \theta } ) = \mathbb { E } _ { \pmb { \tau } , \pmb { a } , \pmb { r } , \pmb { \tau } ^ { \prime } \in D } \left[ \left( \pmb { y } ( \pmb { \tau } , \pmb { a } ) - Q _ { t o t } ( \pmb { \tau } , \pmb { a } ; \pmb { \theta } ) \right) ^ { 2 } \right] , } \end{array}
+$$
+
+where y(τ , $\begin{array} { r } { \mathbf { \Delta } \mathbf { a } ) = r ^ { e x t } + \beta r ^ { i n t } + \gamma \operatorname* { m a x } _ { \mathbf { a } ^ { \prime } } Q _ { t o t } \left( \tau ^ { \prime } , a ^ { \prime } ; \theta ^ { - } \right) ) } \end{array}$ , denoting one step TD target of the inference module, and $\beta$ is the weight term of the intrinsic reward. We use a separate training model for inference (Figure 2a) to avoid the accumulation of projection errors of $Q _ { i }$ during training.
+
+The independence of inference module leads to another advantage, that EMC’s architecture can be adopted into many value-factorization-based multi-agent algorithms which utilize the CDTE paradigm, i.e., the general function $f$ in Figure $2 \mathrm { a }$ can indicate specific (linear, monotonic and IGM) value factorization structures in VDN [4], QMIX [5], and QPLEX [7], respectively. In this paper, we utilize these state-of-the-art algorithms for the inference module. With this curiosity-driven bias plugged into ordinary MARL algorithms, EMC will achieve efficient, diverse and coordinated exploration.
+
+# 4.2 Episodic Memory
+
+Equipped with efficient exploration ability, another challenge is how to make the best use of good trajectories collected by exploration effectively. Recently, episodic control has been widely studied in single-agent reinforcement learning [21, 22], which can replay the highly rewarding sequences, thus boosting training. Inspired by this framework, we generalize single-agent episodic control to propose a multi-agent episodic memory, which records the best memorized Monte-Carlo return in the episode, and provide a memory target $H$ as a reference to regularize the ordinary one-step inference TD target estimation in the inference module (Figure 2a):
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { m e m o r y } } ( \pmb { \theta } ) = \mathbb { E } _ { \pmb { \tau } , \pmb { a } , \pmb { r } , \pmb { \tau } ^ { \prime } \in D } \left[ \left( H - Q _ { t o t } ( \pmb { \tau } , \pmb { a } ; \pmb { \theta } ) \right) ^ { 2 } \right] . } \end{array}
+$$
+
+However, different from the single-agent episodic control, the action space of MARL exponentially grows as the number of agents increases, and partial observability also limits the information of individual value functions. Thus, we maintain our episodic memory by storing the state-value function on the global state space and utilizing the global information during the centralized training process under the CTDE paradigm. Figure 2d shows the architecture of the Episodic Memory. We keep a memory table $M$ to record the maximum remembered return of the current state, and use a fixed random matrix drawn from Gaussian distribution as a representation function to project states into low-dimensional vectors $\phi ( s ) : S \to \mathbb { R } ^ { k }$ , which are used as keys to look up corresponding global state value function $H ( \phi ( s _ { t } ) )$ . When our exploration method collects a new trajectory, we update our memory table $M$ as follows:
+
+$$
+H ( \phi ( s _ { t } ) ) = \left\{ \begin{array} { l l } { \operatorname* { m a x } \{ H ( \phi ( \hat { s } _ { t } ) ) , R _ { t } ( s _ { t } , \pmb { a } _ { t } ) \} } & { i f \| \phi ( \hat { s } _ { t } ) - \phi ( s _ { t } ) \| _ { 2 } < \delta } \\ { R _ { t } ( s _ { t } , \pmb { a } _ { t } ) } & { o t h e r w i s e } \end{array} \right. ,
+$$
+
+where $\phi ( \hat { s } _ { t } )$ is $\phi ( s _ { t } )$ ’s nearest neighbor in the memory $M , \delta$ is a threshold, and $R ( s _ { t } , \pmb { a } _ { t } )$ represents the future return when agents taking joint action $\mathbf { } \mathbf { a } _ { t }$ under global state $s _ { t }$ at the $t$ -th timestep in a new episode. In our implementation, $\phi ( s _ { t } ) \in M$ is indeed evaluated approximately based on the embedding distance. Specifically, when the key of the state $\phi ( s _ { t } )$ is close enough to one key in the memory, we assume that $\dot { \phi } ( s _ { t } ) \in M$ and find the best memorized Monte-Carlo return correspondingly. Otherwise, we think $\phi ( s _ { t } ) \notin M$ and record the state’s return into the memory. Leveraging the episodic memory, we can directly obtain the maximum remembered return of the current state, and use the one-step TD memory target $H$ as a reference to regularize learning:
+
+$$
+H ( \phi ( s _ { t } ) , \pmb { a } _ { t } ) = r _ { t } ( s _ { t } , \pmb { a } _ { t } ) + \gamma H ( \phi ( s _ { t + 1 } ) ) .
+$$
+
+Thus, the new objective function for the inference module is:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mathrm { { t o t a l } } } ( \theta ) = \mathcal { L } _ { \mathrm { i n f e r e n c e } } ( \theta ) + \lambda \mathcal { L } _ { \mathrm { m e m o r y } } ( \theta ) } \\ & { \qquad = \mathbb { E } _ { \tau , a , r , \tau ^ { \prime } \in D } \left[ \left( y ( \tau , a ) - Q _ { t o t } ( \tau , a ; \theta ) \right) ^ { 2 } + \lambda \left( H \left( \phi ( s _ { t } ) , a _ { t } \right) - Q _ { t o t } ( \tau , a ; \theta ) \right) ^ { 2 } \right] , } \end{array}
+$$
+
+where $\lambda$ is the weighting term to balance the effect of episodic memory’s reference. Using the maximum return from the episodic memory to propagate rewards, we can compensate for the disadvantage of slow learning induced by the original one-step reward update and improve sample efficiency.
+
+# 5 Experiments
+
+In this section, we will conduct a large set of empirical experiments for answering the following questions: (1) Is exploration by predicting individual Q-value functions better than exploration by decentralized curiosity or global curiosity (Section 5.1)? (2) Can our method perform efficient coordinated exploration in challenging multi-agent tasks (Section 5.2-5.3)? (3) If so, what role does each key component play for the superior performance (Section 5.4)? (4) Why do we choose to predict target ${ \dot { Q } } _ { i } ^ { e x t }$ for generating intrinsic rewards rather than other choices (Section 5.4)? We will propose several didactic examples and demonstrate the advantage of our method in coordinated exploration, and evaluate our method on the StarCraft II micromanagement (SMAC) benchmark [8] compared with existing state-of-the-art multi-agent reinforcement learning (MARL) algorithms: QPLEX [7], Weighted-QMIX [39], QTRAN [6], QMIX [5], VDN [4], RODE [40], and MAVEN [15].
+
+# 5.1 Didactic Example
+
+Figure 3 shows an $1 1 \times 1 2$ grid world game that requires coordinated exploration. The blue agent and the red agent can choose one of the five actions: [up, down, left, right, stay] at each time step. The wall shown in the picture isolates the two agents, and one agent cannot be observed by the other until it gets into the shaded area. The two agents will receive a positive global reward $r = 1 0$ if and only if they arrive at the corresponding goal grid (referred to the character $G$ in Figure 3) at the same time. If only one arrives, the incoordination will be punished by a negative reward $- p$ .
+
+To evaluate the effectiveness of our curiosity-driven exploration, we implement our method into QPLEX, QMIX, and VDN (denoted as EMCQPLEX, EMC-QMIX, and EMC-VDN, respectively) and test them in this toy game compared with the state-of-the-art MARL algorithms: VDN, IQL, QMIX, and QPLEX. Moreover, to demonstrate the motivation of predicting individual Q-functions, we add two more baselines: QPLEX with the prediction error of global state as intrinsic rewards (denoted as QPLEX-Global), and QPLEX with the prediction error of local joint histories as intrinsic rewards (denoted as QPLEX-Local). Both of them use a fixed network to project the inputs into latent embedding, then predict the latent embedding to generate intrinsic reward, just like the
+
+![](images/ca5b8da9a792c7093c35684dbd271a5f64febc1a0227763618e2913be06de2d7.jpg)  
+Figure 3: Coordinated Toygame
+
+Random Network Distillation (RND) [12]. We test different punishment degrees, i.e., different ps (which are deferred to Appendix C), and the results show QPLEX-Global and QPLEX-Local are effective enough for exploration when $p$ is relatively small. However, as $p$ increases, the task becomes more challenging since it requires sufficient and coordinated exploration. In Figure 4, we show the median test win rate of all methods over 6 random seeds when $p = 2$ , and only our methods can learn the optimal policy and win the game, while other methods failed.
+
+To understand this result better, we have made several visualisations to demonstrate our advantage in coordinated exploration. Figure 4 shows the heatmaps of visitation and intrinsic reward by EMC-QPLEX, QPLEX-Global, and QPLEX-Local. During the early stage of training, all methods uniformly explore the whole area (Figure 4a). As the exploration progresses, the global curiosity (QPLEX-Global) encourages agents to visit all configurations without bias, which is inefficient and fail to leverage the potential locality influence between agents (Figure 4b), resulting in extrinsic rewards beginning to dominate the behaviors (Figure 4c). On the other hand, the visitation heatmap of QPLEX-Local shows the decentralized curiosity encourages agents to explore around the goal grid, but it cannot promise to encourage agents to coordinate and gain the reward due to the partial observability in decentralized execution. In contrast, the heatmap of intrinsic reward for EMC-QPLEX shows that predicting individual Q-values will bias exploration into areas where individual Q-values are more dynamic due to the potential correlation between agents. Therefore, QPLEX-Local and QPLEX-Global both fail in this task (Figure 4c), while our methods are able to find the optimal policy. This didactic example shows the global curiosity or local curiosity may fail to handle complex tasks where coordinated exploration needs to be addressed. While since individual Q-values $Q _ { i }$ are the embeddings of historical observations, and are dynamically updated by the backpropagation of the global reward signal gained through cooperation during centralized training. Thus $Q _ { i }$ can implicitly reflect the influence from the environment and other agents, and predicting $Q _ { i }$ can capture valuable and spare interactions among agents and bias exploration into new or promising states.
+
+![](images/46b4ce175f984bcf4e93709364f50b46cb692db50705fdea07c5db028bcc0b41.jpg)  
+Figure 4: The heat map of gridworld game.
+
+# 5.2 Predator Prey
+
+Predator-Prey is a partially-observable multi-agent coordinated game with miscoordination penalties used by WQMIX [39]. As shown in Figure 5, since extensive exploration is needed to jump out of the local optima, WQMIX is the only baseline algorithm to find the optimal policy, due to its shaped data distribution which can be seen as a type of exploration. Other state-of-the-art multiagent Q-learning algorithms, such as QPLEX and QMIX, fail to solve this task. For MAVEN, QPLEC-Global and QPLEX-Local, although equipped with improved exploration ability, they still failed to address coordination due to uniform exploration nature or partial observability. However, plugged with EMC, EMC-VDN, EMC-QMIX, and EMC-QPLEX can guarantee coordinated exploration effectively and achieve good performance.
+
+![](images/4c6077708920775c9bb9f24a71e77ac9a5502ad0ea117998b1060b2eb133654b.jpg)  
+Figure 5: The performance of Predator Prey.
+
+# 5.3 StarCraftII Micromanagement (SMAC) Benchmark
+
+StarCraft II Micromanagement (SMAC) is a popular benchmark in MARL [4, 5, 7, 40, 39]. We conduct experiments in 17 benchmark tasks of StarCraft II, which contains 14 popular tasks proposed by SMAC [8] and three more super hard cooperative tasks proposed by QPLEX [7]. In the micromanagement scenarios, each unit is controlled by an independent agent that must act based on its own local observation, and the enemy units are controlled by a built-in AI.
+
+For evaluation, we compare EMC with the state-of-theart algorithms: RODE [40], QPLEX [7], MAVEN [15], and the two variants of QMIX [5]: CW-QMIX and OWQMIX [39]. All experimental results are illustrated with the median performance and $2 5 - 7 5 \%$ percentiles. Figure 6 shows the overall performance of the tested algorithms in all these 17 maps. Due to the effective exploration with episodic memory which can efficiently use promising exploratory experience trajectories, EMC is the best performer on up to 6 tasks, underperforms on just three tasks, and ties for the best performer on the rest tasks.
+
+![](images/4bf2efb0efa78ecaec0d9443037e01d9f94255a96498c39f16cdfac30af38e61.jpg)  
+Figure 6: The number of scenarios in which the algorithm’s median test win rate is the highest by as least 1/32.
+
+![](images/594bd42cd742844f6b9d5a165422ad639638f51e43db23e75976be9f6d989590.jpg)  
+Figure 7: Results of super hard maps in SMAC.
+
+The advantages of our algorithm can be mainly illustrated by the results of the six hard maps which need sufficient exploration shown in Figure 7. The three maps in the first row are super hard, and solving them needs efficient, diverse and coordinated exploration. Thus, we can find that the EMC algorithm significantly outperforms other algorithms in corridor and $3 s 5 z \_ { \nu s \_ 3 s 6 z }$ , and also achieves the best performance (equal to RODE) in $6 h \_ { \nu s \_ } 8 z$ . To the best of our knowledge, this will be the state-of-the-art results in corridor and $3 s 5 z \_ { \nu s \_ 3 s 6 z }$ . For the remaining three maps in the second row $( \ I c 3 s 8 z _ { - } \nu s _ { - } I c 3 s 9 z , 5 s I O z$ , and $7 s 7 z$ ), where other baselines can also find winning strategies, due to the boost learning process via episodic memory along with efficient exploration, our algorithm EMC still performs the best in the three maps, with fastest learning speed and the highest rates achieved.
+
+# 5.4 Ablation Study
+
+To understand the superior performance of EMC, we carry out ablation studies to test the contribution of its two main components: curiosity module and episodic memory. Following methods are included in the evaluation: (i) EMC without curiosity module (denoted by EMC-wo- $C$ ); (ii) EMC without episodic memory component (denoted by EMC-wo-M); (iii) QPLEX, which can be considered as EMC without the episodic memory component nor the curiosity module, provides a natural ablation baseline of EMC.
+
+Figure 8(b-c) shows that in easy exploration maps, both EMC and EMC-wo-C achieve the state-of-theart performance, which implies that in the easy tasks, sufficient exploration can be achieved simply by the popular $\epsilon$ -greedy method. However, in super hard exploration maps (Figure 8 (a)), EMC-wo-C cannot solve this task but EMC has excellent performance. These empirical experiments show that the curiosity module plays a vital role in improving performance when sufficient and coordinated exploration is necessary. On the other hand, making the best use of good trajectories collected by exploration is also essential. As shown Figure 8, EMC with episodic memory enjoys better sample efficiency than EMC-wo-M in challenging (Figure 8a) and easy exploration tasks (Figure 8(b-c)). In general, the curiosity module and the episodic memory complement each other, and efficiently using promising exploratory experience trajectories leads to the superior performance of EMC.
+
+Like single-agent curiosity or RND [12] exploration methods, our approach looks simple yet effective.   
+In addition, its design choices do not look straightforward before we know how to do it right.
+
+![](images/f0e4aa9a00e3abed9e6710b42b0e3a99345be18a84f3cbde550b9102ec88cd3c.jpg)  
+Figure 8: Ablation study on the two major components.
+
+![](images/fa5eebfd60744500832ce2fe6c9ee37dd9ce3c43c69a60aea797029a461140f4.jpg)  
+Figure 9: Ablation study on design choice.
+
+Therefore we conduct additional ablation studies to demonstrate the effect of our elaborate formulation of curiosity bias. We introduce several baselines and compare them with $\mathrm { E M C } : ( \mathrm { i } )$ using the normalized TD-error of $Q _ { t o t a l }$ as curiosity rewards, denoted as EMC-TD; (ii) using the averaged error between the individual utilities and their targets as intrinsic rewards, denoted as EMC-Ind; (iii) using the TD error of a centralized critic of the controllers which conditions on all agents’ histories and actions, denoted as EMC-Cen; (iv) using the averaged prediction errors of ${ Q _ { i } ^ { e x t ; d e c } }$ which are trained in a decentralized way, denoted as EMC-Dec. We aim to investigate the subtle implementation difference between EMC and EMC-TD as well as EMC-Ind, and compare the exploration efficiency of our method with the global curiosity-driven exploration method (EMC-Cen) and local curiosity-driven exploration method (EMC-Dec) empirically.
+
+We design a variant of the toygame mentioned in section 5.1, which has an additional random noisy reward region. By visualizations, we demonstrate that the agents of EMC-TD and EMC-Ind tend to get stuck in the noisy-reward region, thus resulting in sub-optimal policy, while our method show superior ability for avoiding such noise-spike problem. On the other hand, since EMC-Cen is based on global curiosity, which encourages agents to explore the whole state space without bias, it may fail in finding sparse but valuable interaction patterns in the exponentially growing space in complex tasks. When comparing with EMC and EMC-Dec, we find that the key difference is the counterfactual baseline (Eq. (2)), which can theoretically reduce the variance of EMC [41]. Therefore, EMC can focus more on the individual specific contribution and achieve the significant improvements.
+
+We test these baselines in SMAC and the results are shown in Figure 9, and our method significantly outperform other baselines. In general, by conducting these ablations, we demonstrate the robustness for noise spikes of our design choice ((i) and (ii)), as well as the efficiency and stability of our method compared with centralized or decentralized curiosity-driven exploration method. More detailed discussions will be deferred to Appendix E.
+
+# 6 Conclusions and Future Work
+
+This paper introduces EMC, a novel episodic multi-agent reinforcement learning algorithm with a curiosity-driven exploration framework that allows for efficient coordinated exploration and boosted policy training by exploiting explored informative experiences. Based on the effective exploration ability, our method shows significant outperformance over state-of-the-art MARL baselines on challenging tasks in the StarCraft II micromanagement benchmark. The limitation of our work lies in the lack of adaptive exploration methods to ensure robustness. Besides, the episodic memory may get problems in stochastic settings. For future work, we may conduct further research in these directions.
+
+# Acknowledgments and Disclosure of Funding
+
+We would like to thank the anonymous reviewers for their valuable comments and helpful suggestions. This work is supported in part by Science and Technology Innovation 2030 – “New Generation Artificial Intelligence” Major Project (No. 2018AAA0100900), a grant from the Institute of Guo Qiang, Tsinghua University, and a grant from Turing AI Institute of Nanjing.
+
+# References
+
+[1] Yongcan Cao, Wenwu Yu, Wei Ren, and Guanrong Chen. An overview of recent progress in the study of distributed multi-agent coordination. IEEE Transactions on Industrial informatics, 9(1):427–438, 2012.   
+[2] Maximilian Hüttenrauch, Adrian Šošic, and Gerhard Neumann. Guided deep reinforcement ´ learning for swarm systems. arXiv preprint arXiv:1709.06011, 2017.   
+[3] Daniel S Bernstein, Robert Givan, Neil Immerman, and Shlomo Zilberstein. The complexity of decentralized control of markov decision processes. Mathematics of operations research, 27(4):819–840, 2002.   
+[4] Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinícius Flores Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z Leibo, Karl Tuyls, et al. Value-decomposition networks for cooperative multi-agent learning based on team reward. In AAMAS, pages 2085–2087, 2018.   
+[5] Tabish Rashid, Mikayel Samvelyan, Christian Schroeder, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. Qmix: Monotonic value function factorisation for deep multi-agent reinforcement learning. In International Conference on Machine Learning, pages 4295–4304, 2018.   
+[6] Kyunghwan Son, Daewoo Kim, Wan Ju Kang, David Earl Hostallero, and Yung Yi. Qtran: Learning to factorize with transformation for cooperative multi-agent reinforcement learning. arXiv preprint arXiv:1905.05408, 2019.   
+[7] Jianhao Wang, Zhizhou Ren, Terry Liu, Yang Yu, and Chongjie Zhang. Qplex: Duplex dueling multi-agent q-learning. arXiv preprint arXiv:2008.01062, 2020.   
+[8] Mikayel Samvelyan, Tabish Rashid, Christian Schroeder de Witt, Gregory Farquhar, Nantas Nardelli, Tim GJ Rudner, Chia-Man Hung, Philip HS Torr, Jakob Foerster, and Shimon Whiteson. The starcraft multi-agent challenge. In Proceedings of the 18th International Conference on Autonomous Agents and MultiAgent Systems, pages 2186–2188, 2019.   
+[9] Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in neural information processing systems, pages 1471–1479, 2016.   
+[10] Georg Ostrovski, Marc G Bellemare, Aäron Oord, and Rémi Munos. Count-based exploration with neural density models. In International Conference on Machine Learning, pages 2721– 2730, 2017.   
+[11] Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In International Conference on Machine Learning, 2017.   
+[12] Yuri Burda, Harrison Edwards, Amos Storkey, and Oleg Klimov. Exploration by random network distillation. arXiv preprint arXiv:1810.12894, 2018.   
+[13] Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. Vime: Variational information maximizing exploration. In Advances in Neural Information Processing Systems, pages 1109–1117, 2016.   
+[14] Tonghan Wang, Jianhao Wang, Yi Wu, and Chongjie Zhang. Influence-based multi-agent exploration. In International Conference on Learning Representations, 2019.
+
+[15] Anuj Mahajan, Tabish Rashid, Mikayel Samvelyan, and Shimon Whiteson. Maven: Multiagent variational exploration. In Advances in Neural Information Processing Systems, pages 7613–7624, 2019.
+
+[16] Hyoungseok Kim, Jaekyeom Kim, Yeonwoo Jeong, Sergey Levine, and Hyun Oh Song. Emi: Exploration with mutual information. arXiv preprint arXiv:1810.01176, 2018.
+
+[17] Adrià Puigdomènech Badia, Pablo Sprechmann, Alex Vitvitskyi, Daniel Guo, Bilal Piot, Steven Kapturowski, Olivier Tieleman, Martin Arjovsky, Alexander Pritzel, Andrew Bolt, et al. Never give up: Learning directed exploration strategies. In International Conference on Learning Representations, 2019.
+
+[18] Adrià Puigdomènech Badia, Bilal Piot, Steven Kapturowski, Pablo Sprechmann, Alex Vitvitskyi, Zhaohan Daniel Guo, and Charles Blundell. Agent57: Outperforming the atari human benchmark. In International Conference on Machine Learning, pages 507–517. PMLR, 2020.
+
+[19] Lihong Li, Thomas J Walsh, and Michael L Littman. Towards a unified theory of state abstraction for mdps. ISAIM, 4:5, 2006.
+
+[20] Jianhao Wang, Zhizhou Ren, Beining Han, Jianing Ye, and Chongjie Zhang. Towards understanding linear value decomposition in cooperative multi-agent q-learning. arXiv preprint arXiv:2006.00587, 2020.
+
+[21] Zichuan Lin, Tianqi Zhao, Guangwen Yang, and Lintao Zhang. Episodic memory deep qnetworks. In IJCAI, 2018.
+
+[22] Guangxiang Zhu, Zichuan Lin, Guangwen Yang, and Chongjie Zhang. Episodic reinforcement learning with associative memory. In International Conference on Learning Representations, 2019.
+
+[23] Frans A Oliehoek, Christopher Amato, et al. A concise introduction to decentralized POMDPs, volume 1. Springer, 2016.
+
+[24] Frans A Oliehoek, Matthijs TJ Spaan, and Nikos Vlassis. Optimal and approximate q-value functions for decentralized pomdps. Journal of Artificial Intelligence Research, 32:289–353, 2008.
+
+[25] Pierre-Yves Oudeyer, Frdric Kaplan, and Verena V Hafner. Intrinsic motivation systems for autonomous mental development. IEEE transactions on evolutionary computation, 11(2):265– 286, 2007.
+
+[26] Pierre-Yves Oudeyer and Frederic Kaplan. What is intrinsic motivation? a typology of computational approaches. Frontiers in neurorobotics, 1:6, 2009.
+
+[27] Haoran Tang, Rein Houthooft, Davis Foote, Adam Stooke, OpenAI Xi Chen, Yan Duan, John Schulman, Filip DeTurck, and Pieter Abbeel. # exploration: A study of count-based exploration for deep reinforcement learning. In Advances in neural information processing systems, pages 2753–2762, 2017.
+
+[28] Bradly C Stadie, Sergey Levine, and Pieter Abbeel. Incentivizing exploration in reinforcement learning with deep predictive models. arXiv preprint arXiv:1507.00814, 2015.
+
+[29] Shakir Mohamed and Danilo J Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In Proceedings of the 28th International Conference on Neural Information Processing Systems-Volume 2, pages 2125–2133, 2015.
+
+[30] Eugenio Bargiacchi, Timothy Verstraeten, Diederik Roijers, Ann Nowé, and Hado Hasselt. Learning to coordinate with coordination graphs in repeated single-stage multi-agent decision problems. In International conference on machine learning, pages 482–490, 2018.
+
+[31] Natasha Jaques, Angeliki Lazaridou, Edward Hughes, Caglar Gulcehre, Pedro Ortega, DJ Strouse, Joel Z Leibo, and Nando De Freitas. Social influence as intrinsic motivation for multi-agent deep reinforcement learning. In International Conference on Machine Learning, pages 3040–3049. PMLR, 2019.
+
+[32] Shariq Iqbal and Fei Sha. Coordinated exploration via intrinsic rewards for multi-agent reinforcement learning. arXiv preprint arXiv:1905.12127, 2019.
+
+[33] M Lengyel and P Dayan. Hippocampal contributions to control: The third way. In Twenty-First Annual Conference on Neural Information Processing Systems (NIPS 2007), pages 889–896. Curran, 2008.
+
+[34] Charles Blundell, Benigno Uria, Alexander Pritzel, Yazhe Li, Avraham Ruderman, Joel Z Leibo, Jack Rae, Daan Wierstra, and Demis Hassabis. Model-free episodic control. arXiv preprint arXiv:1606.04460, 2016.
+
+[35] Alexander Pritzel, Benigno Uria, Sriram Srinivasan, Adria Puigdomenech Badia, Oriol Vinyals, Demis Hassabis, Daan Wierstra, and Charles Blundell. Neural episodic control. In International Conference on Machine Learning, pages 2827–2836. PMLR, 2017.
+
+[36] Steven S Hansen, Pablo Sprechmann, Alexander Pritzel, André Barreto, and Charles Blundell. Fast deep reinforcement learning using online adjustments from the past. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pages 10590–10600, 2018.
+
+[37] Samuel J Gershman and Nathaniel D Daw. Reinforcement learning and episodic memory in humans and animals: an integrative framework. Annual review of psychology, 68:101–128, 2017.
+
+[38] Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+[39] Tabish Rashid, Gregory Farquhar, Bei Peng, and Shimon Whiteson. Weighted QMIX: expanding monotonic value function factorisation for deep multi-agent reinforcement learning. In Proceedings of the Annual Conference on Neural Information Processing Systems 2020 (NeurIPS 2020), 2020.
+
+[40] Tonghan Wang, Tarun Gupta, Anuj Mahajan, Bei Peng, Shimon Whiteson, and Chongjie Zhang. Rode: Learning roles to decompose multi-agent tasks. arXiv preprint arXiv:2010.01523, 2020.
+
+[41] Yihan Wang, Beining Han, Tonghan Wang, Heng Dong, and Chongjie Zhang. Dop: Offpolicy multi-agent decomposed policy gradients. In International Conference on Learning Representations, 2020.
+
+[42] Yuri Burda, Harri Edwards, Deepak Pathak, Amos Storkey, Trevor Darrell, and Alexei A Efros. Large-scale study of curiosity-driven learning. arXiv preprint arXiv:1808.04355, 2018.
+
+[43] Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado Van Hasselt, and David Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018.
+
+[44] Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015.
+
+[45] Matteo Hessel, Joseph Modayil, Hado Van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. In Thirty-second AAAI conference on artificial intelligence, 2018.

parse/train/YDGJ5YExiw6/YDGJ5YExiw6_content_list.json

@@ -0,0 +1,1383 @@
+[
+    {
+        "type": "text",
+        "text": "Episodic Multi-agent Reinforcement Learning with Curiosity-driven Exploration ",
+        "text_level": 1,
+        "bbox": [
+            189,
+            122,
+            810,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lulu Zheng∗1, Jiarui Chen∗2 3, Jianhao Wang1, Jiamin $\\mathbf { H e ^ { 4 \\dagger } }$ , $\\mathbf { Y u j i n g \\ : H u ^ { 3 } }$ , Yingfeng Chen3, Changjie $\\mathbf { F a n ^ { 3 } }$ , Yang $\\mathbf { G a o ^ { 2 } }$ , Chongjie Zhang1 ",
+        "bbox": [
+            183,
+            224,
+            820,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Institute for Interdisciplinary Information Sciences, Tsinghua University, China   \n2Department of Computer Science and Technology, Nanjing University, China 3Fuxi AI Lab, NetEase, China 4Department of Computing Science, University of Alberta, Canada zll19@mails.tsinghua.edu.cn chenjiarui@smail.nju.edu.cn wjh19@mails.tsinghua.edu.cn jiamin12@ualberta.ca {huyujing, chenyingfeng01, fanchangjie}@corp.netease.com gaoy@nju.edu.cn chongjie@tsinghua.edu.cn ",
+        "bbox": [
+            240,
+            256,
+            766,
+            409
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            444,
+            535,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Efficient exploration in deep cooperative multi-agent reinforcement learning (MARL) still remains challenging in complex coordination problems. In this paper, we introduce a novel Episodic Multi-agent reinforcement learning with Curiosity-driven exploration, called EMC. We leverage an insight of popular factorized MARL algorithms that the “induced\" individual Q-values, i.e., the individual utility functions used for local execution, are the embeddings of local actionobservation histories, and can capture the interaction between agents due to reward backpropagation during centralized training. Therefore, we use prediction errors of individual Q-values as intrinsic rewards for coordinated exploration and utilize episodic memory to exploit explored informative experience to boost policy training. As the dynamics of an agent’s individual Q-value function captures the novelty of states and the influence from other agents, our intrinsic reward can induce coordinated exploration to new or promising states. We illustrate the advantages of our method by didactic examples, and demonstrate its significant outperformance over state-of-the-art MARL baselines on challenging tasks in the StarCraft II micromanagement benchmark. ",
+        "bbox": [
+            232,
+            477,
+            766,
+            695
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            722,
+            310,
+            739
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Cooperative multi-agent reinforcement learning (MARL) has great promise to solve many real-world multi-agent problems, such as autonomous cars [1] and robots [2]. These complex applications post two major challenges for cooperative MARL: scalability, i.e., the joint-action space exponentially grows as the number of agents increases, and partial observability, which requires agents to make decentralized decisions based on their local action-observation histories due to communication constraints. Luckily, a popular MARL paradigm, called centralized training with decentralized execution (CTDE) [3], is adopted to deal with these challenges. With this paradigm, agents’ policies are trained with access to global information in a centralized way and executed only based on local histories in a decentralized way. Based on the paradigm of CTDE, many deep MARL methods have been proposed, including VDN [4], QMIX [5], QTRAN [6], and QPLEX [7]. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            864
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A core idea of these approaches is to use value factorization, which uses neural networks to represent the joint state-action value as a function of individual utility functions, which can be referred to individial $Q$ -values for terminological simplicity. For example, VDN learns a centralized but factorizable joint value function $Q _ { t o t }$ represented as the summation of individual value function $Q _ { i }$ . During execution, the decentralized policies can be easily derived for each agent $i$ by greedily selecting actions with respect to its local value function $Q _ { i }$ . By utilizing this factorization structure, an implicit multi-agent credit assignment is realized because $Q _ { i }$ is represented as a latent embedding and is learned by neural network backpropagation from the total temporal-difference error on the single global reward signal, rather than on a local reward signal specific to agent $i$ . This value factorization technique enables value-based MARL approaches, such as QMIX and QPLEX, to achieve state-ofthe-art performance in challenging tasks such as the StarCraft unit micromanagement [8]. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite the current success, since only using simple $\\epsilon$ -greedy exploration strategy, these deep MARL approaches are found ineffective to solve complex coordination tasks that require coordinated and efficient exploration [7]. Exploration has been extensively studied in single-agent reinforcement learning and many advanced methods have been proposed, including pseudo-counts [9, 10], curiosity [11, 12], and information gain [13]. However, these methods cannot be adopted into MARL directly, due to the exponentially growing state space and partial observability, leaving multi-agent exploration challenging. Recently, only a few works have tried to address this problem. For instance, EDTI [14] uses influence-based methods to quantify the value of agents’ interactions and coordinate exploration towards high-value interactions. This approach empirically shows promising results but, because of the need to explicitly estimate the influence among agents, it is not scalable when the number of agents increases. Another method, called MAVEN [15], introduces a hierarchical control method with a shared latent variable encouraging committed, temporally extended exploration. However, since the latent variable still needs to explore in the space of joint behaviours [15], it is not efficient in complex tasks with large state spaces. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a novel multi-agent curiosity-driven exploration method. Curiosity is a type of intrinsic motivation for exploration, which usually uses prediction errors on different spaces (e.g., future observations [12], actions [11], or learnable representation [16]) as a reward signal. Recently, curiosity-driven methods have achieved significant success in single-agent reinforcement learning [12, 17, 18]. However, curiosity-driven methods face a critical challenge in MARL: in which space should we define curiosity? The straightforward method is to measure curiosity on the global observation [12] or joint histories in a centralized way. However, it is inefficient to find structured interaction between agents, which seems too sparse compared with the exponentially growing state space when the number of agents increases. In contrast, if curiosity is defined as the novelty of local observation histories during the decentralized execution, although scalable, it still fails to guide agents to coordinate due to partial observability. Therefore, we find a middle point of centralized curiosity and decentralized curiosity, i.e., utilizing the value factorization of the state-of-the-art multi-agent Q-learning approaches and defining the prediction errors of individual Q-value functions as intrinsic rewards. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The significance of this intrinsic reward is twofold: 1) it provides a novelty measure of joint observation histories with scalability because individual Q-values are latent embeddings (i.e., an effective state abstraction [19]) of observation histories in factorized multi-agent Q-learning (e.g., VDN or QPLEX); and 2) as shown in Figure 1, it captures the influence from other agents due to the implicit credit assignment from global reward signal during centralized training [20], and biases exploration into promising ",
+        "bbox": [
+            174,
+            664,
+            485,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/e42c0e6c468417fb743373d9abc3431cd767200868d964c89ea960b2f12b26fc.jpg",
+        "image_caption": [
+            "Figure 1: CTDE Framework "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            680,
+            823,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "states where strong interdependence may lie between agents. Therefore, with this novel intrinsic reward, our curiosity-driven method enables efficient, diverse, and coordinated exploration for deep multi-agent Q-learning with value factorization. ",
+        "bbox": [
+            176,
+            815,
+            826,
+            856
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Besides efficient exploration, another challenge for deep MARL approaches is how to make the best use of experiences collected by the exploration strategy. Prioritized experience replay based on TD errors shows effectiveness in single-agent deep reinforcement learning. However, it does not carry this promise in factorized multi-agent Q-learning, since the projection error induced by value factorization is also fused into the TD error and severally degrades the effectiveness of the TD error as a measure of the usefulness of experiences. To efficiently use promising exploratory experience trajectories, we augment factorized multi-agent reinforcement learning with episodic memory [21, 22]. This memory stores and regularly updates the best returns for explored states. We use the results in the episodic memory to regularize the TD loss, which allows fast latching onto past successful experience trajectories collected by curiosity-driven exploration and greatly improves learning efficiency. Therefore, we call our method Episodic Multi-agent reinforcement learning with Curiosity-driven exploration, called EMC. ",
+        "bbox": [
+            176,
+            863,
+            823,
+            905
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We evaluate EMC in didactic examples, and a broad set of StarCraft II micromanagement benchmark tasks [8]. The didactic examples along with detailed visualization illustrate that our proposed intrinsic reward can guide agents’ policies to novel or promising states, thus enabling effectively coordinated exploration. Empirical results on more complicated StarCraft II tasks show that EMC significantly outperforms other multi-agent state-of-the-art baselines. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            310,
+            308,
+            327
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Dec-POMDP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            340,
+            303,
+            356
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A cooperative multi-agent task can be modelled as a Dec-POMDP [23], which is defined by a tuple $G = < \\mathcal { T } , \\mathcal { S } , \\mathcal { A } , P , R , \\Omega , O , n , \\gamma >$ , where $\\mathcal { T }$ is the sets of $n$ agents, $s$ is the global state space, $\\mathcal { A }$ is the finite action set, $\\gamma \\in [ 0 , 1 )$ is the discount factor. We consider a partially observable setting in a Dec-POMDP, i.e., at each timestep, agent $i \\in \\mathcal { T }$ only has access to the observation $o _ { i } \\in \\varOmega$ drawn from the observation function $O ( s , i )$ . Besides, each agent has an action-observation history $\\tau _ { i } \\in \\mathcal { T } \\equiv \\left( \\varOmega \\times \\mathcal { A } \\right) ^ { * } \\times \\varOmega$ and constructs its individual policy to jointly maximize team performance. With each agent $i$ selecting an action $a _ { i } \\in { \\mathcal { A } }$ , the joint action $\\mathbf { \\bar { a } } \\equiv [ a _ { i } ] _ { i = 1 } ^ { n } \\in \\mathcal { A } \\equiv \\mathcal { A } ^ { N }$ leads to a shared reward $r = R ( s , { \\pmb a } )$ and the next state $s ^ { \\prime }$ according to the transition distribution $P ( s ^ { \\prime } | s , \\pmb { a } )$ . The formal objective function is to find a joint policy $\\pi$ that maximizes a joint value function $V ^ { \\pi } ( s ) =$ $\\mathbb { E } [ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r _ { t } \\big | s = s _ { 0 } , \\pi ]$ , or a joint action-value function $Q ^ { \\pi } ( s , \\pmb { a } ) = r \\overline { { } } ( s , \\pmb { a } ) + \\gamma \\mathbb { E } _ { s ^ { \\prime } } [ V ^ { \\pmb { \\pi } } ( s ^ { \\prime } ) ]$ . ",
+        "bbox": [
+            173,
+            366,
+            826,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Centralized Training With Decentralized Execution (CTDE) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            520,
+            632,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CTDE is a promising paradigm in deep cooperative multi-agent reinforcement learning [3, 23, 24], where the local agents execute actions only based on local observation histories, while the policies can be trained in centralized manager which has access to global information. During the training process, the whole team cooperate to find the optimal joint action-value function $Q _ { t o t } ^ { * } ( s , \\pmb { a } ) =$ $\\grave { r } ( s , \\pmb { a } ) + \\gamma \\mathbb { E } _ { s ^ { \\prime } } [ \\operatorname* { m a x } _ { \\pmb { a } ^ { \\prime } } Q _ { t o t } ^ { * } ( s ^ { \\bar { \\prime } } , \\pmb { a } ^ { \\prime } ) ]$ . Due to partial observability, we use $Q _ { t o t } ( \\tau , a ; \\theta )$ instead of $Q _ { t o t } ( s , \\pmb { a } ; \\pmb { \\theta } )$ , where $\\pmb { \\tau } \\in \\mathcal { T } \\equiv \\mathcal { T } ^ { N }$ . Then the Q-value neural network will be trained to minimize the following expected TD-error: ",
+        "bbox": [
+            173,
+            545,
+            825,
+            642
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/009aa560a383d6a55daf00bd3f30d0e652318cc6f9c529ffd61e65719d1350cf.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } ( \\pmb { \\theta } ) = \\mathbb { E } _ { \\tau , a , r , \\tau ^ { \\prime } \\in D } \\left[ r + \\gamma V ( \\pmb { \\tau ^ { \\prime } } ; \\pmb { \\theta } ^ { - } ) - Q _ { t o t } ( \\pmb { \\tau } , \\pmb { a } ; \\pmb { \\theta } ) \\right] ^ { 2 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            642,
+            689,
+            664
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $D$ is the replay buffer and $\\pmb { \\theta } ^ { - }$ denotes the parameters of the target network, which is periodically updated by $\\pmb \\theta$ . And $\\operatorname { V } ( \\tau ^ { \\prime } ; \\theta ^ { - } )$ is the one-step expected future return of the TD target. Local agents can only obtain local action-observation history and need inference based on individual Q-value functions $Q _ { i } ( \\tau _ { i } , a _ { i } )$ . Therefore, many works have made efforts in finding the factorization structures between joint Q-value functions $Q _ { t o t }$ and individual Q-functions $Q _ { i } ( \\tau _ { i } , a _ { i } )$ [4, 5, 7]. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            756,
+            321,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Curiosity-driven Exploration Curiosity-driven exploration has been well studied in single-agent reinforcement learning. Previous literature [25, 26] has provided a good summary in this topic. Recently, curiosity-driven methods have made great progress in deep reinforcement learning. For example, some works use pseudo-state counts to get intrinsic rewards [9, 10, 27] instead of countbased methods to get better scalability. Stadie et al. [28] use prediction errors in the feature space of an auto-encoder to measure the novelty of states and encourage exploration. On the other hand, Mohamed and Rezende [29] propose to use empowerment, measured by the information gain based on the entropy of actions, as intrinsic rewards for exploring novel states efficiently. Another informationbased method [13] tries to maximize information gain about the agent’s belief of the environment’s dynamics as an exploration strategy. ICM [11] learns an inverse model which predicts the agent’s action given its current and next states and tries to predict the next state in the learned hidden space by current state and action. RND [12] uses curiosity as intrinsic rewards in a simpler but effective way, which uses a fixed randomly initialized neural network as a representation network and directly predicts the embedding of the next state. Different from these methods, we are the first to propose an advanced curiosity-driven exploration method in MARL setting for diverse and coordinated exploration. ",
+        "bbox": [
+            174,
+            786,
+            826,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Multi-agent Exploration Although single-agent exploration is extensively studied and has achieved considerable success, few exploration methods were designed for cooperative MARL. Bargiacchiet al. [30] proposes an exploration method that can only be used in repeated single-stage problems. Jaques et al. [31] defines intrinsic reward by “social influence” to encourage agents to choose actions that can influence other agents’ actions. Iqbal and Sha [32] uses various simple exploration methods to learn simultaneously and then put the samples of every method in a shared buffer to achieve the coordinated exploration. Wang et al. [14] use mutual information (MI) to capture the interdependence of the rewards and transitions between agents. MAVEN [15] is the state-of-the-art exploration method in MARL that uses a hierarchical policy to produce a shared latent variable and learns several state-action value functions for each agent. These works, although important, still face the challenge of achieving scalable and effective multi-agent exploration. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Episodic Control Our work is also related to episodic control reinforcement learning, which is usually adopted in single-agent settings for better sample efficiency. Previous works propose to use episodic memory in near-deterministic environment [33–36]. Model-free episodic control [34] uses a completely non-parametric table to keep the best Q-values of state-action pair in a tabular-based memory and uses a $\\mathbf { k }$ -nearest-neighbors fashion to find the sequence of actions that so far yielded the highest return from a given start state in the memory. Recently, several extensions have been proposed to integrate episodic control with parametric DQN. Gershman and Daw [37] uses episodic memory to retrieve samples and then average future returns to approximate the action values. EMDQN [21] uses a fixed random matrix as a representation function and uses the projection of states as keys to store the information of episodic memory into a non-parametric model. Using the episodic-memory based target as a regularization term to guide the training process, the performance of EMDQN is significantly improved compared with the original DQN. Despite the fruitful progress made in single-agent episodic reinforcement learning, few works study episodic control in a multi-agent setting. To the best of our knowledge, we are the first to utilize the mechanism of episodic control in deep multi-agent reinforcement learning. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Episodic Multi-agent Reinforcement Learning with Curiosity-Driven Exploration ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            580,
+            779,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce EMC, a novel episodic multi-agent exploration framework. EMC takes prediction errors of individual Q-value functions as intrinsic rewards for guiding the diverse and coordinated exploration. After collecting informative experience, we leverage an episodic memory to memorize the highly rewarding sequences and use it as the reference of a one-step TD target to boost multi-agent Q-learning. First, we analyze the motivations for predicting individual Q-values, then we introduce the curiosity module for exploration. Finally, we describe how to utilize episodic memory to boost training. ",
+        "bbox": [
+            173,
+            628,
+            825,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Curiosity-Driven Exploration by Predicting Individual Q-values ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            743,
+            658,
+            758
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 2, in the paradigm of CDTE, local agents make decisions based on individual Q-value functions, which take local observation histories as inputs, and are updated by the centralized module which has access to global information for training. The key insight is that, different from single-agent cases, individual Q-value functions in MARL are used for both decision-making and embedding historical observations. Furthermore, due to implicit credit assignment by global reward signal during centralized training, individual Q-value functions $Q _ { i } ( \\tau _ { i } , \\cdot )$ are influenced by environment as well as other agents’ behaviors. More concretely, it has been proved by Wang et al. [20] that, when the joint Q-function Q-functions $Q _ { i }$ , i.e., $\\begin{array} { r } { Q _ { t o t } ^ { ( t + 1 ) } ( \\pmb { \\tau } , \\pmb { a } ) = \\sum _ { i = 1 } ^ { N } Q _ { i } ^ { ( t + 1 ) } ( \\tau _ { i } , a _ { i } ) } \\end{array}$ $Q _ { t o t }$ is factorized into linear combination of individual , then $Q _ { i } ^ { ( t + 1 ) } ( \\tau _ { i } , a _ { i } )$ has the following closed-form solution: ",
+        "bbox": [
+            174,
+            768,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b5b9acf54711aa687676193ab6b7319d06a78c5587fbb68710ee9718c7d45023.jpg",
+        "text": "$$\nQ _ { i } ^ { ( t + 1 ) } ( \\tau _ { i } , a _ { i } ) = \\underset { ( \\tau _ { - i } ^ { \\prime } , a _ { - i } ^ { \\prime } ) \\sim p _ { D } ( \\cdot \\vert \\tau _ { i } ) } { \\mathbb { E } } \\left[ y ^ { ( t ) } \\left( \\tau _ { i } \\oplus \\tau _ { - i } ^ { \\prime } , a _ { i } \\oplus a _ { - i } ^ { \\prime } \\right) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            87,
+            678,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/44d74bf0698a02f01424456ae24e7fd8e4c2e08ec7f4e01003807497369352b7.jpg",
+        "text": "$$\n- \\frac { n - 1 } { n } \\mathop { \\mathbb { E } } _ { \\tau ^ { \\prime } , a ^ { \\prime } \\sim p _ { D } ( \\cdot | \\Lambda ^ { - 1 } ( \\tau _ { i } ) ) } \\left[ y ^ { ( t ) } \\left( \\tau ^ { \\prime } , a ^ { \\prime } \\right) \\right] + w _ { i } ( \\tau _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            141,
+            725,
+            176
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { y ^ { ( t ) } ( \\pmb { \\tau } , \\pmb { a } ) = r + \\gamma \\mathbb { E } _ { \\pmb { \\tau } ^ { \\prime } } \\left[ \\operatorname* { m a x } _ { \\pmb { a } ^ { \\prime } } Q _ { t o t } ^ { ( t ) } \\left( \\pmb { \\tau } ^ { \\prime } , \\pmb { a } ^ { \\prime } \\right) \\right] } \\end{array}$ denotes the expected one-step TD target, and $p _ { D } ( \\cdot | \\tau _ { i } )$ denotes the conditional empirical probability of $\\tau _ { i }$ in the given dataset $D$ . The notation $\\tau _ { i } \\oplus \\tau _ { - i } ^ { \\prime }$ denotes $\\langle \\tau _ { 1 } ^ { \\prime } , \\dots , \\tau _ { i - 1 } ^ { \\prime } , \\tau _ { i } , \\tau _ { i + 1 } ^ { \\prime } , \\dots , \\bar { \\tau } _ { n } ^ { \\prime } \\rangle$ , and $\\boldsymbol { \\tau } _ { - i } ^ { \\prime }$ denotes the elements of all agents except for agent $i$ . $\\Lambda ^ { - 1 } ( \\tau _ { i } )$ denotes the set of trajectory histories that may share the same latent-state trajectory as $\\tau _ { i }$ i . The residue term $\\pmb { w } \\equiv [ w _ { i } ] _ { i = 1 } ^ { n }$ is an arbitrary function satisfying $\\forall \\tau \\in \\mathbf { T }$ , $\\scriptstyle \\sum _ { i = 1 } ^ { n } w _ { i } ( \\tau _ { i } ) = 0$ . ",
+        "bbox": [
+            173,
+            202,
+            826,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Eq. (2) shows that by linear value factorization, the individual Q-value $Q _ { i } ( \\tau _ { i } , a _ { i } )$ is not only decided by local observation histories but also influenced by other agents’ action-observation histories. Thus predicting $Q _ { i }$ can capture both the novelty of states and the interaction between agents and lead agents to explore promising states. Motivated by this insight, in this paper, we use a linear value factorization module separate from the inference module to learn the individual value function $Q _ { i }$ , and use the prediction errors of $Q _ { i }$ as intrinsic rewards to guide exploration. In this paper, we define the prediction errors of individual Q-values as curiosity and propose our curiosity-driven exploration module as follows. ",
+        "bbox": [
+            173,
+            289,
+            826,
+            400
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9efd746fe71d13035fe0deba3d9c4985e973d4faf27e4788e6e073a18ce01c1.jpg",
+        "image_caption": [
+            "Figure 2: An overview of EMC’s framework "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            412,
+            816,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2b demonstrates the Curiosity Module, separated from the inference module (Figure 2a). The curiosity module consists of four components: (i) The centralized training part with linear value factorization, which shares the same implementation as VDN [4], but only trained with extrinsic rewards $r ^ { e x t }$ from the environment; (ii) the Target for prediction, i.e., the corresponding individual Q-values ${ Q _ { i } ^ { e x t } }$ , represented by a recurrent Q-network; (iii) Predictor $\\widetilde { Q } _ { i } ( \\tau _ { i } )$ , which is used for predicting ${ Q _ { i } ^ { e x t } }$ and shares the same network architecture as Target ${ Q _ { i } ^ { e x t } }$ ; and (iv) Distance Function, which measures the distance between ${ Q _ { i } ^ { e x t } }$ and $\\widetilde { Q } _ { i }$ , e.g., $L _ { 2 }$ distance. The predictors are trained by minimizing the Mean Squared Error (MSE) of the distance in an end-to-end manner. For stable training, we use the soft-update target [38] of ${ Q _ { i } ^ { e x t } }$ to smooth the outputs of the targets. In general, (ii) is trained with (i) and outputs individual Q-values , while (iii) is trained with (ii) and (iv), and aims to predict the soft-update target of individual Q-values. Motivated by the implicit credit assignment of linear value factorization (Eq. (2)), the curiosity module predicts the individual Q-values $\\bar { \\big [ Q _ { i } ^ { e x t } \\big ] } _ { i = 1 } ^ { n }$ in linear factorization, i.e., $\\begin{array} { r } { Q _ { t o t } ^ { e x t } = \\sum _ { i = 1 } ^ { N } Q _ { i } ^ { e x t } } \\end{array}$ . Then the curiosity-driven intrinsic reward is generated by the following equation: ",
+        "bbox": [
+            173,
+            671,
+            826,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/060d2c4b3c38366399c81b36fd8eea30749596cdf507d427a9dcf97287570077.jpg",
+        "text": "$$\nr ^ { i n t } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\left. \\widetilde { Q } _ { i } ( \\tau _ { i } , \\cdot ) - Q _ { i } ^ { e x t } ( \\tau _ { i } , \\cdot ) \\right. _ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            873,
+            635,
+            916
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This intrinsic reward is used for the centralized training of the inference module, as shown in Figure 2a: ",
+        "bbox": [
+            171,
+            90,
+            826,
+            107
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cfbf4b35331d64209a776c613ca402e4ba9ec629e0910ee82b796de2335a55ef.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { i n f e r e n c e } } ( \\pmb { \\theta } ) = \\mathbb { E } _ { \\pmb { \\tau } , \\pmb { a } , \\pmb { r } , \\pmb { \\tau } ^ { \\prime } \\in D } \\left[ \\left( \\pmb { y } ( \\pmb { \\tau } , \\pmb { a } ) - Q _ { t o t } ( \\pmb { \\tau } , \\pmb { a } ; \\pmb { \\theta } ) \\right) ^ { 2 } \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            114,
+            689,
+            141
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where y(τ , $\\begin{array} { r } { \\mathbf { \\Delta } \\mathbf { a } ) = r ^ { e x t } + \\beta r ^ { i n t } + \\gamma \\operatorname* { m a x } _ { \\mathbf { a } ^ { \\prime } } Q _ { t o t } \\left( \\tau ^ { \\prime } , a ^ { \\prime } ; \\theta ^ { - } \\right) ) } \\end{array}$ , denoting one step TD target of the inference module, and $\\beta$ is the weight term of the intrinsic reward. We use a separate training model for inference (Figure 2a) to avoid the accumulation of projection errors of $Q _ { i }$ during training. ",
+        "bbox": [
+            174,
+            143,
+            825,
+            186
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The independence of inference module leads to another advantage, that EMC’s architecture can be adopted into many value-factorization-based multi-agent algorithms which utilize the CDTE paradigm, i.e., the general function $f$ in Figure $2 \\mathrm { a }$ can indicate specific (linear, monotonic and IGM) value factorization structures in VDN [4], QMIX [5], and QPLEX [7], respectively. In this paper, we utilize these state-of-the-art algorithms for the inference module. With this curiosity-driven bias plugged into ordinary MARL algorithms, EMC will achieve efficient, diverse and coordinated exploration. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            290
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Episodic Memory ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            305,
+            336,
+            320
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Equipped with efficient exploration ability, another challenge is how to make the best use of good trajectories collected by exploration effectively. Recently, episodic control has been widely studied in single-agent reinforcement learning [21, 22], which can replay the highly rewarding sequences, thus boosting training. Inspired by this framework, we generalize single-agent episodic control to propose a multi-agent episodic memory, which records the best memorized Monte-Carlo return in the episode, and provide a memory target $H$ as a reference to regularize the ordinary one-step inference TD target estimation in the inference module (Figure 2a): ",
+        "bbox": [
+            173,
+            330,
+            826,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4cb7f7edb8d394ec2f0f1918996c1abf83850b6431e09947fa1cc06f4b6b065.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { m e m o r y } } ( \\pmb { \\theta } ) = \\mathbb { E } _ { \\pmb { \\tau } , \\pmb { a } , \\pmb { r } , \\pmb { \\tau } ^ { \\prime } \\in D } \\left[ \\left( H - Q _ { t o t } ( \\pmb { \\tau } , \\pmb { a } ; \\pmb { \\theta } ) \\right) ^ { 2 } \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            433,
+            671,
+            460
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, different from the single-agent episodic control, the action space of MARL exponentially grows as the number of agents increases, and partial observability also limits the information of individual value functions. Thus, we maintain our episodic memory by storing the state-value function on the global state space and utilizing the global information during the centralized training process under the CTDE paradigm. Figure 2d shows the architecture of the Episodic Memory. We keep a memory table $M$ to record the maximum remembered return of the current state, and use a fixed random matrix drawn from Gaussian distribution as a representation function to project states into low-dimensional vectors $\\phi ( s ) : S \\to \\mathbb { R } ^ { k }$ , which are used as keys to look up corresponding global state value function $H ( \\phi ( s _ { t } ) )$ . When our exploration method collects a new trajectory, we update our memory table $M$ as follows: ",
+        "bbox": [
+            173,
+            463,
+            825,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2dceae5412ccb0fcacf155e0131de3132c0278e18f856b970c5c0cb4cc9cffae.jpg",
+        "text": "$$\nH ( \\phi ( s _ { t } ) ) = \\left\\{ \\begin{array} { l l } { \\operatorname* { m a x } \\{ H ( \\phi ( \\hat { s } _ { t } ) ) , R _ { t } ( s _ { t } , \\pmb { a } _ { t } ) \\} } & { i f \\| \\phi ( \\hat { s } _ { t } ) - \\phi ( s _ { t } ) \\| _ { 2 } < \\delta } \\\\ { R _ { t } ( s _ { t } , \\pmb { a } _ { t } ) } & { o t h e r w i s e } \\end{array} \\right. ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            608,
+            733,
+            643
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\phi ( \\hat { s } _ { t } )$ is $\\phi ( s _ { t } )$ ’s nearest neighbor in the memory $M , \\delta$ is a threshold, and $R ( s _ { t } , \\pmb { a } _ { t } )$ represents the future return when agents taking joint action $\\mathbf { } \\mathbf { a } _ { t }$ under global state $s _ { t }$ at the $t$ -th timestep in a new episode. In our implementation, $\\phi ( s _ { t } ) \\in M$ is indeed evaluated approximately based on the embedding distance. Specifically, when the key of the state $\\phi ( s _ { t } )$ is close enough to one key in the memory, we assume that $\\dot { \\phi } ( s _ { t } ) \\in M$ and find the best memorized Monte-Carlo return correspondingly. Otherwise, we think $\\phi ( s _ { t } ) \\notin M$ and record the state’s return into the memory. Leveraging the episodic memory, we can directly obtain the maximum remembered return of the current state, and use the one-step TD memory target $H$ as a reference to regularize learning: ",
+        "bbox": [
+            173,
+            648,
+            826,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/39c744a18dedeb7550e9c020538d97a1604678919f744d1f51d91575039214b9.jpg",
+        "text": "$$\nH ( \\phi ( s _ { t } ) , \\pmb { a } _ { t } ) = r _ { t } ( s _ { t } , \\pmb { a } _ { t } ) + \\gamma H ( \\phi ( s _ { t + 1 } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            765,
+            643,
+            781
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Thus, the new objective function for the inference module is: ",
+        "bbox": [
+            171,
+            786,
+            573,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/08d7bbb9a6e32f8b18c3c5d8498c46201a82e53fa746e0a1b3e21d24f05d8257.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\mathrm { { t o t a l } } } ( \\theta ) = \\mathcal { L } _ { \\mathrm { i n f e r e n c e } } ( \\theta ) + \\lambda \\mathcal { L } _ { \\mathrm { m e m o r y } } ( \\theta ) } \\\\ & { \\qquad = \\mathbb { E } _ { \\tau , a , r , \\tau ^ { \\prime } \\in D } \\left[ \\left( y ( \\tau , a ) - Q _ { t o t } ( \\tau , a ; \\theta ) \\right) ^ { 2 } + \\lambda \\left( H \\left( \\phi ( s _ { t } ) , a _ { t } \\right) - Q _ { t o t } ( \\tau , a ; \\theta ) \\right) ^ { 2 } \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            804,
+            795,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is the weighting term to balance the effect of episodic memory’s reference. Using the maximum return from the episodic memory to propagate rewards, we can compensate for the disadvantage of slow learning induced by the original one-step reward update and improve sample efficiency. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            89,
+            312,
+            107
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will conduct a large set of empirical experiments for answering the following questions: (1) Is exploration by predicting individual Q-value functions better than exploration by decentralized curiosity or global curiosity (Section 5.1)? (2) Can our method perform efficient coordinated exploration in challenging multi-agent tasks (Section 5.2-5.3)? (3) If so, what role does each key component play for the superior performance (Section 5.4)? (4) Why do we choose to predict target ${ \\dot { Q } } _ { i } ^ { e x t }$ for generating intrinsic rewards rather than other choices (Section 5.4)? We will propose several didactic examples and demonstrate the advantage of our method in coordinated exploration, and evaluate our method on the StarCraft II micromanagement (SMAC) benchmark [8] compared with existing state-of-the-art multi-agent reinforcement learning (MARL) algorithms: QPLEX [7], Weighted-QMIX [39], QTRAN [6], QMIX [5], VDN [4], RODE [40], and MAVEN [15]. ",
+        "bbox": [
+            173,
+            126,
+            826,
+            265
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Didactic Example ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            289,
+            336,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows an $1 1 \\times 1 2$ grid world game that requires coordinated exploration. The blue agent and the red agent can choose one of the five actions: [up, down, left, right, stay] at each time step. The wall shown in the picture isolates the two agents, and one agent cannot be observed by the other until it gets into the shaded area. The two agents will receive a positive global reward $r = 1 0$ if and only if they arrive at the corresponding goal grid (referred to the character $G$ in Figure 3) at the same time. If only one arrives, the incoordination will be punished by a negative reward $- p$ . ",
+        "bbox": [
+            173,
+            318,
+            825,
+            401
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the effectiveness of our curiosity-driven exploration, we implement our method into QPLEX, QMIX, and VDN (denoted as EMCQPLEX, EMC-QMIX, and EMC-VDN, respectively) and test them in this toy game compared with the state-of-the-art MARL algorithms: VDN, IQL, QMIX, and QPLEX. Moreover, to demonstrate the motivation of predicting individual Q-functions, we add two more baselines: QPLEX with the prediction error of global state as intrinsic rewards (denoted as QPLEX-Global), and QPLEX with the prediction error of local joint histories as intrinsic rewards (denoted as QPLEX-Local). Both of them use a fixed network to project the inputs into latent embedding, then predict the latent embedding to generate intrinsic reward, just like the ",
+        "bbox": [
+            174,
+            407,
+            647,
+            559
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca5b8da9a792c7093c35684dbd271a5f64febc1a0227763618e2913be06de2d7.jpg",
+        "image_caption": [
+            "Figure 3: Coordinated Toygame "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            660,
+            428,
+            823,
+            522
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Random Network Distillation (RND) [12]. We test different punishment degrees, i.e., different ps (which are deferred to Appendix C), and the results show QPLEX-Global and QPLEX-Local are effective enough for exploration when $p$ is relatively small. However, as $p$ increases, the task becomes more challenging since it requires sufficient and coordinated exploration. In Figure 4, we show the median test win rate of all methods over 6 random seeds when $p = 2$ , and only our methods can learn the optimal policy and win the game, while other methods failed. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To understand this result better, we have made several visualisations to demonstrate our advantage in coordinated exploration. Figure 4 shows the heatmaps of visitation and intrinsic reward by EMC-QPLEX, QPLEX-Global, and QPLEX-Local. During the early stage of training, all methods uniformly explore the whole area (Figure 4a). As the exploration progresses, the global curiosity (QPLEX-Global) encourages agents to visit all configurations without bias, which is inefficient and fail to leverage the potential locality influence between agents (Figure 4b), resulting in extrinsic rewards beginning to dominate the behaviors (Figure 4c). On the other hand, the visitation heatmap of QPLEX-Local shows the decentralized curiosity encourages agents to explore around the goal grid, but it cannot promise to encourage agents to coordinate and gain the reward due to the partial observability in decentralized execution. In contrast, the heatmap of intrinsic reward for EMC-QPLEX shows that predicting individual Q-values will bias exploration into areas where individual Q-values are more dynamic due to the potential correlation between agents. Therefore, QPLEX-Local and QPLEX-Global both fail in this task (Figure 4c), while our methods are able to find the optimal policy. This didactic example shows the global curiosity or local curiosity may fail to handle complex tasks where coordinated exploration needs to be addressed. While since individual Q-values $Q _ { i }$ are the embeddings of historical observations, and are dynamically updated by the backpropagation of the global reward signal gained through cooperation during centralized training. Thus $Q _ { i }$ can implicitly reflect the influence from the environment and other agents, and predicting $Q _ { i }$ can capture valuable and spare interactions among agents and bias exploration into new or promising states. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/46b4ce175f984bcf4e93709364f50b46cb692db50705fdea07c5db028bcc0b41.jpg",
+        "image_caption": [
+            "Figure 4: The heat map of gridworld game. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            71,
+            813,
+            397
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Predator Prey ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            443,
+            312,
+            458
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Predator-Prey is a partially-observable multi-agent coordinated game with miscoordination penalties used by WQMIX [39]. As shown in Figure 5, since extensive exploration is needed to jump out of the local optima, WQMIX is the only baseline algorithm to find the optimal policy, due to its shaped data distribution which can be seen as a type of exploration. Other state-of-the-art multiagent Q-learning algorithms, such as QPLEX and QMIX, fail to solve this task. For MAVEN, QPLEC-Global and QPLEX-Local, although equipped with improved exploration ability, they still failed to address coordination due to uniform exploration nature or partial observability. However, plugged with EMC, EMC-VDN, EMC-QMIX, and EMC-QPLEX can guarantee coordinated exploration effectively and achieve good performance. ",
+        "bbox": [
+            174,
+            469,
+            550,
+            675
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c6077708920775c9bb9f24a71e77ac9a5502ad0ea117998b1060b2eb133654b.jpg",
+        "image_caption": [
+            "Figure 5: The performance of Predator Prey. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            563,
+            477,
+            818,
+            618
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 StarCraftII Micromanagement (SMAC) Benchmark ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            684,
+            576,
+            699
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "StarCraft II Micromanagement (SMAC) is a popular benchmark in MARL [4, 5, 7, 40, 39]. We conduct experiments in 17 benchmark tasks of StarCraft II, which contains 14 popular tasks proposed by SMAC [8] and three more super hard cooperative tasks proposed by QPLEX [7]. In the micromanagement scenarios, each unit is controlled by an independent agent that must act based on its own local observation, and the enemy units are controlled by a built-in AI. ",
+        "bbox": [
+            174,
+            710,
+            549,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For evaluation, we compare EMC with the state-of-theart algorithms: RODE [40], QPLEX [7], MAVEN [15], and the two variants of QMIX [5]: CW-QMIX and OWQMIX [39]. All experimental results are illustrated with the median performance and $2 5 - 7 5 \\%$ percentiles. Figure 6 shows the overall performance of the tested algorithms in all these 17 maps. Due to the effective exploration with episodic memory which can efficiently use promising exploratory experience trajectories, EMC is the best performer on up to 6 tasks, underperforms on just three tasks, and ties for the best performer on the rest tasks. ",
+        "bbox": [
+            174,
+            842,
+            550,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4bf2efb0efa78ecaec0d9443037e01d9f94255a96498c39f16cdfac30af38e61.jpg",
+        "image_caption": [
+            "Figure 6: The number of scenarios in which the algorithm’s median test win rate is the highest by as least 1/32. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            575,
+            717,
+            802,
+            858
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/594bd42cd742844f6b9d5a165422ad639638f51e43db23e75976be9f6d989590.jpg",
+        "image_caption": [
+            "Figure 7: Results of super hard maps in SMAC. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            70,
+            820,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            425,
+            825,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The advantages of our algorithm can be mainly illustrated by the results of the six hard maps which need sufficient exploration shown in Figure 7. The three maps in the first row are super hard, and solving them needs efficient, diverse and coordinated exploration. Thus, we can find that the EMC algorithm significantly outperforms other algorithms in corridor and $3 s 5 z \\_ { \\nu s \\_ 3 s 6 z }$ , and also achieves the best performance (equal to RODE) in $6 h \\_ { \\nu s \\_ } 8 z$ . To the best of our knowledge, this will be the state-of-the-art results in corridor and $3 s 5 z \\_ { \\nu s \\_ 3 s 6 z }$ . For the remaining three maps in the second row $( \\ I c 3 s 8 z _ { - } \\nu s _ { - } I c 3 s 9 z , 5 s I O z$ , and $7 s 7 z$ ), where other baselines can also find winning strategies, due to the boost learning process via episodic memory along with efficient exploration, our algorithm EMC still performs the best in the three maps, with fastest learning speed and the highest rates achieved. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 Ablation Study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            622,
+            316,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To understand the superior performance of EMC, we carry out ablation studies to test the contribution of its two main components: curiosity module and episodic memory. Following methods are included in the evaluation: (i) EMC without curiosity module (denoted by EMC-wo- $C$ ); (ii) EMC without episodic memory component (denoted by EMC-wo-M); (iii) QPLEX, which can be considered as EMC without the episodic memory component nor the curiosity module, provides a natural ablation baseline of EMC. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            732
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 8(b-c) shows that in easy exploration maps, both EMC and EMC-wo-C achieve the state-of-theart performance, which implies that in the easy tasks, sufficient exploration can be achieved simply by the popular $\\epsilon$ -greedy method. However, in super hard exploration maps (Figure 8 (a)), EMC-wo-C cannot solve this task but EMC has excellent performance. These empirical experiments show that the curiosity module plays a vital role in improving performance when sufficient and coordinated exploration is necessary. On the other hand, making the best use of good trajectories collected by exploration is also essential. As shown Figure 8, EMC with episodic memory enjoys better sample efficiency than EMC-wo-M in challenging (Figure 8a) and easy exploration tasks (Figure 8(b-c)). In general, the curiosity module and the episodic memory complement each other, and efficiently using promising exploratory experience trajectories leads to the superior performance of EMC. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Like single-agent curiosity or RND [12] exploration methods, our approach looks simple yet effective.   \nIn addition, its design choices do not look straightforward before we know how to do it right. ",
+        "bbox": [
+            173,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0e4aa9a00e3abed9e6710b42b0e3a99345be18a84f3cbde550b9102ec88cd3c.jpg",
+        "image_caption": [
+            "Figure 8: Ablation study on the two major components. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            77,
+            820,
+            214
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa5eebfd60744500832ce2fe6c9ee37dd9ce3c43c69a60aea797029a461140f4.jpg",
+        "image_caption": [
+            "Figure 9: Ablation study on design choice. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            247,
+            818,
+            382
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Therefore we conduct additional ablation studies to demonstrate the effect of our elaborate formulation of curiosity bias. We introduce several baselines and compare them with $\\mathrm { E M C } : ( \\mathrm { i } )$ using the normalized TD-error of $Q _ { t o t a l }$ as curiosity rewards, denoted as EMC-TD; (ii) using the averaged error between the individual utilities and their targets as intrinsic rewards, denoted as EMC-Ind; (iii) using the TD error of a centralized critic of the controllers which conditions on all agents’ histories and actions, denoted as EMC-Cen; (iv) using the averaged prediction errors of ${ Q _ { i } ^ { e x t ; d e c } }$ which are trained in a decentralized way, denoted as EMC-Dec. We aim to investigate the subtle implementation difference between EMC and EMC-TD as well as EMC-Ind, and compare the exploration efficiency of our method with the global curiosity-driven exploration method (EMC-Cen) and local curiosity-driven exploration method (EMC-Dec) empirically. ",
+        "bbox": [
+            173,
+            420,
+            825,
+            560
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We design a variant of the toygame mentioned in section 5.1, which has an additional random noisy reward region. By visualizations, we demonstrate that the agents of EMC-TD and EMC-Ind tend to get stuck in the noisy-reward region, thus resulting in sub-optimal policy, while our method show superior ability for avoiding such noise-spike problem. On the other hand, since EMC-Cen is based on global curiosity, which encourages agents to explore the whole state space without bias, it may fail in finding sparse but valuable interaction patterns in the exponentially growing space in complex tasks. When comparing with EMC and EMC-Dec, we find that the key difference is the counterfactual baseline (Eq. (2)), which can theoretically reduce the variance of EMC [41]. Therefore, EMC can focus more on the individual specific contribution and achieve the significant improvements. ",
+        "bbox": [
+            173,
+            568,
+            825,
+            691
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We test these baselines in SMAC and the results are shown in Figure 9, and our method significantly outperform other baselines. In general, by conducting these ablations, we demonstrate the robustness for noise spikes of our design choice ((i) and (ii)), as well as the efficiency and stability of our method compared with centralized or decentralized curiosity-driven exploration method. More detailed discussions will be deferred to Appendix E. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusions and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            781,
+            457,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces EMC, a novel episodic multi-agent reinforcement learning algorithm with a curiosity-driven exploration framework that allows for efficient coordinated exploration and boosted policy training by exploiting explored informative experiences. Based on the effective exploration ability, our method shows significant outperformance over state-of-the-art MARL baselines on challenging tasks in the StarCraft II micromanagement benchmark. The limitation of our work lies in the lack of adaptive exploration methods to ensure robustness. Besides, the episodic memory may get problems in stochastic settings. For future work, we may conduct further research in these directions. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank the anonymous reviewers for their valuable comments and helpful suggestions. This work is supported in part by Science and Technology Innovation 2030 – “New Generation Artificial Intelligence” Major Project (No. 2018AAA0100900), a grant from the Institute of Guo Qiang, Tsinghua University, and a grant from Turing AI Institute of Nanjing. ",
+        "bbox": [
+            174,
+            121,
+            826,
+            176
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            196,
+            266,
+            213
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Yongcan Cao, Wenwu Yu, Wei Ren, and Guanrong Chen. An overview of recent progress in the study of distributed multi-agent coordination. IEEE Transactions on Industrial informatics, 9(1):427–438, 2012.   \n[2] Maximilian Hüttenrauch, Adrian Šošic, and Gerhard Neumann. Guided deep reinforcement ´ learning for swarm systems. arXiv preprint arXiv:1709.06011, 2017.   \n[3] Daniel S Bernstein, Robert Givan, Neil Immerman, and Shlomo Zilberstein. The complexity of decentralized control of markov decision processes. Mathematics of operations research, 27(4):819–840, 2002.   \n[4] Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinícius Flores Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z Leibo, Karl Tuyls, et al. Value-decomposition networks for cooperative multi-agent learning based on team reward. In AAMAS, pages 2085–2087, 2018.   \n[5] Tabish Rashid, Mikayel Samvelyan, Christian Schroeder, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. Qmix: Monotonic value function factorisation for deep multi-agent reinforcement learning. In International Conference on Machine Learning, pages 4295–4304, 2018.   \n[6] Kyunghwan Son, Daewoo Kim, Wan Ju Kang, David Earl Hostallero, and Yung Yi. Qtran: Learning to factorize with transformation for cooperative multi-agent reinforcement learning. arXiv preprint arXiv:1905.05408, 2019.   \n[7] Jianhao Wang, Zhizhou Ren, Terry Liu, Yang Yu, and Chongjie Zhang. Qplex: Duplex dueling multi-agent q-learning. arXiv preprint arXiv:2008.01062, 2020.   \n[8] Mikayel Samvelyan, Tabish Rashid, Christian Schroeder de Witt, Gregory Farquhar, Nantas Nardelli, Tim GJ Rudner, Chia-Man Hung, Philip HS Torr, Jakob Foerster, and Shimon Whiteson. The starcraft multi-agent challenge. In Proceedings of the 18th International Conference on Autonomous Agents and MultiAgent Systems, pages 2186–2188, 2019.   \n[9] Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in neural information processing systems, pages 1471–1479, 2016.   \n[10] Georg Ostrovski, Marc G Bellemare, Aäron Oord, and Rémi Munos. Count-based exploration with neural density models. In International Conference on Machine Learning, pages 2721– 2730, 2017.   \n[11] Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In International Conference on Machine Learning, 2017.   \n[12] Yuri Burda, Harrison Edwards, Amos Storkey, and Oleg Klimov. Exploration by random network distillation. arXiv preprint arXiv:1810.12894, 2018.   \n[13] Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. Vime: Variational information maximizing exploration. In Advances in Neural Information Processing Systems, pages 1109–1117, 2016.   \n[14] Tonghan Wang, Jianhao Wang, Yi Wu, and Chongjie Zhang. Influence-based multi-agent exploration. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            217,
+            828,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[15] Anuj Mahajan, Tabish Rashid, Mikayel Samvelyan, and Shimon Whiteson. Maven: Multiagent variational exploration. In Advances in Neural Information Processing Systems, pages 7613–7624, 2019. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[16] Hyoungseok Kim, Jaekyeom Kim, Yeonwoo Jeong, Sergey Levine, and Hyun Oh Song. Emi: Exploration with mutual information. arXiv preprint arXiv:1810.01176, 2018. ",
+        "bbox": [
+            169,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[17] Adrià Puigdomènech Badia, Pablo Sprechmann, Alex Vitvitskyi, Daniel Guo, Bilal Piot, Steven Kapturowski, Olivier Tieleman, Martin Arjovsky, Alexander Pritzel, Andrew Bolt, et al. Never give up: Learning directed exploration strategies. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            176,
+            179,
+            820,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[18] Adrià Puigdomènech Badia, Bilal Piot, Steven Kapturowski, Pablo Sprechmann, Alex Vitvitskyi, Zhaohan Daniel Guo, and Charles Blundell. Agent57: Outperforming the atari human benchmark. In International Conference on Machine Learning, pages 507–517. PMLR, 2020. ",
+        "bbox": [
+            171,
+            244,
+            823,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Lihong Li, Thomas J Walsh, and Michael L Littman. Towards a unified theory of state abstraction for mdps. ISAIM, 4:5, 2006. ",
+        "bbox": [
+            173,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Jianhao Wang, Zhizhou Ren, Beining Han, Jianing Ye, and Chongjie Zhang. Towards understanding linear value decomposition in cooperative multi-agent q-learning. arXiv preprint arXiv:2006.00587, 2020. ",
+        "bbox": [
+            173,
+            333,
+            823,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Zichuan Lin, Tianqi Zhao, Guangwen Yang, and Lintao Zhang. Episodic memory deep qnetworks. In IJCAI, 2018. ",
+        "bbox": [
+            174,
+            383,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Guangxiang Zhu, Zichuan Lin, Guangwen Yang, and Chongjie Zhang. Episodic reinforcement learning with associative memory. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            464
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Frans A Oliehoek, Christopher Amato, et al. A concise introduction to decentralized POMDPs, volume 1. Springer, 2016. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Frans A Oliehoek, Matthijs TJ Spaan, and Nikos Vlassis. Optimal and approximate q-value functions for decentralized pomdps. Journal of Artificial Intelligence Research, 32:289–353, 2008. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            553
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Pierre-Yves Oudeyer, Frdric Kaplan, and Verena V Hafner. Intrinsic motivation systems for autonomous mental development. IEEE transactions on evolutionary computation, 11(2):265– 286, 2007. ",
+        "bbox": [
+            173,
+            561,
+            825,
+            604
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Pierre-Yves Oudeyer and Frederic Kaplan. What is intrinsic motivation? a typology of computational approaches. Frontiers in neurorobotics, 1:6, 2009. ",
+        "bbox": [
+            173,
+            612,
+            825,
+            642
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Haoran Tang, Rein Houthooft, Davis Foote, Adam Stooke, OpenAI Xi Chen, Yan Duan, John Schulman, Filip DeTurck, and Pieter Abbeel. # exploration: A study of count-based exploration for deep reinforcement learning. In Advances in neural information processing systems, pages 2753–2762, 2017. ",
+        "bbox": [
+            176,
+            650,
+            823,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Bradly C Stadie, Sergey Levine, and Pieter Abbeel. Incentivizing exploration in reinforcement learning with deep predictive models. arXiv preprint arXiv:1507.00814, 2015. ",
+        "bbox": [
+            171,
+            714,
+            823,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Shakir Mohamed and Danilo J Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In Proceedings of the 28th International Conference on Neural Information Processing Systems-Volume 2, pages 2125–2133, 2015. ",
+        "bbox": [
+            173,
+            752,
+            821,
+            796
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Eugenio Bargiacchi, Timothy Verstraeten, Diederik Roijers, Ann Nowé, and Hado Hasselt. Learning to coordinate with coordination graphs in repeated single-stage multi-agent decision problems. In International conference on machine learning, pages 482–490, 2018. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Natasha Jaques, Angeliki Lazaridou, Edward Hughes, Caglar Gulcehre, Pedro Ortega, DJ Strouse, Joel Z Leibo, and Nando De Freitas. Social influence as intrinsic motivation for multi-agent deep reinforcement learning. In International Conference on Machine Learning, pages 3040–3049. PMLR, 2019. ",
+        "bbox": [
+            174,
+            856,
+            826,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Shariq Iqbal and Fei Sha. Coordinated exploration via intrinsic rewards for multi-agent reinforcement learning. arXiv preprint arXiv:1905.12127, 2019. ",
+        "bbox": [
+            169,
+            90,
+            826,
+            121
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[33] M Lengyel and P Dayan. Hippocampal contributions to control: The third way. In Twenty-First Annual Conference on Neural Information Processing Systems (NIPS 2007), pages 889–896. Curran, 2008. ",
+        "bbox": [
+            174,
+            128,
+            823,
+            171
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[34] Charles Blundell, Benigno Uria, Alexander Pritzel, Yazhe Li, Avraham Ruderman, Joel Z Leibo, Jack Rae, Daan Wierstra, and Demis Hassabis. Model-free episodic control. arXiv preprint arXiv:1606.04460, 2016. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            223
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[35] Alexander Pritzel, Benigno Uria, Sriram Srinivasan, Adria Puigdomenech Badia, Oriol Vinyals, Demis Hassabis, Daan Wierstra, and Charles Blundell. Neural episodic control. In International Conference on Machine Learning, pages 2827–2836. PMLR, 2017. ",
+        "bbox": [
+            173,
+            231,
+            825,
+            275
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[36] Steven S Hansen, Pablo Sprechmann, Alexander Pritzel, André Barreto, and Charles Blundell. Fast deep reinforcement learning using online adjustments from the past. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pages 10590–10600, 2018. ",
+        "bbox": [
+            173,
+            282,
+            826,
+            338
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[37] Samuel J Gershman and Nathaniel D Daw. Reinforcement learning and episodic memory in humans and animals: an integrative framework. Annual review of psychology, 68:101–128, 2017. ",
+        "bbox": [
+            173,
+            347,
+            825,
+            390
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[38] Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            171,
+            398,
+            823,
+            443
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[39] Tabish Rashid, Gregory Farquhar, Bei Peng, and Shimon Whiteson. Weighted QMIX: expanding monotonic value function factorisation for deep multi-agent reinforcement learning. In Proceedings of the Annual Conference on Neural Information Processing Systems 2020 (NeurIPS 2020), 2020. ",
+        "bbox": [
+            173,
+            450,
+            826,
+            507
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[40] Tonghan Wang, Tarun Gupta, Anuj Mahajan, Bei Peng, Shimon Whiteson, and Chongjie Zhang. Rode: Learning roles to decompose multi-agent tasks. arXiv preprint arXiv:2010.01523, 2020. ",
+        "bbox": [
+            169,
+            515,
+            825,
+            545
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[41] Yihan Wang, Beining Han, Tonghan Wang, Heng Dong, and Chongjie Zhang. Dop: Offpolicy multi-agent decomposed policy gradients. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            595
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[42] Yuri Burda, Harri Edwards, Deepak Pathak, Amos Storkey, Trevor Darrell, and Alexei A Efros. Large-scale study of curiosity-driven learning. arXiv preprint arXiv:1808.04355, 2018. ",
+        "bbox": [
+            171,
+            604,
+            825,
+            633
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[43] Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado Van Hasselt, and David Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018. ",
+        "bbox": [
+            171,
+            642,
+            825,
+            685
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015. ",
+        "bbox": [
+            168,
+            693,
+            825,
+            723
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Matteo Hessel, Joseph Modayil, Hado Van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. In Thirty-second AAAI conference on artificial intelligence, 2018. ",
+        "bbox": [
+            174,
+            731,
+            826,
+            787
+        ],
+        "page_idx": 12
+    }
+]