© Springer Nature Switzerland AG 2020
P. Cellier, K. Driessens (eds.)Machine Learning and Knowledge Discovery in DatabasesCommunications in Computer and Information Science1168https://doi.org/10.1007/978-3-030-43887-6_38

Rhythm, Chord and Melody Generation for Lead Sheets Using Recurrent Neural Networks

Cedric De Boom1  , Stephanie Van Laere1  , Tim Verbelen1   and Bart Dhoedt1  
(1)
IDLab, Department of Information Technology at Ghent University – imec, Technologiepark-Zwijnaarde 126, 9052 Ghent, Belgium
 
 
Cedric De Boom (Corresponding author)
Email: cedric.deboom@ugent.be
 
Stephanie Van Laere
Email: stephanie.vanlaere@ugent.be
 
Tim Verbelen
Email: tim.verbelen@ugent.be
 
Bart Dhoedt
Email: bart.dhoedt@ugent.be

Abstract

Music that is generated by recurrent neural networks often lacks a sense of direction and coherence. We therefore propose a two-stage LSTM-based model for lead sheet generation, in which the harmonic and rhythmic templates of the song are produced first, after which, in a second stage, a sequence of melody notes is generated conditioned on these templates. A subjective listening test shows that our approach outperforms the baselines and increases perceived musical coherence .

Keywords
Music generationLead sheetsNeural networks

1 Lead Sheets

Lead sheets are widely used to represent the fundamental musical information about almost any contemporary song: they contain a chord scheme, a melody line, some navigation and repetition markers, and sometimes lyrics. They seldom contain information about the instrumentation or accompaniment, so any band can take a lead sheet as a guideline and make the song their own, sometimes even by improvising over the chord schemes. In this paper we focus on generating chords and melody lines for lead sheets from scratch.

A major difficulty in music generation is that harmony, melody and rhythm all influence each other. For example, a melody note can change whenever the underlying harmony changes, and vice versa. Rhythmic patterns can influence which notes are played, and rhythm and harmony together define the overall groove of the piece. To tackle this issue, we split the generation process into two stages. First, we generate a harmonic progression using chord sequences, while simultaneously picking the most appropriate rhythmic patterns. And in a second step the melody is generated on top of this harmonic and rhythmic template.

We are, however, not the first to tackle the problem of lead sheet generation and, in general, music generation. Briot et al. provide a recent and extensive overview of all deep learning based techniques in this field [1]. Regarding lead sheets specifically, Liu et al. use GAN-based models on piano roll representations, but the melody and chords are still predicted independently by different generators [9]. Roy et al. devise a lead sheet generator with user constraints defined by Markov models, and harmonic synchronization between melody and chords through a probabilistic model that encodes which melody notes fit on which chords [11]. There have also been many efforts in the past that learn to generate chords for a given melody [3, 8, 10] or the other way round [12]. In this paper we want to show that, on the one hand, a two-stage generation process greatly improves the perceived quality of the music. And, on the other hand, we show that melodic coherence improves when the melody generator gets to look ahead at the entire harmonic template of the song.

We formally define a lead sheet $$x_{1:n}$$ of length n, characterized by a sequence of chords $$c_{1:n}$$, rhythms $$r_{1:n}$$ and melody pitches $$m_{1:n}$$. At each time step i in the piece, each of these quantities take some value:
$$\begin{aligned} x_{1:n}&= \left\{ c_{1:n}, r_{1:n}, m_{1:n} \right\} ,\quad x_i = \left\{ c_i, r_i, m_i \right\} . \end{aligned}$$
(1)
In this equation, the compact $$x_{j:k}$$ notation denotes the sequence $$\left( x_j, x_{j+1} \dots x_k\right) $$. Figure 1 shows an example of this decomposition. Notice that the chords are repeated until there is a change in harmony, thereby allowing us to model the entire lead sheet using a single shared time scale. We also point out that there is only one melody note per time step, which is not a severe restriction, since most lead sheets only contain monophonic melodies. Finally, we choose to treat the barlines as separate elements in the sequence, which is indicated by the vertical bars in Fig. 1.
../images/496776_1_En_38_Chapter/496776_1_En_38_Fig1_HTML.png
Fig. 1.

Example of a lead sheet decomposition into chords, rhythms and melodies.

2 The Wikifonia Dataset

In this paper we will make use of the Wikifonia dataset, a former public lead sheet repository hosted by wikifonia.org. It contains more than 6,500 lead sheets in MusicXML format, and in all sorts of modern genres. This section goes over the different preprocessing and encoding steps that are executed on the dataset in order to obtain a clean collection of lead sheets.

2.1 Preprocessing

Eliminate Polyphony. Whenever multiple notes sound at the same time, we only retain the note with the highest pitch, as it is often the note that characterizes the melody.

Ignore Ties. Connections between two notes with the same pitch that extend the first note’s duration are ignored. The two notes are therefore treated as two separate notes with their original duration.

Delete Anacruses. Incomplete bars that often appear at the start of a piece, are removed from all lead sheets.

Unfold Repetitions. Lead sheets can contain repetition and other navigation markers. If a section should be repeated, we duplicate that particular section, thereby unfolding the piece into a single linear sequence.

Remove Ornaments. Since such ornaments do not contribute much to the overall melody, we leave them out.

2.2 Data Encoding and Features

After preprocessing, we encode the melody, rhythm and chord symbols into feature vectors such that they can be used as input to our generators.

Encoding Rhythms. We retain the 12 most common rhythm types in the dataset, which are given in Appendix B. We remove 184 lead sheets from the dataset that contain other than these 12 types. Together with the representation for a barline, we encode rhythm into a 13-dimensional one-hot vector $$\varvec{r}_i$$.

Encoding Chords. A chord is described by both its root and its mode. There are 12 possible roots (C, C$$\sharp $$, D, D$$\sharp $$, ..., B) and we choose to convert all accidentals to either no alteration or one sharp. We count 47 different modes in the dataset, which we map to one of the following four: major, minor, diminished or augmented. This mapping only very slightly reduces musical expressivity and interestingness. The mapping table can be found in Appendix A. The 12 roots and 4 modes give 48 chord options in total, resulting in a 49-dimensional one-hot vector $$\varvec{c}_i$$ if we include the barline.

Encoding Melody. The MIDI standard defines 128 possible pitches. We assign two additional dimensions for rests and barlines, resulting in a 130-dimensional one-hot encoded melody vector $$\varvec{m}_i$$.

3 Recurrent Neural Network Design

As mentioned in Sect. 1, the lead sheet generation process happens in two stages: in stage one the rhythm and chord template of the song is learned, and in stage two the melody notes are learned on top of that template. We will use separate LSTM-based models for both stages [2]; the models are trained independently of each other, but they are combined at inference time to generate an entire lead sheet from scratch. Figure 2 shows the complete architecture.

Stage One. In this stage, the rhythm and chord vectors are first concatenated and are subsequently given as inputs to two LSTM layers followed by a dense layer. All LSTM layers have a output dimensionality of 512 states, as indicated in the figure. The output of the dense layer is cut in two vectors, both on which we apply a softmax nonlinearity with temperature $$\tau $$, controlling the concentration of the output distribution. This way we are effectively modeling a distribution over the chord and rhythm symbols that come next in the sequence.

Stage Two. The second model will process the generated sequence of predicted chords and rhythms. To this end, each chord and rhythm vector is again concatenated before being processed by two BiLSTM layers. These BiLSTM states allow the pitch generator to look back and also ahead at the harmonic sequence, as inspired by [8]. The dimensionality of the BiLSTM layers is 512 in both directions, adding up to a total of 1024 states. After concatenation with the previous melody vector, the BiLSTM states are fed through another stack of two LSTM layers. The output of the last dense layer is used to predict the next melody note, again using a softmax nonlinearity controlled by a temperature parameter.
../images/496776_1_En_38_Chapter/496776_1_En_38_Fig2_HTML.png
Fig. 2.

The RNN architecture for both stage one (left) and stage two (right). The output dimensionality for every layer is written in each of the blocks. Whenever two blocks appear next to each other, the (output) vectors are concatenated.

3.1 Optimization Details

In this paper we train both stages separately; it is possible to jointly train both models through reparameterization tricks [4], but we leave this as future work. While training is done separately, inference of lead sheets from scratch is easily done by feeding the output of the first model to the input of the second model. We use a standard cross-entropy loss function on all outputs. In stage one we sum the losses on both the chord and rhythm outputs with hyperparameter $$\alpha $$:
$$\begin{aligned} \mathcal {L}_{\mathrm {stage\,1}}\!\left( \hat{\varvec{c}}, \hat{\varvec{r}}\right) = \alpha \cdot \mathcal {L}_{\mathrm {CE}}\!\left( \hat{\varvec{c}}\right) + (1 - \alpha )\cdot \mathcal {L}_{\mathrm {CE}}\!\left( \hat{\varvec{r}}\right) . \end{aligned}$$
(2)
In this equation, $$\mathcal {L}_{\mathrm {CE}}\!\left( \cdot \right) $$ indicates the cross-entropy loss. In stage two the loss function is equal to the cross-entropy loss on the melody output.
$$\begin{aligned} \mathcal {L}_{\mathrm {stage\,2}}\!\left( \hat{\varvec{m}}\right) = \mathcal {L}_{\mathrm {CE}}\!\left( \hat{\varvec{m}}\right) . \end{aligned}$$
(3)
We use Adam with learning rate $$\lambda $$ to optimize both models [6]. During optimization, the training data is augmented by shifting the pitches and chords with a random number of semitones between $$-12$$ and 12, that is, between plus or minus one octave. This virtually increases the amount of training data by a factor of 25, thereby aiding model generalization towards less frequently appearing keys.

4 Experiments

Hyperparameters. In all experiments we use a batch size of 128 sequences, each of length 100. The learning rate $$\lambda $$ is set fixed to 0.001. We empirically found that a value $$\alpha $$ of 0.5 leads to good results, so we set it fixed to that value. We also set the temperature $$\tau $$ slightly lower than 1 during inference of the melody, which helps to improve the perceived quality of the generated music; we varied it between 0.75 and 1.0 during the experiments. For the rhythm and chord patterns a temperature of 1.0 gives the most pleasing results.

Baselines. We will compare our model against two baselines:
  1. 1.

    An unconditioned LSTM-based model similar to the stage one model in Fig. 2, but now the melody is also concatenated to the input and output. The melody is no longer conditioned on the entire chord and rhythm sequence. We also add an extra LSTM layer, adding up to a total of three.

     
  2. 2.

    A two-stage model where the BiLSTM layers are replaced by regular LSTM layers, so that the melody cannot look ahead at the harmonic sequence. We keep all other parameters identical to the original model.

     
Subjective Listening Test. We conducted an online listening test in which we asked 40 participants to score 12 short audio clips, each of approximately one minute long. The following songs were included in the test1:

  • 3 pieces generated by the two-stage model from scratch,

  • 3 pieces generated by the two-stage model, but conditioned on the chord and rhythm scheme of existing songs: I Have a Dream (Abba), Autumn Leaves (jazz standard) and Colors of the Wind (Alan Menken),

  • 2 pieces generated by the one-stage baseline model,

  • 2 pieces generated by the two-stage baseline model,

  • 2 (relatively unknown) human-composed songs: You Belong to my Heart (Bing Crosby) and One Small Photograph (Kevin Shegog).

As stated in Sect. 1, a lead sheet only encodes the basic template of a song, and it ideally needs to be played by a real musician. We therefore gave all lead sheets to a semi-professional pianist; the pianist stayed true to the sheet music, but was free to create an accompaniment that suited the piece. In our regards, this evaluation method reflects best how a lead sheet, produced by an AI model, would in practice be used and experienced by musicians and listeners.

The audio clips were presented to each user in randomized order. For each clip we asked the user to rate on a scale of 1 to 5 how much he likes the piece, if the melody is musically coherent, and whether the piece is composed by a computer (1) or a human (5). We also asked the user to indicate if he recognizes the piece. Since each user has his own rating bias and spread [5, 7], we converted the ratings for each user to a standardized Z score between $$-0.5$$ and 0.5:
$$\begin{aligned} Z_{c,u} = \frac{R_{c,u} - \mu _u}{\max _{c'} R_{c',u} - \min _{c'} R_{c',u}}. \end{aligned}$$
(4)
In this formula, $$R_{c,u}$$ is the rating of user u for clip c, $$\mu _u$$ is the average rating of user u, and $$Z_{c,u}$$ is the associated standardized score. Table 1 reports the average $$\bar{Z}$$ score across the audio clips for each of the three questions in the survey, along with the standard deviation. A negative score means that the ratings are below average overall, and a positive score indicates an overall above-average rating.

We observe that the scores are, by far, better for the two-stage models compared to the unconditioned one-stage model. This shows that first sampling a harmonic and rhythmic sequence, and conditioning the melody on top of this sequence, is more beneficial than sampling all quantities simultaneously. Next to this, we also notice that adding the BiLSTM layers improves the score for all three questions. And although by a small margin, we can conclude that the musical quality improves when the melody generator can look ahead in the harmonic sequence. When we condition the melody generator on an existing chord and rhythm scheme, it is remarkable that the human-composed and AI-composed songs perform almost on par. The AI-composed songs are even considered most pleasing. Related to this observation, 4 participants indicated having recognized a piece from the two-stage model, 5 recognized a piece that was generated based on existing chords, and 3 participants recognized a human-composed song.

Finally, we also want to point out that the standard deviations are very substantial, which shows that there is a high level of disagreement between the reviewers. It is however interesting to point out that the standard deviation is slightly higher for better performing models. This might indicate that there is more consensus on what it means for music to sound ‘badly’, but that the definition of ‘good’ music is more subjective and person-dependent.
Table 1.

Results of the subjective listening experiments. We report averaged $$\bar{Z}$$-scores for each of the questions, along with the standard deviations.

Model

Pleasing $$\bar{Z}$$

Coherence $$\bar{Z}$$

Turing $$\bar{Z}$$

One-stage

$$-0.23\pm 0.34$$

$$-0.24\pm 0.31$$

$$-0.22\pm 0.29$$

Two-stage, without BiLSTM

$$-0.04\pm 0.35$$

$$-0.07\pm 0.33$$

$$-0.09\pm 0.33$$

Two-stage, with BiLSTM

$$-0.01\pm 0.36$$

$$0.01\pm 0.34$$

$$-0.02\pm 0.34$$

Two-stage, with existing chords

$$\mathbf{0.15}\pm 0.37$$

$$0.09\pm 0.36$$

$$\mathbf{0.13}\pm 0.36$$

Human-composed songs

$$0.03\pm 0.34$$

$$\mathbf{0.13}\pm 0.36$$

$$\mathbf{0.13}\pm 0.34$$

5 Conclusion

We have proposed a two-stage LSTM-based model to generate lead sheets from scratch. In the first stage, a sequence of chords and rhythm patterns is generated, and in the second stage the sequence of melody notes is generated conditioned on the output of the first stage. We conducted a subjective listening test of which the results showed that our approach outperformed the baselines. We can therefore conclude that conditioning helps the quality of the generated music, and that this approach can be explored further in the future.