Conditional LSTM-GAN for Melody Generation from Lyrics

TL;DR

This paper introduces a new deep generative model, Conditional LSTM-GAN, for melody creation from lyrics, supported by a large aligned lyrics-melody dataset, demonstrating effective and tuneful melody generation.

Contribution

It presents a novel lyrics-conditioned LSTM-GAN model and a large dataset for improved melody generation from lyrics.

Findings

Generated melodies are plausible and tuneful.

The model effectively learns lyrics-melody alignment.

The dataset facilitates future research in lyrics-to-melody synthesis.

Abstract

Melody generation from lyrics has been a challenging research issue in the field of artificial intelligence and music, which enables to learn and discover latent relationship between interesting lyrics and accompanying melody. Unfortunately, the limited availability of paired lyrics-melody dataset with alignment information has hindered the research progress. To address this problem, we create a large dataset consisting of 12,197 MIDI songs each with paired lyrics and melody alignment through leveraging different music sources where alignment relationship between syllables and music attributes is extracted. Most importantly, we propose a novel deep generative model, conditional Long Short-Term Memory - Generative Adversarial Network (LSTM-GAN) for melody generation from lyrics, which contains a deep LSTM generator and a deep LSTM discriminator both conditioned on lyrics. In particular, lyrics-conditioned melody and alignment relationship between syllables of given lyrics and notes of predicted melody are generated simultaneously. Experimental results have proved the effectiveness of our proposed lyrics-to-melody generative model, where plausible and tuneful sequences can be inferred from lyrics.

Tables

Table 1. TABLE I: Configuration of the generator and discriminator.

	RNN1 (generator)	RNN2 (discriminator)
Input	30 (random noise), 20 (syll. embedding)	3 (MIDI attributes), 20 (syll. embedding)
Layer 1	400, Fully-connected, ReLU	400, LSTM, tanh
Layer 2	400, LSTM, tanh	400, LSTM, tanh
Layer 3	400, LSTM, tanh	2 (real or fake), sigmoid
Output	3 (MIDI attributes), fully-connected, linear	N/A

Table 2. TABLE II: Relationship between note duration and note.

0.25	0.5	0.75	1	1.5	2	3	4	6	8	16	32
\Sech​​​​	\Acht​​​	\Acht\Pu	\Vier ​​​	\Vier\Pu​​​​​​	\Halb ​​​​​​	\Halb\Pu ​​​ ​​​	\Ganz ​​​​​​	\Ganz\Pu ​​​​​​	$2\times \text{Ganz}$	$4\times \text{Ganz}$	$8\times \text{Ganz}$

Table 3. TABLE III: Relationship between rest values and corresponding symbols.

0	1	2	4	8	16	32
No rest ​​	\ViPa ​​	\HaPa (half rest) ​​	\GaPa (whole rest)​​	$2\times \text{GaPa}$​​	$4\times \text{GaPa}$ ​​​	$8\times \text{GaPa}$

Table 4. TABLE IV: Configuration of MLE baseline.

	Generator
Input	20 (embedded syllable); 1 (melody-token representing triplet of music attributes)
Layer 1	32, Embedding Layer (for embedding a melody-token)
Layer 2	32, LSTM, tanh
Output	3397, fully-connected, log-softmax; 3 (predicted triplet of music attributes)

Table 5. TABLE V: In-songs attributes metrics evaluation.

	Ground truth	Conditional LSTM-GAN	MLE baseline	Random baseline
MIDI numbers span	10.8	7.7	14.2	18.1
3-MIDI numbers repetitions	3.8	2.9	2.2	0.4
2-MIDI numbers repetitions	7.4	7.7	5.9	2.3
Number of Unique MIDI	5.9	5.1	6.5	9.0
Number of notes without rest	15.6	16.7	15.4	15.6
Average rest value within song	0.8	0.6	0.8	0.8
Song length	43.3	39.2	43.4	43.6

Table 6. TABLE VI: BLEU scores for Random and MLE baseline methods and proposed conditional LSTM-GAN.

Scores	BLEU-2	BLEU-3	BLEU-4
Random baseline	0.499	0.157	0.036
MLE baseline	0.659	0331	0.137
Conditional LSTM-GAN	0.735	0.460	0.230

Equations

$$\sum _{i=1}^{|K|}{x}_{dur}^i+x_{rest}^i$$

$$\mathbf{y}={\text{E}}_w(w)||{\text{E}}_s(s)=\mathbf{w}||\mathbf{s}$$

$$i_t=\sigma (w_i[h_{t-1},x_t]+b_i)$$

$$f_t=\sigma (w_f[h_{t-1},x_t]+b_f)$$

$$o_t=\sigma (w_o[h_{t-1},x_t]+b_o)$$

$$h_t$$

$$c_t$$

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

$$\underset{G}{\min }\underset{D}{\max }V(D,G)$$

$$+{\mathbb{E}}_{\mathbf{z}\sim p_{\mathbf{z}}(\mathbf{z})}[\text{log}(1-D(G(\mathbf{z})))]$$

$$L_G=\frac{1}{m}\sum _{i=1}^m\text{log}(1-D(G({\mathbf{z}}^{(i)}|{\mathbf{y}}^{(i)})|{\mathbf{y}}^{(i)})).$$

$$L_D=\frac{1}{m}\sum _{i=1}^m[-\text{log}D({\mathbf{x}}^{(i)}|{\mathbf{y}}^{(i)})-\text{log}(1-D(G({\mathbf{z}}^{(i)}|{\mathbf{y}}^{(i)})|{\mathbf{y}}^{(i)}))].$$

$$x=\varphi (t\times \frac{\text{BPM}}{60})$$

$${\text{MMD}}_u^2$$

$$+\frac{1}{n(n-1)}\sum _{i=1}^n\sum _{j\ne i}^{n}k(y_i,y_j)-\frac{2}{mn}\sum _{i=1}^m\sum _{j=1}^{n}k(x_i,y_j).$$

$$\hat{l}=-\frac{1}{M\times N}\sum _{i=1}^M\sum _{j=1}^N\log p_{i,j}$$

Full text

I Introduction

Music generation is also referred to as music composition with the process of creating or writing an original piece of music, which is one of human creative activities [1]. Without understanding music rules and concepts well, creating pleasing sounds is impossible. To learn these kinds of rules and concepts such as mathematical relationships between notes, timing, and melody, the earliest study of various music computational techniques related to Artificial Intelligence (AI) has emerged for music composition in the middle of 1950s [2]. Markov models as a representative method of machine learning have been applied to algorithmic composition [3]. However, due to the limited availability of paired lyrics-melody dataset with alignment information, research progress of lyrics-conditioned music generation has been obstructed.

With the development of available lyrics and melody dataset and deep neural networks, musical knowledge mining between lyrics and melody has gradually become possible [4],[5]. Melody [6] is a sequence of musical notes over time, in which each note is sounded with a particular pitch and duration. Generating a melody from lyrics is to predict a melodic sequence when given lyrics as a condition. Existing works, e.g., Markov models [7], random forests[8], and recurrent neural network (RNN)[9], can generate lyrics-conditioned music melody. However, these methods cannot ensure that the distribution of generated data is consistent with that of real samples. Generative adversarial networks (GANs) proposed in [10] are a generative model which can generate data samples following a given distribution, and have achieved a great success in the generation of image, video, and text.

Inspired by the great success of GANs in various generative models in the area of computer vision and national language processing, we propose a conditional LSTM-GAN model to compose lyrics-conditioned melody where a discriminator can help to ensure that generated melodies have the same distribution as real ones. To the best of our knowledge, this is the first study that conditional LSTM-GAN is proposed for melody generation from lyrics, which takes lyrics as additional context to instruct deep LSTM-based generator network and deep LSTM-based discriminator network. Our proposed generation framework has several significant contributions, as follows:

i) A LSTM network is trained to learn a joint embedding in the syllable-level and word-level to capture syntactic structures of lyrics, which can represent semantic information of lyrics.

ii) A conditional LSTM-GAN is optimized to generate discrete-valued sequences of music data by introducing a quantizer.

iii) A large-scale paired lyrics-melody dataset with 12,197 MIDI songs is built to demonstrate that our proposed conditional LSTM-GAN can generate more pleasant and harmonious melody compared with baseline methods.

II Related works

Automatic music generation has experienced a significant change in computational techniques related to artificial intelligence and music [11], spanning from knowledge-based or rule-based methods to deep learning methods. The majority of traditional music generation methods are based on music knowledge representation, which is a natural way to solve the issue with some kind of composition rules [12]. Knowledge-based music rules are utilized to generate melodies when given the specified emotions by users [13]. Moreover, several statistical models [14] such as hidden Markov models, random walk, and stochastic sampling are discussed for music generation. For example, Jazz chord progressions are generated by Markov model for music generation in [15] and statistical models are applied to music composition in [16].

With rapid advancement of neural networks, deep learning has been extended to the field of music generation. A hierarchical RNN for melody generation is proposed in [17], which includes three LSTM subnetworks. Beat profile and bar profile are exploited to represent rhythm features at two different time scales respectively. A neural network architecture [18] is suggested to compose polyphonic music with a manner of preserving translation invariance of dataset. Motivated by convolution that can obtain transposition-invariance and generate joint probability distributions over a musical sequence, two extended versions, Tied-parallel LSTM-NADE and bi-axial LSTM, are proposed to achieve better performance. A continuous RNN with adversarial training (C-RNN-GAN) [19] is proposed to compose MIDI classical music. RNN is considered to model sequences of MIDI data during adversarial learning. The generator is to transform random noise to MIDI sequences, while the discriminator is to distinguish the generated MIDI sequence from real ones.

Earliest work [20] for lyrics-conditioned melody generation is defined as generating a melody when given Japanese lyrics, patterns of music rhythms, and harmony sequences. Some constraints are determined to associate syllables with notes. Melody generation is realized by dynamic programming. In [21] the rhythmic patterns occurred in notes can be classified. Pitches that are most suitable for accompanying the lyrics are generated using n-gram models. Three stylistic categories such as nursery rhymes, folk songs, and rock songs are generated for given lyrics. A recently proposed ALYSIA songwriting system [8] is a lyrics-conditioned melody generation system based on exploiting a random forest model, which can predict the pitch and rhythm of notes to determine the accompaniments for lyrics. When given Chinese lyrics, melody and exact alignment are predicted in a lyrics-conditional melody composition framework [9], which is an end-to-end neural network model including RNN-based lyrics encoder, RNN-based context melody encoder, and a hierarchical RNN decoder. The authors create large-scale Chinese language lyrics-melody dataset to evaluate the proposed learning model.

Our work focuses on lyrics-conditioned melody generation using LSTM-based conditional GAN, which is first proposed for tackling melody generation from lyrics. Distincting from the existing works, our generative model can ensure that the distribution of generated melody mimics that of real sample melodies. A skip-gram model is trained to transform raw textual lyrics into syllable embedding vector which is taken as input together with noise vector for training a deep generator model. A deep discriminator model is trained to distinguish generated MIDI note sequences from real ones. A large English language lyrics-melody dataset is built to validate the effectiveness of our proposed recurrent conditional GAN for lyrics-to-melody generation. Novel ideas are designed to evaluate melody generation, which is also very useful reference for measuring various generative models.

III Preliminaries

Before we describe our melody generation algorithm, a brief introduction is given in the following to help understanding musical knowledge, the sequential alignment relationship between lyrics and melody, and how to build the lyrics-melody music dataset.

III-A Melody

Melody and lyrics provide complementary information in understanding a song with the richness of human beings’ emotions, cultures, and activities. Melody, as a temporal sequence containing musical notes, plays an important role. A note contains two music attributes: pitch and duration. Pitches are perceptual properties of sounds that organize music by highness or lowness on a frequency-related scale, which can be played in patterns to create melodies [22]. Piano keys have MIDI numbers ranging from 21 to 108, which also represent the corresponding pitch numbers. For example, ‘D5’ and ‘A4’ can be respectively represented as 74 and 69 according to the mapping between notes and MIDI numbers. In music, duration [23] represents the length of time that a pitch or tone is sounded. Rests [24] are intervals of silence in pieces of music, marked by symbols indicating the length of the pause. If we treat a rest as a note with a special pitch value, it is hard to find a syllable paired with it. Therefore, to ensure one-syllable-to-one-note alignment, in this work, we take the “rest” as one of music attributes contained in a sequence of triplets.

III-B Lyrics

Lyrics as natural language represent music theme and story, which are a very important element for creating a meaningful impression of the music. An English syllable [25] is a unit of sound, which may be a word or a part of a word. According to timestamp information in MIDI files of music tracks, melodies and lyrics are synchronized together to parse the data and extract alignment information.

III-C Alignment

An English syllable [25] is a unit of sound, which may be a word or a part of a word. One syllable may correspond to one or more notes in English songs. Accordingly, the alignment between lyrics and melody could be a paired sequence of one-syllable-to-one-note or one-syllable-to-multiple-notes. Following the existing research such as [8] on melody generation from lyrics, currently we only exploit the pairs of one-syllable-to-one-note to train our conditional LSTM-GAN model for melody generation from lyrics, and investigate the pairs of one-syllable-to-multiple-notes in the future work. An example data structure of the alignment between lyrics and melodies is shown in Fig. 1. Lyrics are divided to syllables. Each column represents one syllable with its corresponding triplet of music attributes {note, duration, rest}. Accordingly, a lyrics sample can be associated with a sequence of {note, duration, rest} triplets. With these music attributes, sheet music can be produced.

IV Melody generation from lyrics

Our aim is to learn a deep model that is able to represent the distribution of real samples, which further has the capability of generating new samples from this estimated distribution. In particular, using the capability of deep learning and generative modeling, sequential alignment relationship can be learned between lyrics and melody from real musical samples. As the number of epochs increases, the learning goes deeper, and the distribution of generated samples is more consistent with the distribution of real samples. Our training data contains the sequential alignment relationship between syllables and notes, which can be learned by conditional LSTM-GAN. During the training, GAN actually can resemble the distribution of the training samples and LSTM can learn the sequential alignment relationship.

Our proposed conditional LSTM-GAN for lyrics-to-melody generation model is shown in Fig. 2, which is an end-to-end generative learning conditioned with lyrics. A sequence of syllable embedding vectors concatenated with noisy vectors is taken as input of the generator network. The generated MIDI sequences together with the sequence of syllable embedding vectors are taken as input of the discriminator network, which aims to train a model for distinguishing generated MIDI note sequences from real ones. In addition, a tuning scheme is introduced to quantize MIDI numbers so as to generate melody sequence with discrete attributes. Both the generator and discriminator are unidirectional RNN networks with the configuration shown in Table I.

IV-A Problem formulation

Taking lyrics as input, our goal is to predict a melody sequentially aligned with the lyrics, where MIDI numbers, note duration, and rest duration are synthesized with lyrics to generate a song. Our research problem can be formulated as follows: The syllables of lyrics as input are represented by a sequence $Y=(y^{1},\cdots,y^{|K|})$. The melody as output is a sequence $X=(x^{1},\cdots,x^{|K|})$, where MIDI numbers, note duration, and rest duration are simultaneously predicted as the $x^{i}={\{x_{MIDI}^{i},x_{dur}^{i},x_{rest}^{i}}\}$. Moreover, the time length of the output sequence

[TABLE]

determines the length of synthesized song with lyrics.

IV-B Lyrics embedding

As the vocabulary of our lyrics data is large without any labels, we need to train an unsupervised model that can learn the context of any word or syllable. Specifically, we utilize our lyrics data to train a skip-gram model, which enables us to obtain the vector representation that can encode linguistic regularities and patterns in the context of given lyrics.

Our method encodes lyrics information at two different semantic levels: syllable-level and word-level, and two skip-gram models are trained respectively, which aim at associating a vector representation with an English syllable. Specifically, lyrics of each song are divided into sentences, each sentence is divided into words, and each word is further divided into syllables. Words $W=\{w_{1},w_{2},w_{3},...,w_{n}\}$ are taken as tokens for training a word-level embedding model and syllables $S=\{s_{1},s_{2},...,s_{m}\}$ are taken as tokens for training a syllable-level embedding model. Then, we train each skip-gram model as a logistic regression with stochastic gradient decent as the optimizer, and the learning rate with an initial value 0.03 is gradually decayed every epoch until 0.0007. Context window spans 7 adjacent tokens and negative sampling distribution parameter is $\alpha=0.75$. We train the models to respectively obtain the word-level and syllable-level embedding vectors of dimensions $V={10}$.

Let $\text{E}_{w}(\cdot)$ and $\text{E}_{s}(\cdot)$ denote the word-level and syllable-level encoders respectively, and $s$ denote a syllable from word $w$. Then, syllable embedding and word embedding are concatenated as follows:

[TABLE]

where $\mathbf{s}=\text{E}_{s}(s)\in\mathbb{R}^{10}$ and $\mathbf{w}=\text{E}_{w}(w)\in\mathbb{R}^{10}$ are the embedding of syllable $s$ and word $w$, respectively. The dimension of the overall embedding is $V={20}$. Accordingly, lyrics sequences each with 20 syllables, each syllable being encoded in 20-dimension, are used in our experiment.

IV-C Condtional LSTM-GAN model

In our work, an end-to-end deep generative model is proposed for lyrics-conditioned melody generation. LSTM is trained to learn semantic meaning and relationships between lyrics and melody sequences. Conditional GAN is trained to predict melody when given lyrics as input based on considering music alignment relationship between lyrics and melody.

IV-C1 LSTM

LSTM [26] networks are an extension to RNNs, which not only contain internal memory but also have capability of learning longer dependencies. An LSTM cell has three gates: input, forget, and output. These gates decide whether or not allow new input in, forget old information, and affect output at current time-step. In particular, at time-step $t$, the three states of the gates in an LSTM cell are given by:

[TABLE]

[TABLE]

[TABLE]

where $i_{t}$, $f_{t}$ and $o_{t}$ denote the input, forget, and output gates states respectively, $h_{t-1}$ is the output of the LSTM cell at previous time-step, $w$’s and $b$’s are weights and biases, $x_{t}$ is the input of the LSTM cell, and $\sigma(\cdot)$ is the sigmoid function.

Then, the current output of the cell is computed by:

[TABLE]

where $\circ$ denotes the element-wise multiplication between vectors.

IV-C2 GAN

A GAN is proposed by Ian Goodfellow, et al. [10], which aims to train generative models by mitigating complex computation of approximating many probabilities. The general idea of GAN is to simultaneously train a generator $\text{G}(\cdot)$ and a discriminator $\text{D}(\cdot)$ with conflicting objectives. This method learns to predict new data with the same statistics as the training set. The generator $\text{G}(\cdot)$ tries to capture data distribution of training set. It takes an uniform noise vector $\mathbf{z}$ as an input and outputs a vector $\mathbf{\tilde{x}}=\text{G}(\mathbf{z})$. In an adversarial way, the discriminator $\text{D}(\cdot)$ tries to identify samples produced by the generator from real ones. That is to say, $\text{G}(\cdot)$ and $\text{D}(\cdot)$ play the following two-player minimax game:

[TABLE]

IV-C3 Lyrics-conditional GAN

Conditional GAN is proposed in [27], with the goal of instructing the generation process by conditioning the model with additional information, which motivates us to train a generative model for lyrics-conditioned melody generation. In this work, the generator and discriminator are conditioned on lyrics. The lyrics are encoded to a sequence of 20-dimensional embedding vectors.

The melody contains a sequence of music attributes $\mathbf{x}^{(i)}$, representing MIDI note, duration, and rest. Therefore, in the context of lyrics-conditioned melody generation, the input of the generator is the paired sequences of syllable embedding vectors $\mathbf{y}^{(i)}$ and uniform random vector $\mathbf{n}^{(i)}$ in $[0,1]^{k}$, where $k=30$. The generated music attributes, syllable embedding vectors $\mathbf{y}^{(i)}$, and real music attributes $\mathbf{x}^{(i)}$, are fed to the discriminator. $G(\mathbf{z}^{(i)}\lvert\mathbf{y}^{(i)})$ is a sequence of triplets containing attributes $\hat{x}^{i}={\{\hat{x}_{MIDI}^{i},\hat{x}_{dur}^{i},\hat{x}_{rest}^{i}}\}$. Both the generator and the discriminator contain LSTM cells. The loss functions in the following are implemented to jointly train the generator and discriminator, where $m$ is mini batch size.

[TABLE]

[TABLE]

IV-C4 Generator network in Fig.3

The generator is to learn the distribution of real samples, which is trained to increase the error rate of the discriminator. To learn a distribution over the data, the generator builds a mapping function from a prior noise distribution to the data space. By concatenating the syllable embedding and noise as input, GAN is expected to instruct the melody generation process (by lyrics) while generating diverse melodies (by random noise). In this work, each melody sequence has 20 notes, which needs 20 LSTM cells to learn the sequential alignment between lyrics and melody. The first layer in the generator network uses ReLU (rectified linear unit). When given a 50-dimensional vector concatenated by an encoded syllable $\mathbf{y}\in\mathbb{R}^{20}$ and an input random noise vector $\mathbf{n}\in\mathbb{R}^{30}$, the output of the first layer is scaled to a 400-dimensional vector to fit the number of internal hidden units of the LSTM cells. We tried different amounts of LSTM layers and found that 2 layers are sufficient in generator network for MIDI note generation. Then, the fourth linear layer produces a triplet of music attributes $\hat{x}^{i}={\{\hat{x}_{MIDI}^{i},\hat{x}_{dur}^{i},\hat{x}_{rest}^{i}}\}$.

The same LSTM cell is used for each syllable in the lyrics. The output with the triplet music attributes of previous LSTM cell is concatenated with current 20-dimensional syllable embedding, which are further fed to current LSTM cell. This procedure is repeated until the generator can succeed to fool the discriminator.

IV-C5 Discriminator network in Fig.4

The discriminator is to distinguish real melody samples from generated ones, which is trained by estimating the probability that a sample is from real training dataset rather than the generator. The discriminator loss function penalizes the discriminator for misestimating a real sample as fake or a fake sample as real. Because the input of the discriminator is a sequence, LSTM is also used here. Since lyrics as context information are used as condition in the discriminator, the generated triplet of music attributes concatenated with syllable embedding together as a 23-dimensional vector is input to the first LSTM cell in the discriminator. The hidden size of the LSTM cell in the discriminator is also 400. The output 400-dimensional vector from the second LSTM layer is input to the third linear layer, followed by a sigmoid activation function which estimates the decision output of real or fake by a value in the range $[0,1]$. With conditioning lyrics, the discriminator and generator are simultaneously learned until the training process converges.

IV-D Tuning scheme

The output from the generator is a continuous-valued sequence, which needs to be constrained to the underlying musical representation of discrete-valued MIDI attributes. Quantization of music attributes (MIDI number, note duration, and rest duration) are done during the generation in the experiments of validation and testing. Music attributes are constrained to their closest discrete values.

The concept of standard scales is important for the melody generation task. If a melody contains notes belonging to one of the standard scales, it indicates this melody has a perfect scale consistency. Below are three examples of standard scales 111https://en.wikipedia.org/wiki/Scale_(music):

• •

$\mathcal{C}_{major}=\{C,D,E,F,G,A,B\}$;

• •

$\mathcal{D}_{major}=\{D,E,F\sharp,G,A,B,C\sharp\}$;

• •

$\mathcal{D}_{natural\ minor}=\{D,E,F,G,A,B\flat,C\}$, where $B\flat$ is equivalent to $A\sharp$.

The quantized music attributes are estimated to see if each generated sequence has a perfect scale consistency of melody. In particular, the most likely standard scale of music attributes this sequence belongs to is generated from syllable embedding in validation and testing datasets. The remaining out-of-tune notes are mapped to their closest in-tune music attributes.

V Lyrics-melody data acquirement

There is no aligned lyrics-melody music dataset publicly available for music generation. In this work, a large-scale music dataset with sequential alignment between lyrics and melody is created to investigate the feasibility of this research with deep conditional LSTM-GAN. We acquire lyrics-melody paired data from two sources based on considering melodies with enough English lyrics, where 7,998 MIDI files come from the LMD-full MIDI Dataset [28] and 4,199 MIDI files come from the reddit MIDI dataset [29]. Altogether there are 12,197 MIDI files in the dataset, which contain 789.34 hours of melodies. The average length of melodies is 3.88 minutes. This dataset is available on Github 222https://github.com/yy1lab/Lyrics-Conditioned-Neural-Melody-Generation.

V-1 Data selection

In our experiment, 20,934 unique syllables and 20,268 unique words from the LMD-full MIDI and reddit MIDI dataset are used for training a skip-gram model to extract embedding vectors of lyrics. As for training the LSTM-GAN model, only paired lyrics-melody sequences in the LMD-full dataset are used. In particular, if a MIDI file has more than 20 notes but less than 40 notes, one 20-note sequence is taken as our data sample; if a MIDI file has more than 40 notes, two 20-note sequences are taken as our data samples. Accordingly, 13,251 sequences each with 20 notes and 265,020 syllable-note pairs are acquired, which are used for training, validation, and testing.

V-2 Parsing MIDI file

Triplets of music attributes with {MIDI Number, note duration, rest duration} are obtained by parsing each MIDI file from the LMD-full dataset which contains English lyrics. The parsing is made as follows:

• •

The beats-per-minute (BPM) value for each MIDI file is extracted.

• •

If a note has a corresponding English syllable, its MIDI Number is extracted. This value is taken as the first of music attributes in our melody representation.

• •

If a note has a corresponding English syllable, its note-on and note-off values are stored.

• •

From the note-on and note-off values, the note duration and rest duration attributes are calculated, using the formula

[TABLE]

where $x$ is an attribute of note $k$ (either note duration or rest duration), $t$ is a time in seconds ($t=\text{note-off}_{\text{k}}-\text{note-on}_{\text{k}}$ to calculate note duration and $t=\text{note-on}_{\text{k}}-\text{note-off}_{\text{k-1}}$ to calculate rest duration) and $\phi(\cdot)$ is an operator which constrains the value to the closest value in the set of values used to represent the corresponding attribute.

V-3 Note duration

A note duration means the length of time that a note is played. Note durations frequently appearing in our dataset have been shown in Fig.5, and are summarized in Table II. When we discretize note lengths of the generated melody, only note durations in Table II are considered. In the future, we will try to collect more lyrics which include other note durations.

V-4 Rest

A rest means how long the silence in a piece of melody will last. The rest values and corresponding rest symbols are shown in Table III.

V-5 Distribution of music attributes

The distribution of each attribute in our music dataset is respectively shown in Fig. 5, which indicates that most MIDI note numbers range from 60 to 80, quarter note is most frequently played, and $rest=0$ appeared in most cases of melodies.

VI Evaluation

In this section, experimental setup, validation method, and experimental results are introduced to investigate the feasibility of our proposed conditional LSTM-GAN model.

VI-A Experimental setup

The entire dataset is split with a 0.8/0.1/0.1 proportion between training, validation and testing sets. The model is trained using mini-batch gradient descent for a total of 400 epochs. The learning rate starts at a value of $0.1$, and gradually decreases.

During both validation and testing stages, the sequences of triplet continuous-valued attributes are first constrained to their closest discrete value. The candidate values for the MIDI Numbers are in the range $\{21,\dots,108\}$. In addition, the quantized sequence is checked to see if it belongs to most likely scale, where the MIDI number of the out-of-tune notes is changed to the closest MIDI number in the most likely scale.

VI-B Validation using MMD

The validation is made using a Maximum Mean Discrepancy (MMD) [30] unbiased estimator. Giving two sets of samples, MMD2 takes a value between 0 and 1, indicating how likely the two sets of samples are coming from the same distribution (a value of 0 indicates that the two sets are sampled from the same distribution). Here, a melody sequence of notes is regarded as a set. At the end of each training epoch, the MMD between the generated sequences and the validation sequences is calculated. The weights and biases from the model corresponding to the lowest MMD value are selected.

Let $X_{m}:=\{x_{1},\dots,x_{m}\}$ and $Y_{n}:=\{y_{1},\dots,y_{n}\}$ be two sets of independently and identically distributed (i.i.d) samples from $P_{x}$ and $P_{y}$ respectively. Then, an unbiased empirical estimate of MMD2 is given by [31]:

[TABLE]

where $\mathcal{F}$ is a reproducing kernel Hilbert space (RKHS), with the kernel function $k(x,x^{\prime}):=\langle\phi(x),\phi(x^{\prime})\rangle$, and continuous feature mapping $\phi(x)\in\mathcal{F}$ for each $x$. We used $k(x,x^{\prime})=\text{exp}(-\|x-x^{\prime}\|^{2}/(2\sigma^{2}))$ as the kernel function, with kernel bandwidth $\sigma$ set such that $\|x-y\|/(2\sigma^{2})$ equals 1 when the distance between $x$ and $y$ is the mean distance between points from both datasets $X_{m}$ and $Y_{n}$ [32].

VI-C Comparison methods

The Random baseline model for the following experiments is inspired by [33]. Melodies of 20 notes are created by randomly sampling the testing set based on the dataset distribution for music attributes (i.e. the distribution shown in Fig. 5). Sequences generated by the baseline model are also judged to see if out-of-tune MIDI number needs to be changed. The MIDI numbers are restricted in the set $\{60,\dots,80\}$, meaning that if a MIDI number lower than 60 is sampled from the MIDI numbers distribution, then it takes a value of 60, and similarly a MIDI number higher than 80 is set to 80.

Besides the Random baseline model, we also use a stronger baseline model trained with the Maximum Likelihood Estimation (MLE) objective which exploits a single-layered LSTM network [34] as the generator. We refer to it as the MLE baseline model in our experiments. This MLE baseline is trained by mini-batch gradient descent over the gradient of a log-maximum likelihood estimator as follows:

[TABLE]

where $M$ is the batch size, $N$ is the sequence length, and $p_{i,j}$ is the estimated probability (i.e. output of the softmax function) with which the $i,j$-th generated note is the same as the $i,j$-th note from the batch taken from the training set. MLE with a single LSTM layer is selected as the baseline according to our experimental results. The configuration for the MLE baseline model is shown in Table IV.

VI-D Training stage analysis

The MIDI note number, spectrum, and relative amplitude of generated songs are investigated at 1, 51, and 351 epochs as shown in Fig. 6. The corresponding sheet score with alignment between lyrics and melodies at 1, 51, and 351 epochs are shown in Fig. 7. It is obvious that the generated melody gets better when the learning goes deeper by increasing the number of epochs. Additionally, we ask volunteers to listen to the generated songs at different epochs. Their feedback also confirms the effectiveness of our deep conditional LSTM-GAN.

VI-E Music quantitative evaluation

In order to investigate if lyrics-conditioned LSTM-GAN can generate melodies that resemble the distribution of training samples, some quantitative measurements are designed to compare the melodies generated by our proposed model, the Random baseline, and MLE baseline, which are shown in the following:

• •

MIDI numbers span: the difference between the highest MIDI number and the lowest one of a sequence.

• •

3-MIDI-number repetitions: the sum of the “count of each distinct 3-MIDI occurrence minus 1” (a melody slice consisting of 3 adjacent notes) throughout the sequence, which is a metric similar to the one used in previous work [19].

• •

2-MIDI-number repetitions: the sum of the “count of each distinct 2-MIDI occurrence minus 1” throughout a sequence.

• •

Number of unique MIDI numbers: a count of how many different MIDI numbers are present in a sequence.

• •

Number of notes without rest: a count of how many rest duration have a value of 0 throughout a sequence.

• •

Average rest value within a song: an average value of the rest duration attribute.

• •

Song length: the sum of all the note duration attributes and all the rest duration attributes of a sequence.

Figure 8 demonstrates the evolution of each of these values averaged over 1,051 generated sequences (one sequence per testing set lyrics).

For pitch-related attributes, the proposed model outperforms the baseline in every aspect and outperforms MLE in most aspects. The proposed model tends to converge to a value which is relatively close to the ground truth (i.e. the average value from the dataset). However, the 2-MIDI numbers and 3-MIDI numbers repetitions converge to values which are significantly lower than the corresponding measurement over the dataset, but is still much better than that of MLE baseline.

For metrics which are related to temporal attributes (i.e. note duration and rest duration), the baselines are closer to the ground truth value. This is expected, since these metrics are nothing but an average of attributes which the baseline samples from the ground truth distribution. Hence, these values tend to the ground truth value as the number of generated examples increases. Table V shows the numerical values of the results.

We also investigated scale-consistency of generated melodies. The mean accuracy of scale-consistency for the conditional LSTM-GAN model is 48.6%. In contrast, for the MLE baseline and Random baseline models, it is 47.3% and 46.6% respectively. The mean accuracy of scale-consistency is not high due to two main reasons: i) the mapping between lyrics and melody is not unique, i.e., for a given lyrics there can be multiple melodies belonging to different standard scales. ii) some notes overlap between different standard scales, e.g., D,E,F,G,A appear in both $\mathcal{C}_{major}$ and $\mathcal{D}_{natural\ minor}$.

Another important attribute in music is the distribution of the transitions between MIDI numbers. Figure 9 shows the distributions of the transitions for the melodies generated by our model, the MLE and Random baseline models and the testing set. The melody generated by the proposed model approximates well the distribution of the human composed music. Although the testing set melody has a slightly higher transition from a note to a lower-pitched one, the melody generated by our model has more transitions from a note to a higher-pitched one.

To compare the qualities of generated melodies, standard BLEU scores as evaluation metrics 333https://en.wikipedia.org/wiki/BLEU for conditional LSTM-GAN, MLE baseline, and Random baseline are respectively calculated, which are shown in Table VI. From this table, we can find that our conditional LSTM-GAN model achieves the highest BLEU scores compared with the other two baseline methods. This also concludes that our method can generate melodies of relatively higher qualities.

VI-F Effect of lyrics conditioning

VI-F1 Distribution of MIDI numbers

The experiments show that the proposed LSTM-GAN model without conditioning on lyrics leads to a model which generates a narrower-band distribution of MIDI number as shown in Fig. 10. Here are the MIDI number distributions, which are smoothed by using kernel density estimation. It is obvious in Fig. 11 that the estimated distribution of generated MIDI numbers conditioned on lyrics is more consistent with the distribution of ground truth MIDI numbers.

An example of the influence of lyrics on the generated MIDI numbers is shown in Fig. 12. Given two kinds of lyrics, 1,000 songs are generated for each lyrics, and the distribution of the generated MIDI numbers is estimated. In our example, the second lyrics leads to songs with lower MIDI numbers than the first one, which helps to deliver some semantic information latent in the lyrics.

VI-F2 Note duration and rest duration

In this experiment, an evaluation method to seeing if the lyrics conditioning has an effect on the generated note duration and rest duration is presented. The following focuses on note duration attribute, but the same is valid for rest duration as well.

Let $D\in\mathbb{R}^{N\times M}$ be a matrix composed of N note duration (or note rest) sequences of M note durations, where each sequence is taken from a different song from a N songs dataset used to train a generator G. Therefore, $D_{i,j}$ is the $j$-th note duration of the $i$-th song. Let $G\in\mathbb{R}^{N\times M}$ be a matrix composed of note duration sequences generated by G by feeding the syllables sequences corresponding to each row of $D$. This means that $G_{i,j}$ is the $j$-th note duration of the sequence generated by G when the syllables corresponding to $\mathbf{d}_{i}$ are fed to it, where $\mathbf{d}_{i}$ denotes the $i$-th row of $D$.

Let $\text{randrow}(\cdot)$ be an operator which randomizes the order of the row of a matrix. Therefore $D_{\text{rs}}=\text{randrow}(D)$ can be seen as a matrix with correct in-sequence note duration order, but wrong song order when compared to $D$. D_{\text{rn}}=\big{(}\text{randrow}(D^{T})\big{)}^{T} can be seen as a matrix for which the song order is the same as $D$’s, but the note duration sequences are randomized. Finally, $D_{\text{rns}}=\text{randrow}(D_{\text{rn}})$ can be seen as a matrix in which both the song and note order are randomized when compared to $D$. The subscripts ${}_{\text{rs}}$, ${}_{\text{rn}}$ and ${}_{\text{rns}}$ denote “random songs”, “random notes”, and “random notes + songs” respectively. Since $\text{randrow}(\cdot)$ is a random operator, $D_{\text{rs}}$, $D_{\text{rn}}$, $D_{\text{rns}}$ are matrices of random variables (random matrices).

In this experiment, $d=\frac{1}{NM}\|D-G\|_{F}$ (which is a real value) is compared to the distribution of the random variables $d_{\text{rs}}=\frac{1}{NM}\|D_{\text{rs}}-G\|_{F}$, $d_{\text{rn}}=\frac{1}{NM}\|D_{\text{rn}}-G\|_{F}$ and $d_{\text{rns}}=\frac{1}{NM}\|D_{\text{rns}}-G\|_{F}$, with $N=1,051$ (number of songs in testing set) and $M=20$. The experiment is made on the testing set.

Results are shown in Fig. 13 (note duration), and Fig. 14 (rest duration). The three distributions are estimated using 10,000 samples for each random variable. In each case, $d$ is statistically lower than the mean value, indicating $G$ learned useful correlation between syllable embeddings and note/rest durations.

VI-G Subjective evaluation

4 different lyrics are randomly selected from the ground truth dataset. Accordingly, 16 melodies are obtained by using Random baseline, MLE baseline, our model, and ground truth. These melodies can be downloaded from the link 444https://drive.google.com/file/d/1ugOwfBsURax1VQ4jHmI8P3ldE5xdDj0l/view?usp=sharing.

All melodies are sung by a female voice produced by synthesizer V [35]. 4 male and 3 female subjects without knowing our research and any musical knowledge were invited to listen to these 16 melodies, where each melody with around 20 seconds is played 2 times in a random order. Three questions as metrics are used for evaluation: how about the entire melody? how about the rhythm? and does the melody fit the lyrics well? The subjects are asked to give a score from 1 to 5 (where 1 corresponds to “very bad”, 2 to “bad”, 3 to “OK”, 4 to “good” and 5 to “very good”).

The first run is taken to enable subjects to get used to the type of melodies they were listening to. The scores of evaluation metrics are respectively averaged based on listening results of Random baseline, MLE baseline, our model, and ground truth on the second run.

Evaluation results are shown in Figure 15. It is obvious that the melodies generated by the proposed model are closer to the ones composed by humans than the baseline in each metric. This also verifies the proposed conditional LSTM-GAN can predict the plausible sequential alignment relationship between syllables and notes. The feedback from subjects indicates that relatively low scores of melody evaluation are generated which might be due to the limited capability of the synthesizer for high pitches. From these results of all three metrics, we also can find there still are the gaps between melodies generated by our model and ones from human composition, which tells us there is much space we can investigate to improve capability of neural melody generation.

VII Conclusion and future work

Melody generation from lyrics in music and AI is still unexplored well. Making use of deep learning techniques for melody generation is a very interesting research area, with the aim of understanding music creative activities of human. Several contributions are done in this work: i) the largest paired English lyrics-melody dataset is built to facilitate the learning of alignment relationship between lyrics and melody. This dataset is very useful for the area of melody generation. ii) a skip-gram model is trained to exact lyrics embedding vectors, which can be taken as a lyrics2vec model for English lyrics feature extraction. iii) Conditional LSTM-GAN is proposed to model sequential alignment relationship between lyrics and melody, followed by a tuning scheme that has the capability of constraining a continuous-valued sequence to the closest in-tune discrete-valued sequence. iv) Evaluation method of melody generation is suggested to demonstrate the effectiveness of our proposed deep generative model.

The continuous-valued sequence generated by the generator needs to be constrained to the underlying musical representation of discrete-valued MIDI attributes. Due to the quantization error, the generated note could be associated to an improper duration, which would destroy the rhythm. But this probability could be low after applying LSTM in the melody generation. In the future, we plan to apply Gumbel-Softmax relaxation technique [36] to train a lyrics-conditioned LSTM-GAN for the discrete generation of music attributes.

In addition, several interesting future works will be investigated as follow: i) How to compose a melody with the sketch of uncomplete lyrics, ii) how to compose a polyphonic melody with lyrics, and iii) how to predict lyrics when given a melody as a condition.