The recursive neural network (RNN) model became popular since the work of socher_learning_2010. It has been employed to tackle several NLP tasks, such as syntactic parsing [Socher et al.2013a], machine translation [Liu et al.2014], and word embedding learning [Luong et al.2013]. However, like traditional recurrent
neural networks, the RNN seems to suffer from the vanishing gradient problem, in which error signals propagating from the root in a parse tree to the child nodes shrink very quickly. Moreover, it encounters difficulties in capturing long range dependencies: information propagating from child nodes deep in a parse tree can be obscured before reaching the root node.
In the recurrent neural network world, the long short term memory (LSTM) architecture[Hochreiter and Schmidhuber1997] is often used as a solution to these two problems. A natural extension of the LSTM can be defined for tree structures, which we call Recursive LSTM (RLSTM), as proposed independently by tai2015improved, zhu2015long, and le2015composition. However, while there is intensive research showing how the LSTM architecture can overcome those two problems compared to traditional recurrent models (e.g., gers2001lstm), such research is, to our knowledge, still absent for the comparison between RNNs and RLSTMs. Therefore, in the current paper we investigate the following two questions:
Is the RLSTM more capable of capturing long range dependencies than the RNN?
Does the RLSTM overcome the vanishing gradient problem more effectively than the RNN?
Supervised learning requires annotated data, which is often expensive to collect. As a result, examining a model on natural data on many different aspects can be difficult because the portion of data that fits a specific aspect could not be sufficient. Moreover, studying individual aspects separately is hard since many aspects are often correlated with each other. This, unfortunately, is true in our case: answering those two questions requires us to evaluate the examined models on datasets of different tree depths, in which the key nodes which contain decisive information in a parse tree must be identified. Using available annotated corpora such as the Stanford Sentiment Treebank [Socher et al.2013b] and the Penn Treebank is thus inappropriate, as they are too small for this purpose (10k, 40k trees, respectively, compared to 240k trees in our experiments), and key nodes are not marked. Our solution is an artificial task where sentences and parse trees can be randomly generated under any arbitrary constraints on tree depth and key node’s position.
Both the RNN and the RLSTM model are instances of a general framework which takes a sentence, syntactic tree, and vector representations for the words in the sentence as input, and applies a composition function to recursively compute vector representations for all the phrases in the tree and the complete sentence. Technically speaking, given a production, and representing , we compute for by , where is a composition function.
In the RNN,
is a one-layer feed-forward neural network. In the RLSTM, a nodeis represented by the vector resulting from concatenating a vector representing the phrase that the node covers and a memory vector. could be any LSTM that can combine two such concatenation vectors, such as Structure-LSTM [Zhu et al.2015], Tree-LSTM [Tai et al.2015], and LSTM-RNN [Le and Zuidema2015]. In the current paper, we use the implementation111https://github.com/lephong/lstm-rnn of le2015composition.
We now examine how the two problems, the vanishing gradient problem and the problem of how to capture long range dependencies, affect the RLSTM model and the RNN model. To do so, we propose the following artificial task, which requires a model to distinguish useful signals from noise. We define:
a sentence is a sequence of tokens which are integer numbers in the range ;
a sentence contains one and only one keyword token which is an integer number smaller than 1000;
a sentence is labeled with the integer resulting from dividing the keyword by 100. For instance, if the keyword is 607, the label is 6. In this way, there are 10 classes, ranging from 0 to 9.
The task is to predict the class of a sentence, given its binary parse tree (Figure 1). Because the label of a sentence is determined solely by the keyword, the two models need to identify the keyword in the parse tree and allow only the information from the leaf node of the keyword to affect the root node. It is worth noting that this task resembles sentiment analysis with simple cases in which the sentiment of a whole sentence is determined by one keyword (e.g. “I like the movie”). Simulating complex cases involving negation, composition, etc. is straightforward and for future work. But here we believe that the current task is adequate to answer our two questions raised in Section 1.
The two models, RLSTM and RNN, were implemented with the dimension of vector representations and vector memories 50. Following socher2013recursive, we used. We trained the two models using the AdaGrad method [Duchi et al.2011]
with a learning rate of 0.05 and a mini-batch size of 20 for the RNN and of 5 for the RLSTM. Development sets were employed for early stopping (training is halted when the accuracy on the development set is not improved after 5 consecutive epochs).
3.1 Experiment 1
We randomly generated 10 datasets. To generate a sentence of length , we shuffle a list of randomly chosen non-keywords and one keyword. The -th dataset contains 12k sentences of lengths from tokens to tokens, and is split into train, dev, test sets with sizes of 10k, 1k, 1k sentences. We parsed each sentence by randomly generating a binary tree whose number of leaf nodes equals to the sentence length.
The test accuracies of the two models on the 10 datasets are shown in Figure 2; For each dataset we run each model 5 times and reported the highest accuracy for the RNN model, and the distribution of accuracies (via boxplot) for the RLSTM model. We can see that the RNN model performs reasonably well on very short sentences (less than 11 tokens). However, when the sentence length exceeds 10, the RNN’s performance drops so quickly that the difference between it and the random guess’ performance (10%) is negligible. Trying different learning rates, mini-batch sizes, and values for (the dimension of vectors) did not give significant differences. On the other hand, the RLSTM model achieves more than 90% accuracy on sentences shorter than 31 tokens. Its performance drops when the sentence length increases, but is still substantially better than the random guess when the sentence length does not exceed 70. When the sentence length exceeds 70, both the RLSTM and RNN perform similarly.
3.2 Experiment 2
In Experiment 1, it is not clear whether the tree size or the keyword depth is the main factor of the rapid drop of the RNN’s performance. In this experiment, we kept the tree size fixed and vary the keyword depth. We generated a pool of sentences of lengths from 21 to 30 tokens and parsed them by randomly generating binary trees. We then created 10 datasets each of which has 12k trees (10k for training, 1k for development, and 1k for testing). The -th dataset consists of only trees in which distances from keywords to roots are or (to stop the networks from exploiting keyword depths directly).
Figure 3 shows test accuracies of the two models on those 10 datasets. Similarly in Experiment 1, for each dataset we run each model 5 times and reported the highest accuracy for the RNN model, and the distribution of accuracies for the RLSTM model. As we can see, the RNN model achieves very high accuracies when the keyword depth does not exceed 3. Its performance then drops rapidly and gets close to the performance of the random guess. This is evidence that the RNN model has difficulty capturing long range dependencies. By contrast, the RLSTM model performs at above 90% accuracy until the depth of the keyword reaches 8. It has difficulty dealing with larger depths, but the performance is always better than the random guess.
3.3 Experiment 3
We now examine whether the two models can encounter the vanishing gradient problem. To do so, we looked at the the back-propagation phase of each model in Experiment 1 on the third dataset (the one containing sentences of lengths from 21 to 30 tokens). For each tree, we calculated the ratio
where the numerator is the norm of the error vector at the keyword node and the denominator is the norm of the error vector at the root node. This ratio gives us an intuition how the error signals develop when propagating backward to leaf nodes: if the ratio , the vanishing gradient problem occurs; else if the ratio
, we observe the exploding gradient problem.
Figure 4 reports the ratios w.r.t. the keyword node depth in each epoch of training the RNN model. The ratios in the first epoch are always very small. In each following epoch, the RNN model successfully lifts up the ratios steadily (see Figure (a)a for a clear picture at the keyword depth 10), but a clear decrease when the depth becomes larger is observable. For the RLSTM model (see Figure 5 and (b)b), the story is somewhat different. The ratios go up after two epochs so rapidly that there are even some exploding error signals sent back to leaf nodes. They subsequently go down and remain stable with substantially less exploding error signals. This is, interestingly, concurrent with the performance of the RLSTM model on the development set (see Figure (b)b). It seems that the RLSTM model, after one epoch, quickly locates the keyword node in a tree and relates it to the root by building a strong bond between them via error signals. After the correlation between the keyword and the label at the root is found, it tries to stabilize the training by reducing the error signals sent back to the keyword node. Comparing the two models by aligning Figure 4 with Figure 5, and Figure (a)a with Figure (b)b, we can see that the RLSTM model is more capable of transmitting error signals to leaf nodes.
It is worth noting that we do see the vanishing gradient problem happening when training the RNN model in Figure 4; but Figure (a)a suggests that the problem can become less serious after a long enough training time. This might be because depth 10 is still manageable for the RNN model. (Notice that in the Stanford Sentiment Treebank, more than three quarters of leaf nodes are at depths less than 10.) The fact the the RNN model still doesnot perform better than random guessing can be explained using the arguments given by bengio1994learning, who show that there is a trade-off between avoiding the vanishing gradient problem and capturing long term dependencies when training traditional recurrent networks.
The experimental results show that the RLSTM is superior to the RNN in terms of overcoming the vanishing gradient problem and capturing long term dependencies. This is in parallel with general conclusions about the power of the LSTM architecture compared to traditional Recurrent neural networks. In future work we focus on more complex cases involving negation, composition, etc.
- [Bengio et al.1994] Yoshua Bengio, Patrice Simard, and Paolo Frasconi. 1994. Learning long-term dependencies with gradient descent is difficult. Neural Networks, IEEE Transactions on, 5(2):157–166.
[Duchi et al.2011]
John Duchi, Elad Hazan, and Yoram Singer.
Adaptive subgradient methods for online learning and stochastic
The Journal of Machine Learning Research, pages 2121–2159.
- [Gers and Schmidhuber2001] Felix A Gers and Jürgen Schmidhuber. 2001. Lstm recurrent networks learn simple context-free and context-sensitive languages. Neural Networks, IEEE Transactions on, 12(6):1333–1340.
- [Hochreiter and Schmidhuber1997] Sepp Hochreiter and Jürgen Schmidhuber. 1997. Long short-term memory. Neural computation, 9(8):1735–1780.
- [Le and Zuidema2015] Phong Le and Willem Zuidema. 2015. Compositional distributional semantics with long short term memory. In Proceedings of the Joint Conference on Lexical and Computational Semantics (*SEM). Association for Computational Linguistics.
- [Liu et al.2014] Shujie Liu, Nan Yang, Mu Li, and Ming Zhou. 2014. A recursive recurrent neural network for statistical machine translation. In Proceedings of the 52nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1491–1500, Baltimore, Maryland, June. Association for Computational Linguistics.
- [Luong et al.2013] Minh-Thang Luong, Richard Socher, and Christopher D Manning. 2013. Better word representations with recursive neural networks for morphology. CoNLL-2013, 104.
[Socher et al.2010]
Richard Socher, Christopher D. Manning, and Andrew Y. Ng.
Learning continuous phrase representations and syntactic parsing with
recursive neural networks.
Proceedings of the NIPS-2010 Deep Learning and Unsupervised Feature Learning Workshop.
- [Socher et al.2013a] Richard Socher, John Bauer, Christopher D Manning, and Andrew Y Ng. 2013a. Parsing with compositional vector grammars. In Proceedings of the 51st Annual Meeting of the Association for Computational Linguistics, pages 455–465.
- [Socher et al.2013b] Richard Socher, Alex Perelygin, Jean Y Wu, Jason Chuang, Christopher D Manning, Andrew Y Ng, and Christopher Potts. 2013b. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings EMNLP.
[Tai et al.2015]
Kai Sheng Tai, Richard Socher, and Christopher D. Manning.
Improved semantic representations from tree-structured long
short-term memory networks.
Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), pages 1556–1566, Beijing, China, July. Association for Computational Linguistics.
- [Zhu et al.2015] Xiaodan Zhu, Parinaz Sobhani, and Hongyu Guo. 2015. Long short-term memory over recursive structures. In Proceedings of International Conference on Machine Learning, July.