Restricted Recurrent Neural Tensor Networks: Exploiting Word Frequency and Compositionality

TL;DR

This paper introduces restricted recurrent neural tensor networks (r-RNTN) that allocate distinct weights for frequent words and shared weights for infrequent ones, improving language modeling efficiency and performance.

Contribution

The paper proposes r-RNTN, a novel model that reduces memory costs while enhancing language model performance by exploiting word frequency and compositionality.

Findings

r-RNTN outperforms standard RNNs in perplexity with fewer parameters

r-RNTN achieves similar or better results than unrestricted RNTNs

Effective with Gated Recurrent Units and LSTM

Abstract

Increasing the capacity of recurrent neural networks (RNN) usually involves augmenting the size of the hidden layer, with significant increase of computational cost. Recurrent neural tensor networks (RNTN) increase capacity using distinct hidden layer weights for each word, but with greater costs in memory usage. In this paper, we introduce restricted recurrent neural tensor networks (r-RNTN) which reserve distinct hidden layer weights for frequent vocabulary words while sharing a single set of weights for infrequent words. Perplexity evaluations show that for fixed hidden layer sizes, r-RNTNs improve language model performance over RNNs using only a small fraction of the parameters of unrestricted RNTNs. These results hold for r-RNTNs using Gated Recurrent Units and Long Short-Term Memory.

Tables

Table 1. Table 1: Comparison of validation and test set perplexity for r-RNTNs with f 𝑓 f mapping ( K = 100 𝐾 100 K=100 for PTB, K = 376 𝐾 376 K=376 for text8) versus s-RNNs and m-RNN. r-RNTNs with the same H 𝐻 H as corresponding s-RNNs significantly increase model capacity and performance with no computational cost. The RNTN was not run on text8 due to the number of parameters required.

		PTB		text8				PTB
Method	$H$	# Params	Test PPL	# Params	Test PPL	Method	$H$	# Params	Test PPL
s-RNN	100	2M	146.7	7.6M	236.4	GRU	244	9.6M	92.2
r-RNTN $f$	100	3M	131.2	11.4M	190.1	GRU	650	15.5M	90.3
RNTN	100	103M	128.8	388M	-	r-GRU $f$	244	15.5M	87.5
m-RNN	100	3M	164.2	11.4M	895.0	LSTM	254	10M	88.8
s-RNN	150	3M	133.7	11.4M	207.9	LSTM	650	16.4M	84.6
r-RNTN $f$	150	5.3M	126.4	19.8M	171.7	r-LSTM $f$	254	16.4M	87.1

Equations

$$h_t=\sigma (W_h{x}_t+U_h{h}_{t-1}+b_h)$$

$$P(x_t|x_{1\dots t-1})=x_t^{T}Softmax(W_o{h}_t+b_o)$$

$$h_t=\sigma (W_h{x}_t+U_h^{i(x_t)}{h}_{t-1}+b_h)$$

$$h_t=\sigma (W_h{x}_t+U_h^{f(i(x_t))}{h}_{t-1}+b_h^{f(i(x_t))})$$

$$f(w)=min(rank(w),K)$$

$$r_t$$

$$z_t$$

$$\text{noindent}{\tilde{h}}_t$$

$$h_t$$

$$f_t$$

$$i_t$$

$$o_t$$

$${\tilde{c}}_t$$

$$c_t$$

$$h_t$$

$$f_{mod}(w)=rank(w)\mathrm{mod}K$$

Full text

1 Introduction

Recurrent neural networks (RNN), which compute their next output conditioned on a previously stored hidden state, are a natural solution to sequence modeling. Mikolov et al. (2010) applied RNNs to word-level language modeling (we refer to this model as s-RNN), outperforming traditional n-gram methods. However, increasing capacity (number of tunable parameters) by augmenting the size $H$ of the hidden (or recurrent) layer — to model more complex distributions — results in a significant increase in computational cost, which is $O(H^{2})$.

Sutskever et al. (2011) increased the performance of a character-level language model with a multiplicative RNN (m-RNN), the factored approximation of a recurrent neural tensor network (RNTN), which maps each symbol to separate hidden layer weights (referred to as recurrence matrices from hereon). Besides increasing model capacity while keeping computation constant, this approach has another motivation: viewing the RNN’s hidden state as being transformed by each new symbol in the sequence, it is intuitive that different symbols will transform the network’s hidden state in different ways Sutskever et al. (2011). Various studies on compositionality similarly argue that some words are better modeled by matrices than by vectors (Baroni and Zamparelli, 2010; Socher et al., 2012). Unfortunately, having separate recurrence matrices for each symbol requires memory that is linear in the symbol vocabulary size ($|V|$). This is not an issue for character-level models, which have small vocabularies, but is prohibitive for word-level models which can have vocabulary size in the millions if we consider surface forms.

In this paper, we propose the Restricted RNTN (r-RNTN) which uses only $K<|V|$ recurrence matrices. Given that $|V|$ words must be assigned $K$ matrices, we map the most frequent $K-1$ words to the first $K-1$ matrices, and share the $K$-th matrix among the remaining words. This mapping is driven by the statistical intuition that frequent words are more likely to appear in diverse contexts and so require richer modeling, and by the greater presence of predicates and function words among the most frequent words in standard corpora like COCA Davies (2009). As a result, adding $K$ matrices to the s-RNN both increases model capacity and satisfies the idea that some words are better represented by matrices. Results show that r-RNTNs improve language model performance over s-RNNs even for small $K$ with no computational overhead, and even for small $K$ approximate the performance of RNTNs using a fraction of the parameters. We also experiment with r-RNTNs using Gated Recurrent Units (GRU) (Cho et al., 2014) and Long Short-Term Memory (LSTM) (Hochreiter and Schmidhuber, 1997), obtaining lower perplexity for fixed hidden layer sizes. This paper discusses related work ($\S$2), and presents r-RNTNs ($\S$3) along with the evaluation method ($\S$4). We conclude with results ($\S$5), and suggestions for future work.

2 Related Work

We focus on related work that addresses language modeling via RNNs, word representation, and conditional computation.

Given a sequence of words $(x_{1},...,x_{T})$, a language model gives the probability $P(x_{t}|x_{1\dots t-1})$ for $t\in[1,T]$. Using a RNN, Mikolov et al. (2010) created the s-RNN language model given by:

[TABLE]

where $h_{t}$ is the hidden state represented by a vector of dimension $H$, $\sigma(z)$ is the pointwise logistic function, $W_{h}$ is the $H\times V$ embedding matrix, $U_{h}$ is the $H\times H$ recurrence matrix, $W_{o}$ is the $V\times H$ output matrix, and $b_{h}$ and $b_{o}$ are bias terms. Computation is $O(H^{2})$, so increasing model capacity by increasing $H$ quickly becomes intractable.

The RNTN proposed by Sutskever et al. (2011) is nearly identical to the s-RNN, but the recurrence matrix in eq. 1 is replaced by a tensor as follows:

[TABLE]

where $i(z)$ maps a hot-one encoded vector to its integer representation. Thus the $U_{h}$ tensor is composed of $|V|$ recurrence matrices, and at each step of sequence processing the matrix corresponding to the current input is used to transform the hidden state.

The authors also proposed m-RNN, a factorization of the $U_{h}^{i(x_{t})}$ matrix into $U_{lh}diag(v_{x_{t}})U_{rh}$ to reduce the number of parameters, where $v_{x_{t}}$ is a factor vector of the current input $x_{t}$, but like the RNTN, memory still grows linearly with $|V|$. The RNTN has the property that input symbols have both a vector representation given by the embedding and a matrix representation given by the recurrence matrix, unlike the s-RNN where symbols are limited to vector representations.

The integration of both vector and matrix representations has been discussed

but with a focus on representation learning and not sequence modeling Baroni and Zamparelli (2010); Socher et al. (2012). For instance, Baroni and Zamparelli (2010) argue for nouns to be represented as vectors and adjectives as matrices.

Irsoy and Cardie (2014) used m-RNNs for the task of sentiment classification and obtained equal or better performance than s-RNNs. Methods that use conditional computation Cho and Bengio (2014); Bengio et al. (2015); Shazeer et al. (2017) are similar to RNTNs and r-RNTNs, but rather than use a static mapping, these methods train gating functions which do the mapping. Although these methods can potentially learn better policies than our method, they are significantly more complex, requiring the use of reinforcement learning (Cho and Bengio, 2014; Bengio et al., 2015) or additional loss functions (Shazeer et al., 2017), and more linguistically opaque (one must learn to interpret the mapping performed by the gating functions).

Whereas our work is concerned with updating the network’s hidden state, Chen et al. (2015) introduce a technique that better approximates the output layer’s Softmax function by allocating more parameters to frequent words.

3 Restricted Recurrent Neural Tensor Networks

To balance expressiveness and computational cost, we propose restricting the size of the recurrence tensor in the RNTN such that memory does not grow linearly with vocabulary size, while still keeping dedicated matrix representations for a subset of words in the vocabulary. We call these Restricted Recurrent Neural Tensor Networks (r-RNTN), which modify eq. 3 as follows:

[TABLE]

where $U_{h}$ is a tensor of $K<|V|$ matrices of size $H\times H$, $b_{h}$ is a $H\times K$ bias matrix with columns indexed by $f$. The function $f(w)$ maps each vocabulary word to an integer between $1$ and $K$.

We use the following definition for $f$:

[TABLE]

where $rank(w)$ is the rank of word $w$ when the vocabulary is sorted by decreasing order of unigram frequency.

This is an intuitive choice because words which appear more often in the corpus tend to have more variable contexts, so it makes sense to dedicate a large part of model capacity to them. A second argument is that frequent words tend to be predicates and function words. We can imagine that predicates and function words transform the meaning of the current hidden state of the RNN through matrix multiplication, whereas nouns, for example, add meaning through vector addition, following Baroni and Zamparelli (2010).

We also perform initial experiments with r-RNTNs using LSTM and GRUs. A GRU is described by

[TABLE]

and an LSTM by

[TABLE]

We create r-RNTN GRUs (r-GRU) by making $U_{h}^{h}$ and $b_{h}^{h}$ input-specific (as done in eq. 4). For r-RNTN LSTMs (r-LSTM), we do the same for $U_{h}^{c}$ and $b_{h}^{c}$.

4 Materials

We evaluate s-RNNs, RNTNs, and r-RNTNs by training and measuring model perplexity (PPL) on the Penn Treebank (PTB) corpus Marcus et al. (1994) using the same preprocessing as Mikolov et al. (2011). Vocabulary size is 10000.

For an r-RNTN with $H=100$, we vary the tensor size $K$ from $1$, which corresponds to the s-RNN, all the way up to $10000$, which corresponds to the unrestricted RNTN. As a simple way to evaluate our choice of rank-based mapping function $f$, we compare it to a pseudo-random variant:

[TABLE]

We also compare results to 1) an s-RNN with $H=150$, which has the same number of parameters as an r-RNTN with $H=100$ and $K=100$. 2) An m-RNN with $H=100$ with the size of factor vectors set to $100$ to match this same number of parameters. 3) An additional r-RNTN with $H=150$ is trained to show that performance scales with $H$ as well.

We split each sentence into 20 word sub-sequences and run stochastic gradient descent via backpropagation through time for 20 steps without mini-batching, only reseting the RNN’s hidden state between sentences. Initial learning rate (LR) is $0.1$ and halved when the ratio of the validation perplexity between successive epochs is less than $1.003$, stopping training when validation improvement drops below this ratio for $5$ consecutive epochs. We use Dropout Srivastava et al. (2014) with $p=.5$ on the softmax input to reduce overfitting. Weights are drawn from $\mathcal{N}(0,.001)$; gradients are not clipped. To validate our proposed method, we also evaluate r-RNTNs using the much larger text8222http://mattmahoney.net/dc/textdata.html corpus with a 90MB-5MB-5MB train-validation-test split, mapping words which appear less than 10 times to $\langle unk\rangle$ for a total vocabulary size of $37751$.

Finally, we train GRUs, LSTMs, and their r-RNTN variants using the PTB corpus and parameters similar to those used by Zaremba et al. (2014). All networks use embeddings of size $650$ and a single hidden layer. Targeting $K=100$, we set $H=244$ for the r-GRU and compare with a GRU with $H=650$ which has the same number of parameters. The r-LSTM has $H=254$ to match the number of parameters of an LSTM with $H=650$. The training procedure is the same as above but with mini-batches of size 20, 35 timestep sequences without state resets, initial LR of 1, Dropout on all non-recurrent connections, weights drawn from $\mathcal{U}(-.05,.05)$, and gradients norm-clipped to $5$.

5 Results

Results are shown in fig. 1 and table 1.

Comparing the r-RNTN to the baseline s-RNN with $H=100$ (fig. 1), as model capacity grows with K, test set perplexity drops, showing that r-RNTN is an effective way to increase model capacity with no additional computational cost. As expected, the $f$ mapping outperforms the baseline $f_{mod}$ mapping at smaller $K$. As $K$ increases, we see a convergence of both mappings. This may be due to matrix sharing at large $K$ between frequent and infrequent words because of the modulus operation in eq. 16. As infrequent words are rarely observed, frequent words dominate the matrix updates and approximate having distinct matrices, as they would have with the $f$ mapping.

It is remarkable that even with $K$ as small as $100$, the r-RNTN approaches the performance of the RNTN with a small fraction of the parameters. This reinforces our hypothesis that complex transformation modeling afforded by distinct matrices is needed for frequent words, but not so much for infrequent words which can be well represented by a shared matrix and a distinct vector embedding. As shown in table 1, with an equal number of parameters, the r-RNTN with $f$ mapping outperforms the s-RNN with a bigger hidden layer. It appears that heuristically allocating increased model capacity as done by the $f$ based r-RNTN is a better way to increase performance than simply increasing hidden layer size, which also incurs a computational penalty.

Although m-RNNs have been successfully employed in character-level language models with small vocabularies, they are seldom used in word-level models. The poor results shown in table 1 could explain why.333It should be noted that Sutskever et al. (2011) suggest m-RNNs would be better optimized using second-order gradient descent methods, whereas we employed only first-order gradients in all models we trained to make a fair comparison.

For fixed hidden layer sizes, r-RNTNs yield significant improvements to s-RNNs, GRUs, and LSTMs, confirming the advantages of distinct representations.

6 Conclusion and Future Work

In this paper, we proposed restricted recurrent neural tensor networks, a model that restricts the size of recurrent neural tensor networks by mapping frequent words to distinct matrices and infrequent words to shared matrices. r-RNTNs were motivated by the need to increase RNN model capacity without increasing computational costs, while also satisfying the ideas that some words are better modeled by matrices rather than vectors Baroni and Zamparelli (2010); Socher et al. (2012). We achieved both goals by pruning the size of the recurrent neural tensor network described by Sutskever et al. (2011) via sensible word-to-matrix mapping. Results validated our hypothesis that frequent words benefit from richer, dedicated modeling as reflected in large perplexity improvements for low values of $K$.

Interestingly, results for s-RNNs and r-GRUs suggest that given the same number of parameters, it is possible to obtain higher performance by increasing $K$ and reducing $H$. This is not the case with r-LSTMs, perhaps to due to our choice of which of the recurrence matrices to make input-specific. We will further investigate both of these phenomena in future work, experimenting with different combinations of word-specific matrices for r-GRUs and r-LSTMs (rather than only $U_{h}^{h}$ and $U_{h}^{c}$), and combining our method with recent improvements to gated networks in language modeling Jozefowicz et al. (2016); Merity et al. (2018); Melis et al. (2018) which we believe are orthogonal and hopefully complementary to our own.

Finally, we plan to compare frequency-based and additional, linguistically motivated $f$ mappings (for example different inflections of a verb sharing a single matrix) with mappings learned via conditional computing to measure how external linguistic knowledge contrasts with knowledge automatically inferred from training data.

Acknowledgments

This research was partly supported by CAPES and CNPq (projects 312114/2015-0, 423843/2016-8, and 140402/2018-7).