Diagonal RNNs in Symbolic Music Modeling

TL;DR

This paper introduces a diagonal RNN architecture that replaces full recurrent matrices, leading to improved test likelihood and faster convergence in symbolic music modeling tasks across various RNN types.

Contribution

The paper presents a simple yet effective modification of RNNs using diagonal matrices, enhancing performance and training speed in symbolic music modeling.

Findings

Diagonal RNNs outperform full RNNs in test likelihood

Faster convergence observed with diagonal matrices

Effective across LSTM, GRU, and vanilla RNNs

Abstract

In this paper, we propose a new Recurrent Neural Network (RNN) architecture. The novelty is simple: We use diagonal recurrent matrices instead of full. This results in better test likelihood and faster convergence compared to regular full RNNs in most of our experiments. We show the benefits of using diagonal recurrent matrices with popularly used LSTM and GRU architectures as well as with the vanilla RNN architecture, on four standard symbolic music datasets.

Tables

Table 1. Table 1: Minimum Negative Log-Likelihoods on Test Data (Lower is better) with Adam and RMSProp optimizers. F stands for Full models and D stands for Diagonal models.

Dataset/Optimizer	RNN-F	RNN-D	LSTM-F	LSTM-D	GRU-F	GRU-D
JSB Chorales/Adam	8.91	8.12	8.56	8.23	8.64	8.21
Piano-Midi/Adam	7.74	7.53	8.83	7.59	8.28	7.54
Nottingham/Adam	3.57	3.69	3.90	3.74	3.57	3.61
MuseData/Adam	7.82	7.26	8.96	7.08	7.52	7.20
JSB Chorales/RMSprop	8.72	8.22	8.51	8.14	8.53	8.22
Piano-Midi/RMSprop	7.65	7.51	7.84	7.49	7.62	7.48
Nottingham/RMSprop	3.40	3.67	3.54	3.65	3.45	3.62
MuseData/RMSprop	7.14	7.23	7.20	7.09	7.11	6.96

Equations

$$h_t=$$

$$f_t=$$

$$w_t=$$

$$c_t=$$

$$h_t=$$

$$f_t=$$

$$w_t=$$

$$o_t=$$

$$c_t=$$

$$h_t^{\prime }=$$

$$h_t=$$

$$f_t=$$

$$w_t=$$

$$c_t=$$

$$h_t=$$

$$f_t=$$

$$w_t=$$

$$o_t=$$

$$c_t=$$

$$h_t^{\prime }=$$

$$h_t=$$

$$h_t=\sigma (W\sigma (W{h}_{t-2}+U{x}_{t-1})+U{x}_t)$$

$$=$$

$$h_t=$$

$$=$$

$$\text{Per Frame Negative Log-Likelihood}=-\frac{1}{T}\sum _{t=1}^T{y}_t\log {\hat{y}}_t,$$

Full text

**Index Terms— ** Recurrent Neural Networks, Symbolic Music Modeling

1 Introduction

During the recent resurgence of neural networks in 2010s, Recurrent Neural Networks (RNNs) have been utilized in a variety of sequence learning applications with great success. Examples include language modeling [1], machine translation [2], handwriting recognition [3], speech recognition [4], and symbolic music modeling [5].

In this paper, we empirically show that in symbolic music modeling, using a diagonal recurrent matrix in RNNs results in significant improvement in terms of convergence speed and test likelihood.

The inspiration for this idea comes from multivariate Gaussian Mixture Models: In Gaussian mixture modeling (or Gaussian models in general) it is known that using a diagonal covariance matrix often results in better generalization performance, increased numerical stability and reduced computational complexity [6, 7]. We adapt this idea to RNNs by using diagonal recurrent matrices.

We investigate the consequences of using diagonal recurrent matrices for the vanilla RNNs, and for more popular Long Short Term Memory Networks (LSTMs) [8, 9] and Gated Recurrent Units (GRUs) [10]. We empirically observe that using diagonal recurrent matrices results in an improvement in convergence speed in training and the resulting test likelihood for all three models, on four standard symbolic music modeling datasets.

2 Recurrent Neural Networks

The vanilla RNN (VRNN) recursion is defined as follows:

[TABLE]

where $h_{t}\in\mathbb{R}^{K}$ is the hidden state vector with $K$ hidden units, and $x_{t}\in\mathbb{R}^{L}$ is the input vector at time $t$ (which has length $L$). The $U\in\mathbb{R}^{K\times L}$ is the input matrix that transforms the input $x_{t}$ from an $L$ to $K$ dimensional space and $W\in\mathbb{R}^{K\times K}$ is the recurrent matrix (factor) that transforms the previous state. Finally, $b\in\mathbb{R}^{K}$ is the bias vector. Note that, in practice this recursion is either followed by an output stage on top of $h_{t}$ to get the outputs as $y_{t}=\sigma_{2}(Vh_{t})\in\mathbb{R}^{L}$, or another recursion to obtain a multi-layer recurrent neural network. The hidden layer non-linearity $\sigma_{1}(.)$ is usually chosen as hyperbolic tangent. The choice of the output non-linearity $\sigma_{2}(.)$ is dependent on the application, and is typically softmax or sigmoid function.

Despite its simplicity, RNN in its original form above is usually not preferred in practice due to the well known gradient vanishing problem [11]. People often use the more involved architectures such as LSTMs and GRUs, which alleviate the vanishing gradient issue using gates which filter the information flow to enable the modeling of long-term dependencies.

2.1 LSTM and GRU

The GRU Network is defined as follows:

[TABLE]

where $\odot$ denotes element-wise (Hadamard) product, $\sigma(.)$ is the sigmoid function, $f_{t}\in\mathbb{R}^{K}$ is the forget gate, and $w_{t}\in\mathbb{R}^{K}$ is the write gate: If $f_{t}$ is a zeros vector, the current state $h_{t}$ depends solely on the candidate vector $c_{t}$. On the other extreme where $f_{t}$ is a ones vector, the state $h_{t-1}$ is carried over unchanged to $h_{t}$. Similarly, $w_{t}$ determines how much $h_{t-1}$ contributes to the candidate state $c_{t}$. Notice that if $w_{t}$ is a ones vector and $f_{t}$ is a zeros vector, the GRU architecture reduces to the VRNN architecture in Equation (1). Finally, note that we have omitted the biases in the equations for $f_{t}$, $w_{t}$, and $c_{t}$ to reduce the notation clutter. We will omit the bias terms also in the rest of this paper.

The LSTM Network is very much related to the GRU network above. In addition to the gates in GRU, there is the output gate $o_{t}$ to control the output of the RNN, and the forget gate is decoupled into gates $f_{t}$ and $w_{t}$, which blend the previous state and the candidate state $c_{t}$:

[TABLE]

Also notice the application of the tangent hyperbolic on $h^{\prime}_{t}$ before yielding the output. This prevents the output from assuming values with too large magnitudes. In [12] it is experimentally shown that this output non-linearity is crucial for the LSTM performance.

2.2 Diagonal RNNs

We define the Diagonal RNN as an RNN with diagonal recurrent matrices. The simplest case is obtained via the modification of the VRNN. After the modification, the VRNN recursion becomes the following:

[TABLE]

where this time the recurrent term $W$ is a length $K$ vector, instead of a $K\times K$ matrix. Note that element wise multiplying the previous state $h_{t-1}$ with the $W$ vector is equivalent to having a matrix-vector multiplication $W_{diag}h_{t-1}$ where $W_{diag}$ is a diagonal matrix, with diagonal entries set to the $W$ vector, and hence the name for Diagonal RNNs. For the more involved GRU and LSTM architectures, we also modify the recurrent matrices of the gates. This results in the following network architecture for GRU:

[TABLE]

where $W_{f},W_{w},W\in\mathbb{R}^{K}$. Similarly for LSTM, we obtain the following:

[TABLE]

where again $W_{f},W_{w},W_{o},W\in\mathbb{R}^{K}$. One more thing to note is that the total number of trainable parameters in this model scales as $\mathcal{O}(K)$ and not $\mathcal{O}(K^{2})$ like the regular full architectures, which implies lower memory and computation requirements.

2.3 Intuition on Diagonal RNNs

In order to gain some insight on how diagonal RNNs differ from regular full RNNs functionally, let us unroll the VRNN recursion in Equation 1:

[TABLE]

So, we see that the RNN recursion forms a mapping from $x_{1:t}=(x_{1},\dots,x_{t-1},x_{t})$ to $h_{t}$. That is, the state $h_{t}$ is a function of all past inputs and the current input. To get an intuition on how the recurrent matrix $W$ interacts with the inputs $x_{1:t}$ functionally, we can temporarily ignore the $\sigma(.)$ non-linearities:

[TABLE]

Although this equation sacrifices from generality, it gives a notion on how the $W$ matrix effects the overall transformation: After the input transformation via the $U$ matrix, the inputs are further transformed via multiple application of $W$ matrices: The exponentiated $W$ matrices act as “weights” on the inputs. Now, the question is, why are the weights applied via $W$ are the way they are? The input transformations via $U$ are sensible since we want to project our inputs to a $K$ dimensional space. But the transformations via recurrent weights $W$ are rather arbitrary as there are multiple plausible forms for $W$.

We can now see that a straightforward alternative to the RNN recursion in equation (1) is considering linear transformations via diagonal, scalar and constant alternatives for the recurrent matrix $W$, similar to the different cases for Gaussian covariance matrices [7]. In this paper, we explore the diagonal alternative to the full $W$ matrices.

One last thing to note is that using a diagonal matrix does not completely eliminate the ability of the neural network to model inter-dimensional correlations since the projection matrix $U$gets applied on each input $x_{t}$, and furthermore, most networks typically has a dense output layer.

3 Experiments

We trained VRNNs, LSTMs and GRUs with full and diagonal recurrent matrices on the symbolic midi music datasets. We downloaded the datasets from http://www-etud.iro.umontreal.ca/~boulanni/icml2012 which are originally used in the paper [5]. The learning goal is to predict the next frame in a given sequence using the past frames. All datasets are divided into training, test, and validation sets. The performance is measured by the per-frame negative log-likelihood on the sequences in the test set.

The datasets are ordered in increasing size as, JSB Chorales, Piano-Midi, Nottingham and MuseData. We did not apply any transposition to center the datasets around a key center, as this is an optional preprocessing as indicated in [5]. We used the provided piano roll sequences provided in the aforementioned url, and converted them into binary masks where the entry is one if there is a note played in the corresponding pitch and time. We also eliminated the pitch bins for which there is no activity in a given dataset. Due to the large size of our experiments, we limited the maximum sequence length to be 200 (we split the sequences longer than 200 into sequences of length 200 at maximum) to take advantage of GPU parallelization, as we have noticed that this operation does not alter the results significantly.

We randomly sampled 60 hyper-parameter configurations for each model in each dataset, and for each optimizer. We report the test accuracies for the top 6 configurations, ranked according to their performance on the validation set. For each random hyper-parameter configuration, we trained the given model for 300 iterations. We did these experiments for two different optimizers. Overall, we have 6 different models (VRNN full, VRNN diagonal, LSTM full, LSTM diagonal, GRU full, GRU diagonal), and 4 different datasets, and 2 different optimizers, so this means that we obtained $6\times 4\times 2\times 60=2880$ training runs, 300 iterations each. We trained our models on Nvidia Tesla K80 GPUs.

As optimizers, we used the Adam optimizer [13] with the default parameters as specified in the corresponding paper, and RMSprop [14]. We used a sigmoid output layer for all models. We used mild dropout in accordance with [15] with keep probability $0.9$ on the input and output of all layers. We used Xavier initialization [16] for all cases. The sampled hyper-parameters and corresponding ranges are as follows:

• •

Number of hidden layers: Uniform Samples from {2,3}.

• •

Number of hidden units per hidden layer: Uniform Samples from {50,…,300} for LSTM, and uniform samples from {50,…,350} for GRU, and uniform samples from {50,…,400} for VRNN.

• •

Learning rate: Log-uniform samples from the range $[10^{-4},10^{-2}]$.

• •

Momentum (For RMS-Prop): Uniform samples from the range $[0,1]$.

As noted in the aforementioned url, we used the per-frame negative log-likelihood measure to evaluate our models. The negative log-likelihood is essentially the cross-entropy between our predictions and the ground truth. Per frame negative log-likelihood is given by the following expression:

[TABLE]

where $y_{t}$ is the ground truth for the predicted frames and $\hat{y}_{t}$ is the output of our neural network, and $T$ is the number of time steps (frames) in a given sequence.

In Figures 1, 2, 3, and 4 we show the training iterations vs negative test log-likelihoods for top 6 hyperparameter configurations on JSB Chorales, Piano-midi, Nottingham and MuseData datasets, respectively. That is, we show the negative log-likelihoods obtained on the test set with respect to the training iterations, for top 6 hyper-parameter configurations ranked on the validation set according to the performance attained at the last iteration. The top rows show the training iterations for the Adam optimizer and the bottom rows show the iterations for the RMSprop optimizer. The curves show the negative log-likelihood averaged over the top 6 configurations, where cyan curves are for full model and black curves are for diagonal models. We use violin plots, which show the distribution of the test negative log-likelihoods of the top 6 configurations. We also show the average number of parameters used in the models corresponding to top 6 configurations in the legends of the figures. The minimum negative log-likelihood values obtained with each model using Adam and RMSprop optimizers are summarized in Table 1.

We implemented all models in Tensorflow [17], and our code can be downloaded from our github page https://github.com/ycemsubakan/diagonal_rnns. All of the results presented in this paper are reproducible with the provided code.

4 Conclusions

• •

We see that using diagonal recurrent matrices results in an improvement in test likelihoods in almost all cases we have explored in this paper. The benefits are extremely pronounced with the Adam optimizer, but with RMSprop optimizer we also see improvements in training speed and the final test likelihoods. The fact that this modification results in an improvement for three different models and two different optimizers strongly suggests that using diagonal recurrent matrices is suitable for modeling symbolic music datasets, and is potentially useful in other applications.

• •

Except the Nottingham dataset, using the diagonal recurrent matrix results in an improvement in final test likelihood in all cases. Although the final negative likelihoods on the Nottingham dataset are larger for diagonal models, we still see some improvement in training speed in some cases, as we see that the black curves lie below the cyan curves for the most part.

• •

We see that the average number of parameters utilized by the top 6 diagonal models is in most cases smaller than that of the top 6 full models: In these cases, we observe that the diagonal models achieve comparable (if not better) performance by using fewer parameters.

Overall, in this paper we provide experimental data which strongly suggests that the diagonal RNNs can be a great alternative for regular full-recurrent-matrix RNNs.