Improving Tree-LSTM with Tree Attention

TL;DR

This paper introduces a generalized attention mechanism for Tree-LSTM models to better capture tree structures in NLP, leading to improved performance on semantic relatedness tasks.

Contribution

It proposes a novel attention framework integrated into Tree-LSTM for dependency and constituency trees, enhancing their ability to model hierarchical language structures.

Findings

Achieved superior results on semantic relatedness compared to non-attention Tree-LSTM models.

Outperformed other neural and non-neural methods without attention.

Performed well against attention-based Tree-LSTM variants.

Abstract

In Natural Language Processing (NLP), we often need to extract information from tree topology. Sentence structure can be represented via a dependency tree or a constituency tree structure. For this reason, a variant of LSTMs, named Tree-LSTM, was proposed to work on tree topology. In this paper, we design a generalized attention framework for both dependency and constituency trees by encoding variants of decomposable attention inside a Tree-LSTM cell. We evaluated our models on a semantic relatedness task and achieved notable results compared to Tree-LSTM based methods with no attention as well as other neural and non-neural methods and good results compared to Tree-LSTM based methods with attention.

Tables

Table 1. TABLE I : Ranges of different hyper-parameters searched during tuning.

Hyper-parameter	Range Selected
Learning rate	0.01 / 0.025 / 0.05
Batch size	10 / 25 / 30
Momentum	0.9
Memory dimension	150
MLP hidden dimension	50
Attention layer dimension	150
Dropout	0.5 / 0.2 / 0.1
Word embedding size	300
Gradient clipping	5 / 20 / 50
Weight decay	${10}^{-5}$
Learning rate decay	0.05

Table 2. TABLE II : Test set results on the SICK dataset. The first group lists previous results, and the remainder are the results of our models. We mark models that we re-implemented with a † † \dagger .

Previous Models	Model		$𝐫$	MSE
	ECNU [28]		0.8414	—
	Combine-skip+COCO [29]		0.8655	0.2561
	ConvNet[19]		0.8686	0.2606
	Seq-GRU [16]		0.8595	0.2689
	Seq-LSTM [16]		0.8528	0.2831
	Dep. Tree-GRU [16]		0.8672	0.2573
	Dep. Tree-GRU + Attn. [16]		0.8701	0.2524
	Const. Tree-LSTM [18]		0.8582	0.2734
			0.8460 $†$	0.2895 $†$
	Dep. Tree-LSTM [18]		0.8676	0.2532
			0.8663 $†$	0.2612 $†$
	Dep. Tree-LSTM + Attn. [16]		0.8730	0.2426
			0.8635 $†$	0.2591 $†$
Child Sum Tree LSTM	Model 1	Self	0.7466	0.4545
		Sentence 1	0.7305	0.4849
		Sentence 2	0.7939	0.3801
		Phrase	0.7889	0.3877
	Model 2	Self	0.8577	0.2695
		Sentence 1	0.8620	0.2634
		Sentence 2	0.8686	0.2518
		Phrase	0.8623	0.2615
Binary Tree LSTM	Model 1	Self	0.8648	0.2567
		Sentence 1	0.8692	0.2486
		Sentence 2	0.8686	0.2507
		Phrase	0.8676	0.2517
	Model 2	Self	0.8698	0.2476
		Sentence 1	0.8698	0.2476
		Sentence 2	0.8720	0.2435
		Phrase	0.8696	0.2479

Equations

$${\tilde{\text{h}}}_j=\sum _{k\in C(j)}{h}_{jk}$$

$${\text{i}}_j=\sigma ({\text{W}}^{(i)}{x}_j+{\text{U}}^{(i)}{\tilde{h}}_j+{\text{b}}^{(i)})$$

$${\text{o}}_j=\sigma ({\text{W}}^{(o)}{x}_j+{\text{U}}^{(o)}{\tilde{h}}_j+{\text{b}}^{(o)})$$

$${\tilde{\text{c}}}_j=\text{tanh}({\text{W}}^{(c)}{x}_j+{\text{U}}^{(c)}{\tilde{h}}_j+{\text{b}}^{(c)})$$

$${\text{f}}_{jk}=\sigma ({\text{W}}^{(f)}{x}_j+{\text{U}}^{(f)}{h}_{jk}+{\text{b}}^{(f)})$$

$${\tilde{\text{f}}}_j=\sum _{k\in C(j)}{f}_{jk}\cdot c_k$$

$${\text{c}}_j=i_j\cdot {\tilde{c}}_j+{\tilde{f}}_j$$

$${\text{h}}_j=o_j\cdot \text{tanh}(c_j)$$

$${\text{i}}_j=\sigma ({\text{W}}^{(i)}{x}_j+\sum _{l=1}^N{\text{U}}_l^{(i)}{\tilde{h}}_{jl}+{\text{b}}^{(i)})$$

$${\text{o}}_j=\sigma ({\text{W}}^{(o)}{x}_j+\sum _{l=1}^N{\text{U}}_l^{(o)}{\tilde{h}}_{jl}+{\text{b}}^{(o)})$$

$${\tilde{\text{c}}}_j=\text{tanh}({\text{W}}^{(c)}{x}_j+\sum _{l=1}^N{\text{U}}_l^{(c)}{\tilde{h}}_{jl}+{\text{b}}^{(c)})$$

$${\text{f}}_{jk}=\sigma ({\text{W}}^{(f)}{x}_j+\sum _{l=1}^N{\text{U}}_{kl}^{(f)}{h}_{jl}+{\text{b}}^{(f)})$$

$${\tilde{\text{f}}}_j=\sum _{l=1}^N{f}_{jl}\cdot c_{jl}$$

$$m_k=\text{tanh}({\text{W}}^{(m)}{h}_k+{\text{U}}^{(m)}s),$$

$${\alpha }_k=\frac{{\text{w}}^T{m}_k}{{\sum }_{j=1}^n{\text{w}}^T{m}_j}$$

$$g=\sum _{1\le k\le n}{\alpha }_k{h}_k$$

$$\tilde{h}=\text{tanh}({\text{W}}^{(a)}g+{\text{b}}^{(a)})$$

$$\text{key}={\text{W}}^{(k)}{M}^{(k)}$$

$$\text{query}={\text{W}}^{(q)}{M}^{(q)}$$

$$\text{value}={\text{W}}^{(v)}{M}^{(v)}$$

$$\text{align}=(\text{query}{)}^T\text{key}\cdot \frac{1}{\sqrt{d}}$$

$$\alpha =\text{softmax}(\text{align})$$

$$\tilde{h}=\text{bmm}(\alpha ,\text{value})$$

$$\tilde{h}=\{\begin{array}{ll}\text{bmm}(\alpha ,{\text{M}}^{(k)}),& \text{if}\alpha isamatrix\\ \alpha \ast {\text{M}}^{(k)},& \text{if}\alpha isavector\end{array}$$

$$\hat{h}=\text{tanh}(\text{W}\tilde{h}+\text{b})$$

Full text

I Introduction

Long Short Term Memory (LSTM) units are very effective when working on sequential data [1, 2]. For some Natural Language Processing (NLP) tasks, we often need to find a distributed representation of phrases and sentences [3, 4, 5]. One obvious way of doing this is to use a sequential LSTM which captures word order in a sentence [6, 7]. But we can also have information about sentence structure from a dependency parse tree or about phrase structure from a constituency tree [8]. Despite the fact that RNN based models work well with sequence information, they frequently neglect to catch any sort of semantic compositionality if the information is structured rather than in the sequential frame [9]. For example, the syntactic principles of natural language are known to be recursive, with noun phrases containing relative clauses that themselves contain noun phrases, e.g., “I went to the church which has nice windows”[10]. The term compositionality can also be explained in terms of a car. A car can be recursively decomposed into smaller car parts, for example, tires and windows and these parts can occur in different contexts, like tires on airplanes or windows in houses.

Attention [11, 12, 13] was first introduced for doing machine translation where the target word generated by the decoder at each time step is aligned with all the words in the source sentence. In its general form, attention allows a model to put importance on certain parts of the sentence for doing any specific downstream task [14, 15]. In a dependency tree, the relationship between the entities (head and dependent) are organized as a structure where a head word can have multiple dependents under it. In the case of a constituency tree, a phrase is represented by one of the subtrees with the root being the phrase type and words or subtrees being the children. In both tree structured LSTMs, the derivation of the vector representation of the entire tree does not depend on all of the subtree components uniformly. Some parts of the tree have a larger influence on the root vector and some parts may have less. This contribution from subtrees for the building of the whole tree depends on the underlying task that the model is performing. For example, in a sentiment analysis task the sentiment of a tree depends on the sentiment of all of its children and how this information propagates. There may be scenarios where a single word (such as “not”) flips the sentiment of the whole subphrase. These words should get more attention when deciding the sentiment of a subphrase containing them. On the other hand, when the problem is a regression problem with the task of assigning a score based on the semantic similarity of two sentences, this attention can be calculated as a cross sentence attention. In this case the representation of one sentence can guide the structural encoding of the other sentence on the dependency as well as constituency parse tree [16].

Capturing semantic relatedness means recognizing the textual entailment between the hypothesis and the premise [17]. The general approach of modeling sentence pairs (i.e., measuring the relatedness between sentences) using neural networks includes two steps: represent both of the sentences as vectors via a sentence encoder and then initializing a classifier with these vectors to do the classification. The sentence encoder can be viewed as a compositional function which maps a sequence of words in a sentence to a vector. Some of the common compositional functions are sequential LSTM [16], Tree-LSTM [18, 16] and CNN [19].

In this paper, we propose two models to encode attention inside tree structured LSTM cells and verify their effectiveness by evaluating them on the semantic relatedness task where the model needs to give a score depending on how similar two sentences are. The tree data structure allows a set of dependents in the dependency tree or constituents in the constituency tree to be children of an immediately higher level (parent) tree node. Our tree attention model applies attention over the set of children in a subtree and decides which of them are important to reconstruct their parent node vector. We apply this attention with respect to four pieces of information: the vector representation of the sentence currently being represented as a tree, the vector representation of the sentence being compared with, dependent vectors (dependency tree) or phrase vector (binary constituency tree), and concatenated vectors of the dependents or the constituents. Our extensive evaluation proves the effectiveness of our attentive Tree-LSTM with respect to the plain Tree-LSTM models as well as some top performing models on the benchmark dataset.

II Related work

Socher et al. [9] propose a number of recursive neural network (rNN) based models which take phrases as input rather than entire sentences. Phrases are represented as a vector as well as a parse tree. Vectors for higher level nodes in the tree are computed using a tensor-based composition function. Their best model was Matrix Vector rNN (MVrNN) where each word is represented as a vector as well as a matrix. In this model the children in a subtree interact more through their vectors rather than being influenced by some weights during the calculation of the parent’s vector and matrix representation.

Tai et al. [18] developed two different variants of standard linear chain LSTMs: child sum Tree-LSTM and N-ary Tree-LSTM. The underlying concept of using input, output, update and forget gates in these variants is quite similar to how these gates are used in standard LSTMs, however there are few important changes. The standard LSTM works over the sequence data whereas these variants are compatible with tree structured data (constituency tree or dependency tree). Also, unlike standard LSTMs, the hidden and cell states of a word at the current time step does not depend on the entire sequence seen before. Instead, the hidden and cell state of a parent node depends only on its children hidden and cell states. Recently, Chen et al.  [20] combined LSTM with Tree LSTM for natural language inference task and empirically proved that these two models complement each other very well.

Zhou et al. [16] extend the concept of standard Tree-RNNs and propose a number of attention based Tree-RNN models to perform the semantic relatedness task. Their insight was quite novel: in order to compute the semantic similarity of two sentences, one can encode attention in the tree structure of one sentence with respect to the vector representation of the other sentence. However, their proposed attention model only works with child sum Tree-LSTMs and GRUs. Attention with Tree LSTM has also been studied by Liu et al. [21] for text summarization task where they use two different kinds of alignment : block alignment for aligning phrases and word alignment for aligning inter-words within phrases.

Turning to machine translation, the attention mechanism is used to align the source and target sentences in the decoding phase. More formally, the attention mechanism allows the model to attend to some elements with the intention of emphasizing different elements. The well-known attention models from [11] and [12] use recurrent models to attend over a set of source words during the generation of each target word. Using recurrent models to generate an attention score incorporates a memory mechanism inside the network which helps the model at run time to traverse and decide what to attend over. Also, this recurrency allows some positional information in the sequence to help ordering the generated words.

Parikh et al. [22] propose a decomposable attention model for natural language inference tasks by removing the modules with recurrent behavior during the calculation of attention. First, they pick a single vector from a set of vectors representing the source sentence and then compare its point-wise similarity with every element of each word vector from the target sentence. Following this, they compare these alignments using a function which is a feed forward neural network and finally perform an aggregation through summation before doing the final classification. Gehring et al. [23] propose a sequence to sequence learning framework utilizing a convolutional neural network which completely avoids recurrent models allowing their architecture to be parallelizable. In order to capture the positional information, they include a positional embedding layer which gives their model a sense of the portion of the sequence in the input or output it is currently dealing with. They encode sine and cosine frequencies for each dimension of every position in the sentence to create the positional embeddings and finally combine them with word embeddings. Vaswani et al. [13] combine the previous two works and propose a powerful machine translation framework utilizing attention without recurrence and positional embeddings. They also extend the decomposable attention mechanism by attending over the input sequence multiple times stating it as a multi-head attention where the target is to extract different features by different attentional heads.

III The Model

In this section, we describe our work in detail. We first explain how the two variants of Tree-LSTM work. Following this, we describe our universal attention mechanism that is applicable for these two Tree-LSTM variants. Additionally, we give an in-depth analysis of adding this attention with respect to various information as discussed in Section II.

III-A Incompatibility of standard LSTM and Tree structured data

Recurrent neural networks (RNNs) are the best known and most widely used neural network (NN) model for sequence data as they sequentially scan the entire sequence and generate a compressed form of it. Although in theory RNNs are capable of remembering long distance dependencies, practically, as the sequence becomes longer, RNNs suffer from the vanishing gradient problem [24, 25]. To overcome this drawback some RNN variants have been introduced such as Long Short Term Memory (LSTM) [1] and Gated Recurrent Unit (GRU) [26]. These variants use a gating mechanism to propagate new information further and at the same time to forget some previous information allowing the gradients to propagate further. Performance-wise, LSTMs are superior to GRUs because they have more parameters but in terms of computational complexity GRUs often surpass LSTMs.

Even though these gating variants effectively solve the RNN vanishing gradient problem, they are limited to linear data; however, a natural language sentence encodes more than a sequence of words. This extra information is usually represented in a tree structure. The tree structure shows how the words combine through different sub-phrases to reflect the overall meaning. If a sentence gets traversed by a standard LSTM, the latter part of the sentence gets more importance comparatively as the traversal moves left to right. But if the tree structure of the sentence gets traversed from bottom to top then the information from different constituent or dependents first gets combined to represent the root at the upper level and then this roots gradually gets traversed as children and combined to represent the root at next level and so on. So in both cases an LSTM cell will forget previous information which for plain LSTM, is related to the length of the sentence and for Tree-LSTM, is related to the depth of the tree. Also in plain LSTM, the hidden and cell state of a word at time step $t$ depends on hidden and cell state of all the words from time step $1\ldots t-1$. But in Tree-LSTM, the hidden and cell state of a root word depends only on the hidden and cell state of all of its children rather than all the words before it.

III-B Tree-LSTM

There are two possible tree representations of a sentence: Dependency tree and Constituency tree [27]. As previously presented, the standard linear chain LSTM and BLSTM cannot correctly analyze this structured information. To properly deal with this structured data, Tai et al. [18] proposed two LSTM models which can analyze a tree structure preserving every property of the standard LSTM gating mechanisms. They called the first one child sum Tree-LSTM and the second one N-ary Tree-LSTM. Child sum Tree-LSTM fits well with dependency trees as it is well suited for high branching child-unordered trees. On the other hand N-ary Tree-LSTM (with $n=2$) works better with the binarized (Chomsky Normal Form) constituency trees.

Traditional LSTM generates a new hidden and cell state from the previous hidden state $h_{t-1}$, previous cell state $c_{t-1}$ and current sequential input $x_{t}$. In the child sum Tree-LSTM, a component node state is generated based on the states of its children in the tree as shown in Fig. LABEL:lstm(a). To do this, the internal gates (i.e., the input, output and intermediate cell states) are updated using the sum of the hidden states of the children of the component node as follows:

[TABLE]

where $C(j)$ denotes the children of node $j$. Next, using this modified hidden state, $\tilde{h}$, the input, output and intermediate cell states are calculated as follows:

[TABLE]

[TABLE]

[TABLE]

where $W^{(i)}$, $W^{(o)}$, $W^{(c)}$, $U^{(i)}$, $U^{(o)}$, $U^{(c)}$, $b^{(i)}$, $b^{(o)}$, and $b^{(c)}$ are the parameters to be learned. Instead of having just a single forget gate, child sum Tree-LSTMs have $k$ forget gates where $k$ is the number of children of the target node. This multiple forget gate allows child sum Tree-LSTM to incorporate individual information from each of the children in a selective manner. Each forget gate is calculated as follows:

[TABLE]

Next, the individual forget gate outputs are multiplied with corresponding cell state values and then combined to get a single forget vector which is used to get the final cell state of the model as follows:

[TABLE]

[TABLE]

Finally, the update equation for the hidden state of a child sum Tree-LSTM cell is similar to the traditional LSTM:

[TABLE]

Each of the parameter matrices represents a correlation among the component vector, input $x_{j}$ and the hidden state $h_{k}$ of the $k^{th}$ child of the component unit. For example, the sigmoid function at the input gate represents semantically important words at input by giving values close to 1 (e.g., a verb) and relatively unimportant words by giving values close to 0 (e.g., a determiner). Since the hidden state and cell state values of the parent node are generated based on the hidden state and the cell state of its children, child sum Tree-LSTM is well suited for dependency trees.

The N-ary Tree-LSTM is used where there are at most $N$ ordered children. Unlike the child sum Tree-LSTM, it has a different set of parameters for each child having its own cell and hidden state, shown in Fig. LABEL:lstm(b). The update equations for deriving input, output and update gate values are as follows:

[TABLE]

[TABLE]

[TABLE]

where $W^{(i)}$, $W^{(o)}$, $W^{(c)}$, $U^{(i)}_{l}$, $U^{(o)}_{l}$, $U^{(c)}_{l}$, $b^{(i)}$, $b^{(o)}$, and $b^{(c)}$ are the parameters to be learned. As can be seen, for each gate, the N-ary Tree-LSTM has a set of $N$ parameter matrices associated with the $N$ hidden states whereas the child sum Tree-LSTM has just one. Next, for each of the children, forget gate values are calculated separately, as done in the child sum Tree-LSTM as follows:

[TABLE]

Similar to the child sum Tree-LSTM, these new forget gate values are multiplied with corresponding cell state values and then summed to get the final values for the forget gate:

[TABLE]

Finally, the cell state and new hidden state values are updated using Equations 7 and 8.

III-C Attention

The two tree structured LSTM models described in Section III-B treat every word within a sub-tree with equal probability. More specifically, in an N-ary Tree-LSTM, every word contributes uniformly to the building of the higher-level constituent. Likewise, the child sum Tree-LSTM architecture suggests that, within a dependency tree branch, a head word influences all of its dependent words in a similar way. When viewing the tree as a semantic representation of a sentence, this may not be the case in many scenarios. For a constituency tree, if a sub-tree contains some negative sentiment words, then it is not always the case that the sentiment of that particular constituent is negative. If the negative sentiment word is preceded by a negation, then the higher-level constituent becomes semantically positive because of the location of the negation word. To capture this type of information, attention is applied over the sub-tree components to apportion the importance of each sub-tree component when building the entire tree either semantically or syntactically. In this study, we are interested in applying semantic attention over the sub-tree components to see how they contribute to building a sub-tree.

Attentive Tree-LSTM was proposed by [16] for doing the semantic relatedness task. They state that the effect of semantic relevance could be implemented as part of the sentence representation construction process using a Tree-LSTM where each child should be assigned a different weight. In their proposed model, a soft attention mechanism assigns an attention weight on each child in a subtree. Given a collection of hidden state $h_{1},h_{2},\cdots,h_{n}$ and an external vector $s$, their proposed attention mechanism assigns a weight $\alpha_{k}$ on each of these hidden states and produces a weighted vector $g$. To achieve this, first they perform an affine transformation on each of the child hidden states and calculate a vector $m_{k}$ as follows:

[TABLE]

where $W^{(m)}$ and $U^{(m)}$ are the parameter matrices of size $d\times d$ and $s$ is the vector representation of the sentence learned by a sequential LSTM. Next, using this transformed hidden states $m_{k}$, the attention probabilities $\alpha_{k}$ are calculated as follows

[TABLE]

where $w$ is a parameter vector of size $1\times d$. Following this, a weighted combination of the hidden states is calculated using,

[TABLE]

This $g$ is of size $1\times d$. Finally, an affine transformation is applied on this $g$ to get the new hidden state $\tilde{h}$ as follows:

[TABLE]

This soft attention mechanism from [16] introduces four new parameters to derive the final attentive hidden state; two matrices in Eqn. 14, one vector in Eqn. 15 and one matrix in Eqn. 17. This attention mechanism is only applicable to the child sum Tree-LSTM. It is not possible to apply this attention on N-ary Tree-LSTMs since the structure of the N-ary Tree-LSTM is such that it needs $N$ separate hidden states to work with whereas a child sum Tree-LSTM collapses all the hidden states to a single vector through summation. In this study, we develop two generalized attention models by adopting the decomposable attention framework proposed by [22] and the soft attention mechanism proposed by [16].

Model 1: Our first model is based on the self attention mechanism where we make some subtle changes to calculate the attention probability with respect to different segments of the sentence. Calculating attention in this way involves three matrices key, query, and value. The key matrix represents on which child to attend over, the query matrix represents “with respect to what” is attention to be applied and the value matrix extracts the final attention-able vector using attention probability. The key matrix is calculated as follows:

[TABLE]

where, $W^{(k)}$ is a parameter matrix of size $d\times d$ and $M^{(k)}$ is the matrix on which to attend over. For child sum Tree-LSTMs, this matrix is the concatenation of the vectors of all the words under a particular head word. For N-ary Tree-LSTMs, it is the concatenation of all the word vectors in a constituent. So in both cases the formal representation is $M^{(k)}=[h_{1};h_{2};\dots;h_{n}]$. In order to encode self attention in the sub-tree, the query and value matrices also get calculated with respect to $M^{(k)}$ ($M^{(k)}=M^{(q)}=M^{(v)}$) but with a different set of parameter matrices $W^{(q)}$ and $W^{(v)}$ as follows:

[TABLE]

[TABLE]

Once the key and query get calculated, the next step is to align each of them by looking at the similarity at each dimension of their representation. This is done using:

[TABLE]

where the align matrix is of size $n\times n$ with $n$ representing the number of children within this sub-tree. The $d$ is being used here as a normalizing factor. Finally, the attention probability is calculated by applying softmax over it as follows:

[TABLE]

Here $\alpha$ is the matrix of attention probabilities where each row represents how much attention needs to be given on each of the children within that sub-tree according to the word at that row. As there are $n$ children within a sub-tree, the size of this matrix is $n\times n$. Finally, we calculate a new attention encoded hidden state $\tilde{h}$ through a batch-wise matrix multiplication between the $\alpha$ and value matrices as follows:

[TABLE]

The shape of this new $\tilde{h}$ is $n\times d$. It contains attention encoded hidden state values of all the children sequentially one on top of another. So in order to locate a specific hidden state value, the row number corresponding to the position of that child in the sub-tree is used. For child sum Tree-LSTMs, all of the hidden state vectors are summed to get a single vector and for N-ary Tree-LSTMs, one row of $\tilde{h}$ is selected as the hidden state of a child.

For the semantic relatedness task, where the objective is to assign a score based on the similarity between two sentences, it is better to calculate the query matrix with respect to the vector representation of the second sentence. Specially, given a pair of sentences, our generalized attentive encoder uses the representation of one sentence generated via a sequential LSTM to guide the structural encoding of the other sentence on both the dependency as well as the constituency tree. In that case, $M^{(q)}$ is a vector rather than a matrix thus changing the shape of query from Eqn. 19 into $1\times d$. This results in an alignment vector from Eqn. 21 of size $1\times n$. When softmax is applied over this vector, a vector of probabilities, $\alpha$, is produced. Finally, instead of doing a matrix multiplication as in Eqn. 23, a point-wise multiplication $\tilde{h}=\alpha*\texttt{value}$ is performed resulting in a new hidden state vector. For child sum Tree-LSTMs, we use this new hidden state vector in place of the one generated in Eqn. 1 and for N-ary Tree-LSTMs, we use this hidden state vector as the hidden state of both the left and right children. This way of calculating self attention requires three additional matrices as parameters from Eqn. 18, 19 and 20, a smaller number of parameters than found in [16]. We further continue our experiments by calculating a phrase vector representation using an additional LSTM cell and use it as the query vector. Then, we adopt the same procedure as above to calculate the attention probability $\alpha$ and the final hidden state vector $\tilde{h}$. However, this requires more parameters than what is required in [16].

Model 2: In our second model, we combine the concepts of decomposable attention mechanism with a soft attention layer. Here, we have two matrices key and query and their derivation are the same as Eqns. 18 and 19. We further align and transform these matrices into probabilities using the same set of equations, Equations 21 and 22. We again make some subtle changes which result in four different versions of this model. In Eqn. 19, when $M^{(q)}=M^{(k)}$, the dimension of the attention probability becomes $n\times n$ and when $M^{(q)}$ is either a sentence vector $M^{(q)}=\texttt{LSTM}(\textit{sentence}_{2})$ or phrase vector $M^{(q)}=\texttt{LSTM}(M^{(k)})$, the dimension of this attention probability changes to $1\times n$. Then, $\tilde{h}$ is calculated as follows,

[TABLE]

Next we perform an affine transformation of this $\tilde{h}$ by multiplying it with a parameter matrix $W$ and passing it through a tanh layer as follows:

[TABLE]

In the case of child sum Tree-LSTMs, if $\hat{h}$ is a matrix, we do a summation of all the rows and use that as the final vector and if $\hat{h}$ is a vector. we use that as it is. In the case of N-ary Tree-LSTMs, if $\hat{h}$ is a matrix, then each row corresponds to the hidden state of a child and if $\hat{h}$ is a vector, then we just copy this vector as the hidden states of the children.

IV Experimental Setup and Analysis

In this section, we describe the detailed experimental setup for the evaluation of our study. We first explain the dataset statistics for evaluating our generalized attention frameworks. Following this, we explain the working environment details along with the hyper-parameter settings of our architecture.

We evaluated our model for the semantic similarity task on the Sentences Involving Compositional Knowledge (SICK) dataset [17]. The task is to give a likeness score for a pair of sentences and then compare it to a human produced score. The SICK dataset contains 9927 sentence pairs configured as: 4500 training pairs, 500 development pairs and 4927 test pairs. Each sentence pair is annotated with a similarity score ranging from 1 to 5. A high score shows that the sentence pair is strongly related. All sentences are derived from existing image and video comment datasets. The assessment measures are Pearson’s $\rho$ and mean squared error (MSE).

Table I shows the detailed hyper-parameter settings of our model. We trained our model on an Nvidia GeForce GTX 1080 GPU with ‘Adam’, ‘SGD’ and ‘Adagrad’ optimizers. All of the results in the next section are reported using ‘Adagrad’ as it was giving the best results. The ‘Learning rate decay’ parameter was only used with the ‘SGD’ optimizer. We used PyTorch 0.4 to implement our model under the Linux environment.

Table II shows the overall evaluation of our model in terms of Pearson’s $\rho$ and Mean Squared Error (MSE). This table also contains the results of some top performing models on the SICK dataset. Among these models, [18] and [16] did their evaluation with plain Tree-LSTMs, whereas the rest of the models use some different composition functions such as CNN [29], ECNU [28] and Combine-skip + COCO [19]. However [16] also experimented with attentive Tree-LSTMs and GRUs, but they have only been able to design models compatible with the child sum variant. On the other hand, among our two proposed models, Model 2 performs very well on both Tree-LSTM variants showing significant improvements with every configuration. For both child sum as well as binary Tree-LSTMs, our second model with cross sentence attention has superior performance compared to the plain Tree-LSTM variants getting MSE of $0.2518$ and $0.2435$ respectively. For the child sum Tree-LSTM, Model 1 performs poorly compared to all the other models. This poor performance is due to the hard attention that it applies. If a subtree has $n$ children, this hard attention forces $n-1$ children to have probability close to [math] which causes the domination of just one child hidden state in the summation. The rest will not contribute at all. On the other hand, the reason behind Model 2 performing better in every configuration with both variants is that even though a hard attention causes one of the children to get close to [math], the normalization of N-ary tree into binary tree causes much more flexibility for the information to flow from bottom to top. During normalization, a branch with $n$ children gets split up to $n-1$ full binary trees resulting in $(n-1)/2$ nodes that are always chosen. Our best performing attentive child sum Tree-LSTM model with cross sentence attention achieves a better result ($0.2518$ MSE) than the plain child sum tree variant from [18] ($0.2532$ MSE). Our score did not surpass the reported result ($0.2426$ MSE) of the attentive child sum variant from [16]. However, our implementation of their model with their reported hyper-parameters gave a $0.2591$ MSE which is significantly worse than their claimed MSE. This suggests to us that the implementation environment has a strong impact on model performance. Our child sum Tree-LSTM Model 2 with cross sentence attention achieves better performance than our implementation of [16] using their hyper-parameter settings. To the best of our knowledge, our work is the first to encode attention inside a binary Tree-LSTM cell. In terms of binary tree LSTM, our best performing model with cross sentence attention achieves $0.2435$ MSE which is significantly better than the one reported in [18] ($0.2734$ MSE) for the non-attentive version. In our implementation of plain binary Tree-LSTM without attention from [18] we were not able to reproduce their reported result and ended up with $0.2895$ MSE which is much worse than the one we got with every configuration of our Model 1 and Model 2. This performance analysis does show the effectiveness of our generalized attention model.

Figure 2 depicts the probability assigned to each node in the dependency tree by our Model 2 with cross sentence attention. Unlike standard child sum Tree-LSTM, where the hidden states of all the children nodes are combined with a plain summation, our attentive child sum Tree-LSTM assigns a weight to each node and then does a weighted summation. The example used in this figure has “A man is exercising” as the left sentence, “A man is doing physical activity” as the right sentence and “Entailment” as their relationship. As usual, the main verb from both of the sentences is selected as the root node. The auxiliary verb (is) gets high attention in both the left and right trees because of the word similarity. However, their absolute influence varies because of the presence of semantically related words in other branches as discussed above. Both of these trees share the same nominal subject (nsubj) however with different probabilities (in the left tree its probability is significantly lower). The reason behind this is the cross sentence attention allows the word man from the left sentence to align with two words man and physical from the right sentence. As they share a similar semantic meaning in the vector space, the branch in the left sentence that contains man is diminished because the right sentence divides the attention between two branches (left sentence: exercising $\xrightarrow[]{\textit{nsubj}}$ man; right sentence: doing $\xrightarrow[]{\textit{nsubj}}$ man and doing $\xrightarrow[]{\textit{dobj}}$ activity).

Figure 3 depicts the probability assigned to each node in a binary (Chomsky Normal Form) constituency tree using an attentive binary Tree-LSTM with cross sentence attention. In this setting, the attention on the structure of the left sentence is computed with respect to the vector representation of the right sentence and vice versa. As a result, the words in a specific phrase from the left sentence are aligned with very high attention probability if the same words appear anywhere in the right sentence. However, as softmax was operating with small values from Eqn. 21, it forced both children to have the same probabilities ($0.5$). In order to verify whether this probability has any effect or not, we have confirmed that replacing $\alpha$ in Eqn. 23 with pairs of the same value other than $(0.5$) results in the model giving comparatively poor performance. Finally, for the inference of attention probabilities, we replaced softmax from Eqn. 22 with plain normalization. For the example in Fig. 3, we have “A man is playing a violin” as the left sentence, “A man is harping on about a play” as the right sentence and “Neutral” as their relationship. The phrase NP gets almost the same probabilities in both the left ($0.49$) and right ($0.55$) trees because of having the same set of words: “A man”. The sub-phrase VBZ under VP in both trees gets very high attention due to having the same word “is” at exactly the same position. Due to the Chomsky normalization, the tree on the right side gets an extra dummy node X which contains VBG and RP as the child nodes. In the vector space, the words “playing” and “harping” are semantically connected which allows both of the models to align them with moderately high as well as equal probabilities. The left tree does not have any particle (“RP”) words which causes the model to put low attention probability when it appears on the right tree. The left tree has NP as the right child of VP at level 3 with probability $0.55$ which is quite close to the amount of attention PP gets ($0.63$) as the right child of VP at the same level in the right tree. Again in both of these trees, at the right most branch, the words “play” and “violin” share the same semantic space which causes them to get aligned with almost the same probabilities. The DT in this branch gets the same high probability because of appearing in both sentences at relatively similar positions.

V Conclusion

Previous attempts to encode the attention mechanism in Tree-LSTMs were only successful for the child-sum tree variant as the techniques used are not easily adaptable to binary trees like the Chomsky Normal Form constituency tree. In this paper, we have introduced two different ways of applying attention on tree structures. The second of these two methods gives superior performance for both tree variants. The proposed techniques can be used on both dependency as well as constituent tree structure. Our experimental results verify the superiority of the attentive variant of Tree-LSTMs over traditional Tree-LSTMs and linear chain LSTMs on the semantic relatedness task. With our extensive in depth analysis, we showed that our proposed attention models provide a good representation of how a sentence builds semantically from the words. Our generalized attention framework is adaptable to any tree like structures.