het leren van hiërarchieën van tijdsschalen met diepe recurrente neurale netwerken

het leren van hiërarchieën van tijdsschalen met diepe recurrente neurale netwerken Brecht Coghe

Promotor: prof. dr. ir. Benjamin Schrauwen Begeleiders: dr. ir. Michiel Hermans, Philémon Brakel Masterproef ingediend tot het behalen van de academische graad van Master of Science in Engineering Physics

Vakgroep Elektronica en Informatiesystemen Voorzitter: prof. dr. ir. Jan Van Campenhout Faculteit Ingenieurswetenschappen en Architectuur Academiejaar 2013-2014

het leren van hiërarchieën van tijdsschalen met diepe recurrente neurale netwerken Brecht Coghe

Promotor: prof. dr. ir. Benjamin Schrauwen Begeleiders: dr. ir. Michiel Hermans, Philémon Brakel Masterproef ingediend tot het behalen van de academische graad van Master of Science in Engineering Physics

Vakgroep Elektronica en Informatiesystemen Voorzitter: prof. dr. ir. Jan Van Campenhout Faculteit Ingenieurswetenschappen en Architectuur Academiejaar 2013-2014

Voorwoord

Bij het maken van deze thesis heb ik veel bijgeleerd over neurale netwerken en machinaal leren in het algemeen en is mijn interesse voor dit onderwerp sterk gegroeid. De thesis wordt ingediend om de Master in Physical Engineering te behalen. Bij dit werk werd ik ondersteund door de vakgroep ELIS - reservoir lab, UGENT. Bij deze wil ik graag hun medewerkers bedanken:

Dr. Ir. Michiel HERMANS voor het begeleiden bij de taken, de vele bijkomende uitleg en het helpen zoeken naar oplossingen voor problemen.

Prof. Dr. Ir. Benjamin SCHRAUWEN voor het promoten van deze thesis en voor het gebruik van de middelen van reservoir lab.

”De auteur geeft de toelating deze masterproef voor consultatie beschikbaar te stellen en delen van de masterproef te kopiren voor persoonlijk gebruik. Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder met betrekking tot de verplichting de bron uitdrukkelijk te vermelden bij het aanhalen van resultaten uit deze masterproef.”

Brecht Coghe, 11 juni 2014

Het leren van hi¨ erarchie¨ en van tijdsschalen met diepe recurrente neurale netwerken door Brecht COGHE Thesis ingediend tot het behalen van de academische graad van master in Physical Engineering Academiejaar 2013–2014 Promotor: Prof. Dr. Ir. B. SCHRAUWEN Thesisbegeleider: Dr. Ir. M. HERMANS Faculteit Ingenieurswetenschappen Universiteit Gent Vakgroep ELIS-reservoir lab

Samenvatting Een onderdeel van het gebied machinaal leren is neurale netwerken. Deze thesis onderzoekt in het bijzonder de combinatie van een diep en een recurrent neuraal netwerk als ’nieuwe’ architectuur. Aan de hand van twee taken worden de voordelen en nadelen van zo’n diep recurrent neuraal netwerk bekeken. De eerste taak situeert zich in de spraaktechnologie. Er wordt gebruik gemaakt van de TIMIT-dataset. De tweede taak werkt met symbolische muziek (MIDI) en gebruikt een eigen dataset.

Trefwoorden Deep Recurrent Neural Networks TIMIT MIDI

Learning temporal hierarchies with deep recurrent neural networks Brecht Coghe Supervisor(s): Dr. Michiel Hermans, Prof. Benjamin Schrauwen Abstract— In this article we explain Deep Recurrent Neural Networks (DRNNs) and how to train them. The DRNNs are a combination of the commonly used Recurrent Neural Networks and the Deep Neural networks. We hope to show that the deeper version of the Recurrent Neural Network can cope with more complex data and the different layers show a hierarchy in time, corresponding with the layers in a deep neural network who can learn a hierarchy in the data. To do this we use the TIMIT speech recognition dataset and a self-made music dataset in MIDI-format. Keywords— Deep recurrent neural networks, TIMIT, artificial music generation

output is calculated as: y = g(A h)

(2)

Here the output weights ai are compiled in one matrix A. The same goes for the activations of the different neurons, this vector is called h. The output-function g is chosen in respect to the task. A neural network is trained by changing its weights to produce an output y that is as close to the target t as possible.

I. I NTRODUCTION EURAL Networks are an important part of machine learning. Machine learning is the subject of letting a computer learn by itself from data. Some examples are Computer vision, speech recognition, brain-computer interfaces, sentiment analysis etc [1][2][3][4]. The object in machine learning is to generalise from the data, in other words, the trained program should be able to process unseen data. A Neural network is a composition of different artificial neurons. These neurons are a strong abstraction of the neurons in our brains. One can be seen at Figure 1. To learn from data, they use a supervised training method. They get input vectors x and the target outputs t to learn by example. If sufficient data is given the neural network is able to make a model for the task at hand.

N

Fig. 2. Single-layered Neural Network

Two variations to this single-layered NN are the Deep NN (Figure 3) and the recurrent NN. A Deep NN consists of different layers of neurons stacked onto each other. These layers are connected to each other with their own weight matrices Vi and one layer uses the activations of the preceding layer as inputs. This deep structure provides a more hierarchical structure and makes it possible to model more complex data. These deep networks have made an improvement possible in different applications, such as image processing, classification and speech recognition [5].

Fig. 1. Schematic presentation of an artificial neuron

An artificial neuron has an activation value h calculated as: h = f(

N X

vi xi )

(1)

i=1

Where the vi are the so called weights and the function f is an activation function. In what follows we use the tanh-function. The simplest Neural Network consists of one layer of hidden neurons as can be seen in Figure 2. The hidden layer of neurons produces an output in an analogue way as the neurons. The Master student applied physics, Ghent University (UGent), Gent, Belgium.

Fig. 3. Deep Neural Network

One problem with the Deep NN is to cope with sequential data. In a sequence there is a certain causality. The current data point depends on the ones coming before that. But it’s not always that

easy to see how long this dependency should be. Therefore, it is difficult to find the amount of data points one should use as input in the deep NN to make use of this causal dependency. A recurrent NN tackles this problem in a different way. In its architecture there is an implicit context as can be seen in Figure 4. Every timestep is made up of the same single-layered neural network and these are connected in time by the so-called Recurrent Weights W . These recurrent connections carry the history of all preceding timesteps. The activations on timestep t are now calculated as: h(t) = tanh(V x(t) + W h(t−1) )

weight matrices V , W and A in every timestep. These are averaged and are then used to upgrade the weight matrices.

(3)

and thus depend on the activation of the neural layer one step back in time.

Fig. 5. Schematic of BPTT: The error in red is propagated back through the network and back in time.

II. D EEP R ECURRENT NN S Fig. 4. Simplified schematic of a RNN. Every circle presents a complete layer. Blue are inputs, black are hidden neuron layers and green is an output layer.

To train a simple or deep neural network, we use gradient descent. With each iteration we want to change the weights in the direction of a decreasing cost-function. The cost-function E is a measure for the difference between the generated output y of the networks and the given targets t. The gradient of this function with respect to the weights gives us the direction in which to step to decrease it. The update equation thus becomes: W (t+1) ← W (t) − η ∇E(W (t) )

(4)

Where W stands for all the weight matrices and η is the learning speed. To calculate this gradient, we use the backpropagation algorithm. Briefly it can be explained as followed: We generate a graph from the schematic of the NNs. Every layer is a node and every weight matrix forms a connection between nodes. Then the error at the output is being calculated as y − t. This error can be propagated back through the network by multiplying it with the transposed weight matrix of that connection. In this way, an error can be calculated in every node. If two connections reach a node, these errors have to be added before propagating further back. Once all nodes have their errors calculated, the gradient of a weight matrix can be calculated as the outer product between the input of the connection and the error at the end of it. For a more formal derivation we refer to [6]. A recurrent network can be trained in a simular way. If we unfold it in time, we can see that the recurrent NN can be seen as a deep NN and thus we can use the Backpropagation Through Time (BPTT) algorithm here which is mainly the same as before. Note that here the error should also be backpropagated through the recurrent connections. BPTT is schematicly depicted in Figure 5. In this way we calculate a gradient for the

Even though the Recurrent NN made some nice improvements on some tasks, it still has some shortcomings. First of all, in one timestep, the input goes through only one layer to reach the output. Some data will thus be to complex to get a good model off, as one layer won’t be able to cope with this data. A second problem is that a hierarchy isn’t explicitly inherent in the network architecture. Some tasks will, though, require a temporal hierarchy to be dealt with. These problems make it clear to us that we need to make the recurrent NN deeper. To do that, we stack several recurrent layers onto each other as in Figure 6 . By doing this, we make the network deeper in space. There are now more layers between the input and the output.

Fig. 6. Schematic of a deep recurrent network with three layers.

The shortcomings (and solutions for them) of a Recurrent NN have already been proposed by some people. One way to get a higher context is proposed in [7]. They combine a recurrent NN with LSTM or long-short term memory[8]. These are special memory blocks who can be trained to remember activations or data from far away in time. They are explicitly present in the architecture. They also stacked these LSTM-RNN layers on top of each other to make a LSTM-DRNN. These are then used

on the TIMIT speech recognition database to get state-of-the-art performances, but there is room for a better analysis of these networks. In [9], the same networks are used but now to generate handwriting and do text prediction. Again these networks perform very well. In [10] different architectures are proposed and tested to make a Recurrent NN deeper. Again, state-of-the-art performances are achieved, this time in music prediction and language modelling. In [11] the DRNNs we use are introduced and applied on a wikipedia dataset to do text prediction. With a far simpler training algorithm, it still achieves better performances than a so-called mRNN (up till then the best RNN performance on this task) that is trained with a second order training algorithm. Furthermore an analysis has been carried out to look at the functionality of the different layers. One can see that closing brackets (which happens on a different time scale than the usual text prediction), is accounted for by the highest layer in the network. Which is a promising result. The objective of this thesis would thus be to show that more layers equal a higher performance of the tasks and to analyse what caused this. Furthermore, we like to investigate if a higher layer also takes into account a longer timeframe. The calculations to generate an output with the DRNN are not much more complicated than with a normal RNN. To be clear, we’ll go over it briefly. With every time step, there are now different input, recurrent and output weight matrices as can be seen in Figure 7. The activations of the neuron layers can now be calculated as: (t+1)

hj

(t)

(t+1)

= f (Wj hj + Vj h(j−1) )

(5)

where the upper indices are time indices and the lower indices indicate the layers. The output is now generated by the sum of all connections to the output: X (t) y (t) = g( Aj hj ) (6) j

To train the network we can still use the stochastic gradient descent method with backpropagation through time. Notice that every neuron layer also gets an error propagated from the output directly, that should be added with the other errors. III. TIMIT

Fig. 7. A three-layered DRNN zoomed in on one timestep. Note that in every neural layer there should arrive connections too. As they would have the same weight matrices Wi they are not drawn.

weight matrices have to be searched here. To get the best metaparameters we sweep over a validation set of about 10% of the training data. This data isn’t used to train on first, but is used to see how well the DRNN with certain metaparameters performs on unseen data. The metaparametes that perform best on this validation set are chosen and the network is trained again on the complete training data (including the validation set). B. Results To compare DRNNs with a different amount of layers, we need to find an honest way to do it. Here, we have chosen to use the same amount of weight parameters (amount of all elements of the weight matrices). In the TIMIT application we used about 400000. This gives the following amount of neurons per layer for the different DRNNs: Amount of layers Neurons per layer

1 600

2 348

3 269

4 227

5 200

The first application we tested our DRNN on is the speech recognition dataset TIMIT [12]. The dataset contains about one million training samples which are 39-dimensional. The targets are phonemes and are manually labeled, also 39-dimensional. We now want our DRNN to classify our inputs. Therefore we calculate the output with the softmax as an output function. This gives us the probability of belonging to the k th class. We choose the class with the highest probability and compare it with the targets. The error rate we use is the ratio of the amount of missclassified phonemes on the total amount of classified phonemes.

As 1M datapoints is to many to calculate all at once, we use a batch containing 50 randomly chosen datapoints per iteration (this is stochastic gradient descent). We also need to use the same metaparameters for all the DRNNs so they don’t influence the results relative to each other: The learning speed is set at 0.1 and let it decrease to zero lineary over all iterations, we use 1.5M iterations, we choose the initialisation of the input weights randomly out of a normal distribution between −0.005 en 0.005, the recurrent weights are initialised in the same way, but now we take a normal distribution between -1 and 1 divided by the square root of the amount of neurons in the layers. The output weights are set to 0 to start the learning proces.

To train our DRNN we need to search the best metaparameters. They can influence the performance of the network. Learning speed, the amount of iterations and the initialisation of the

After training the networks, we save them and use them to find the performance on the given test set. The results are shown below:

A. Training

Amount of layers Testerror

1 0.285

2 0.281

3 0.279

4 0.276

5 0.275

We see that the results fit our objective. Indeed, the testerror goes down with an increasing amount of layers. To analyse what made this possible, we want to make an estimation of the context that each layer harnasses. To do this, we will again use a training method. But this time we use the trained DRNN with 5 layers and we train a desired input for a certain target. The same way as we used the backpropagation algorithm, we can calculate the error on the input and change the input accordingly. The error propagated through the network consists only of the error in the current timestep. As we want a desired input for the target at time t, the errors past in time don’t matter. We depicted this method in Figure 8. Note that to make a distinction between each layer, we propagate the error from the output only to the layer that is being analysed and not to all layers.

Fig. 9. Estimated context for different layers: We see a longer context in higher layers

the other layers. The analysis of the DRNNs with a different amount of layers, trained on the TIMIT-dataset meets thus our objectives.

Fig. 8. Training of the desired input follows three steps: 1) The error of the current timestep(node on the right) is being propagated back from the output to the analysed layer (here the second layer) (upper side). 2) The error is being propagated to the input (bottom side). 3) The input is being updated and the process repeats itself

Fig. 10. Targetphoneme 8. From left-upper side to right-bottom side: A real input, Desired input from layer 1 to 5.

IV. M USIC MODELLING A. training

We did this training proces with a learning speed of 0.1 and used 1000 iterations. The input is initialised at a random training data sequence. Ridge regression is used to be sure the data back in time that doesn’t matter, is set to zero after training. The resulting desired inputs are averaged over different targets and are normalised to 1. That way we can see the relative differences. Results of this estimation of the context is seen in Figure 9. The results are promising, we observe that the desired input is bigger back in time for the higher layers. This gives us the estimation that the context of this layer would also be bigger. And thus the analysis of this application is positive. As a last experiment we can have a look at the difference in desired input for each layer. The absolute values of the of the desired input are shown in figure 10. It’s also noteable in this Figure how the desired input of the fifth layer is larger back in time than in

The next application for our DRNNs is music modelling. Some nice results have already been obtained useing LSTMs in combination with RNN [13][14]. But we want the time dependency to be modelled implicitly in our network. Not with some special memory blocks. To do that, we made our own dataset consisting out of 106 classical piano works in MIDI-format. MIDI-format tells us when a note is on/off. So to produce a proper input for these files we made a time roster with 25 steps per second. When a note is on at the current timestep, it gets value 1 in its row. When a note is off, it gets value zero. We repeated this proces each 0.04 seconds. A smaller sample rate would mean a loss of information, as the spaces between the same note being on can be very small, and they would be modelled as one long note instead of two short ones. The targets here are the input of the next timestep. In this way

we want to make a predictive neural network. Some little adjustments have to be made to the training in comparison with the TIMIT application. First of all, several notes can be played at the same time. Therefore, the softmax output function isn’t appropiate anymore because it favors one class in particular. To tackle this problem, we use a sigmoid output function for every channel (=note). The output then is a probability for every note seperatly that it is on or off. The same goes for the performance rate. As error we use the cross-entropy error, this is a measure to see how well the generated output probabilities overlap with the targets. Again, by sweeping the metaparameters over a validation set (10 % of the training data), we gain the settings to train the DRNNs to best performance. The learning speed is chosen as 0.5 and decreases to zero over 20000 iterations. We initialised the recurrent weights the same way as we did in the TIMIT-application. The input weights are initialised by taking random numbers in [0.1;0.1] and the output weights by random numbers in [-2;2]. If we start by setting the output weights at 0, we notice that we get the same probability for all notes on all times which is far from the ideal training. As size of the batch on which is trained every iteration we chose 500 timesteps (20 seconds). This is rather large, but to learn rythm out of music we deem this necessary.

Fig. 11. Relative desired inputs

longest. But it’s only 30 timesteps, which is 1.2 seconds. That’s not nearly enough to predict rythms in music. If we compare the output of the network to the targets we see that the output lags behind one timestep to the targets(f.e. Figure 12). The network thus didn’t learn to predict rhythms but seems to copy the last timestep. We didn’t succeed in learning the DRNN the right context to make changes in notes on to off on the right times.

B. results To compare DRNNs with a different amount of layers we again, choose to take the same amount of total weight parameters. In this case there are about 167000. This corresponds to the following amount of neurons N per layer: Amount of layers Neurons per layer

1 300

2 180

3 138

4 115

5 100

In the following table, we see the validation cross-entropy errors. We again notice an improvement in performance. The error goes from 0.039 for a one-layered DRNN to 0.023 for a five-layered DRNN. A positive result which again shows us the power of these DRNNs. Note, though, that the forth and fifth layers don’t improve the error as much as the addition of the first two. Amount of layers Validation error

1 0.039

2 0.027

3 0.025

4 0.024

Fig. 12. Comparison between output probabilities and targets

5 0.023 Even by training the network with a different error, the results stay the same. The different error used here had to focus on the To analyse where this improvement comes from, we calculate changes between note on and off. In a timestep a note changed, the desired input of the different layers as before. As regression- the error was multiplied with [5,10,100]. These errors thus had parameter we chose 10−4 here. The result is seen in Figure 11. to be far more important in the training proces. For the first three layers we see the result we wanted. The higher the layer, the longer in time it goes back to predict the current time step. Strange results, though, are seen with the desired input of the forth and fifth layer. They seem to take every timestep in account in an equal way. If we investigate this further, we see that the desired input of the forth and fifth layer are nearly equal to zero in every timestep. In other words, it seems to be so that these layers are abundant. If we look at Figure 11 we see that in the third layer the context is

C. Generating music As a last experiment we tried to generate music with the trained network. By sampling from the output probabilities, we gain the input for the next step. After an initialisation of 1200 timesteps we let the network generate music of its own. An example is seen in Figure 13. We see that almost immediatly after the initialisation, the network goes out of control and generates chaos. There is no rhythm to be seen in it. If we zoom in to the timesteps around the end of the initialisation, we see that the first few timesteps, the network performs realistic, but afterwards it

can’t correct ‘mistakes’ which lead to the result later on.

ACKNOWLEDGMENTS The author of this abstract would like to thank Dr. M. Hermans for the aid in the research done and Prof. B. Schrauwen for promoting this thesis. Also I’d like to thank the University of Ghent, especially the reservoir lab for its time and devotion. R EFERENCES [1]

[2] Fig. 13. Generated music of the network. The initialisation stops at timestep 1200.

[3] [4]

[5] [6] [7]

[8] Fig. 14. Generated music zoomed in around the end of the initialisation. Initialisation stops at timestep 100.

V. C ONCLUSION Deep Recurrent Neural Networks are a powerful tool and an expansion of a common recurrent neural network. It seems to outperform them by looking in a more hierarchical way in time. This has been tested in two applications. In the TIMIT speech recognition application the results are promising: performances improve and each layer has a bigger context, or so it seems by the desired input of each layer. The more difficult music modelling task has less ideal results. Though, we have an improvement in performance and a rise in context from layer 1 to 3. It seems that the network is not doing what it is supposed to do and is just copying the last timestep. We can conclude from it that training DRNNs (and NN in general) still has limits in the tasks it can complete.

[9] [10] [11]

[12]

[13] [14]

Paul Viola and Michael Jones, “Rapid object detection using a boosted cascade of simple features,” in Computer Vision and Pattern Recognition, 2001. CVPR 2001. Proceedings of the 2001 IEEE Computer Society Conference on. IEEE, 2001, vol. 1, pp. I–511. Lawrence Rabiner, “A tutorial on hidden markov models and selected applications in speech recognition,” Proceedings of the IEEE, vol. 77, no. 2, pp. 257–286, 1989. Anirudh Vallabhaneni, Tao Wang, and Bin He, “Braincomputer interface,” in Neural Engineering, pp. 85–121. Springer, 2005. Bo Pang, Lillian Lee, and Shivakumar Vaithyanathan, “Thumbs up?: sentiment classification using machine learning techniques,” in Proceedings of the ACL-02 conference on Empirical methods in natural language processing-Volume 10. Association for Computational Linguistics, 2002, pp. 79–86. Yann LeCun and Yoshua Bengio, “Convolutional networks for images, speech, and time series,” The handbook of brain theory and neural networks, vol. 3361, 1995. Christopher M Bishop et al., Pattern recognition and machine learning, vol. 1, springer New York, 2006. Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton, “Speech recognition with deep recurrent neural networks,” in Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on. IEEE, 2013, pp. 6645–6649. Sepp Hochreiter and Jürgen Schmidhuber, “Long short-term memory,” Neural computation, vol. 9, no. 8, pp. 1735–1780, 1997. Alex Graves, “Generating sequences with recurrent neural networks,” arXiv preprint arXiv:1308.0850, 2013. Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio, “How to construct deep recurrent neural networks,” arXiv preprint arXiv:1312.6026, 2013. Michiel Hermans and Benjamin Schrauwen, “Training and analysing deep recurrent neural networks,” in Advances in Neural Information Processing Systems 26, C.J.C. Burges, L. Bottou, M. Welling, Z. Ghahramani, and K.Q. Weinberger, Eds., pp. 190–198. Curran Associates, Inc., 2013. John S Garofolo, Lori F Lamel, William M Fisher, Jonathon G Fiscus, and David S Pallett, “Darpa timit acoustic-phonetic continous speech corpus cd-rom. nist speech disc 1-1.1,” NASA STI/Recon Technical Report N, vol. 93, pp. 27403, 1993. Judy A Franklin, “Jazz melody generation from recurrent network learning of several human melodies.,” in FLAIRS Conference, 2005, pp. 57–62. Douglas Eck and Jürgen Schmidhuber, “Learning the long-term structure of the blues,” in Artificial Neural NetworksICANN 2002, pp. 284–289. Springer, 2002.

INHOUDSOPGAVE

i

Inhoudsopgave 1 Inleiding

1

1.1

Machinaal leren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1

1.2

Neuronen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3

1.3

Neurale netwerken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

1.3.1

Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

1.4

Diepe recurrente neurale netwerken . . . . . . . . . . . . . . . . . . . . . . . . . .

5

1.5

Verdere verloop thesis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6

2 Neurale netwerken

7

2.1

Het artificiële neuron en éénlagig netwerk . . . . . . . . . . . . . . . . . . . . . .

7

2.2

Diepe neurale netwerken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

10

2.3

Recurrente neurale netwerken . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

2.4

Het backpropagation algoritme . . . . . . . . . . . . . . . . . . . . . . . . . . . .

14

2.4.1

Gradient descent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

14

2.4.2

Error backpropagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

15

2.4.3

Backpropagation bij Diepe Neurale Netwerken . . . . . . . . . . . . . . .

17

2.4.4

Backpropagation Through Time . . . . . . . . . . . . . . . . . . . . . . .

18

Training . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

21

2.5.1

Stochastic Gradient Descent . . . . . . . . . . . . . . . . . . . . . . . . . .

21

2.5.2

Validatieset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

22

2.5.3

Initialisatie gewichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

23

2.5.4

Leersnelheid + aantal iteraties . . . . . . . . . . . . . . . . . . . . . . . .

24

Samengevat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

25

2.5

2.6

INHOUDSOPGAVE

ii

3 Diepe Recurrente neurale netwerken

26

3.1

Tekortkomingen recurrente neurale netwerken . . . . . . . . . . . . . . . . . . . .

26

3.2

Concept en doel DRNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

27

3.3

Literatuur DRNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

27

3.4

Werking DRNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

29

4 Toepassing 1: TIMIT

31

4.1

training . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

31

4.2

Resultaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

32

4.2.1

Hoe vergelijken? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

32

4.2.2

Vergelijken prestatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

33

4.2.3

Context . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

34

4.2.4

Vergelijken invoer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

38

Samengevat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

40

4.3

5 Toepassing 2: Symbolische muziek

41

5.1

introductie

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

41

5.2

Prestatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

43

5.3

Alternatieve leermethode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

46

5.4

Voorspellen muziek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

48

5.5

Samengevat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

49

6 Conclusie

50

INLEIDING

1

Hoofdstuk 1

Inleiding 1.1

Machinaal leren

Machinaal leren, een tak van artificiële intelligentie, is het concept om een computerprogramma/ architectuur te laten leren van data. Het gebruikt deze data om taken uit te voeren. Arthur Samuel gaf de definitie: “Field of study that gives computers the ability to learn without being explicitly programmed” [Samuel, 1962]. Tom M. Mitchell gaf dan weer de meer formele definitie: “A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E”. [Mitchell, 1999] Machinaal leren is dus een vorm van artifiële intelligentie. De meest voorkomende taken zijn regressie (het benaderen van een continue functie), classificatie en voorspellingen in een bepaalde sequentie. Sommige van deze technieken proberen een menselijke kant te geven aan computerprogramma’s en vele toepassingen maken van deze technieken gebruikt. Om toch een paar concretere voorbeelden te geven:

- Visuele dataverwerking met o.a. objectherkenning [Viola and Jones, 2001] - Spraak- en handschriftherkenning [Rabiner, 1989] - Brain-computer interfaces [Vallabhaneni et al., 2005] - Gevoelsanalyse (bv. herkennen van positieve/negatieve reviews) etc. [Pang et al., 2002]

Een belangrijk punt in machinaal leren is generalisatie. Generalisatie betekent dat na het leren van een model aan de hand van een trainingsdataset, het model ook de taak kan uitvoeren op

1.1 Machinaal leren

2

ongeziene data. De trainingsdataset zou dan uiteraard representatief moeten zijn voor zoveel mogelijk ongeziene data.

Een neuraal netwerk is een aanéénschakeling van artificiële neuronen. Het is in staat om taken uit te voeren die behoren tot het vakgebied van machinaal leren. Laten we starten met een voorbeeld van wat zo’n neuraal netwerk doet. Handschriftherkenning is voor onze hersenen een eenvoudige taak. Niemand heeft het moeilijk met het herkennen van de cijfers 504192 in Figuur 1.1.

Figuur 1.1: handgeschreven cijfers De moeilijkheid bij visuele patroonherkenning ligt nu wanneer men probeert een programma te schrijven dat deze taak vervult. Terwijl wij het vanzelfsprekend vinden dat bijvoorbeeld een 9 een bolletje boven aan heeft met een staartje aan is dat onmogelijk te programmeren. Het blijkt snel dat er te veel variatie zit in verschillende handschriften om een zo goed als altijd werkend programma te creëeren.

De oplossing voor dit probleem is nu machinaal leren. In plaats van expliciet te programmeren werkt het dus met voorbeelden. Met andere woorden gaat het dus de voorbeelden gebruiken om automatisch zelf regels voor handschriftherkenning uit de data te onttrekken. Hoe meer data er dus voor handen is, hoe beter de accuraatheid zal zijn. Daarvoor is een database opgemaakt: de MNIST-database [LeCun and Cortes, 1998]. Deze bestaat uit 60000 trainingsafbeeldingen en 10000 testafbeeldingen. Elk van deze afbeeldingen is een 28 × 28-pixel afbeelding van een handgeschreven cijfer. State-of-the-art foutmarges met neurale netwerken liggen onder 0.5%.

Figuur 1.2: Voorbeelden uit de MNIST-database voor handgeschreven cijfers

1.2 Neuronen

3

Figuur 1.3: Schematische voorstelling artificieel neuron

1.2

Neuronen

Het menselijk brein is een van de wonderbaarlijkste dingen op onze planeet. Het is erg ingewikkeld en een krachtig gereedschap. De werking ervan is nog lang niet volledig verklaard, maar de beginselen zijn al min or meer duidelijk. Het werkt met een constructie van neuronen in een gigantisch netwerk waarbij die neuronen met elkaar zijn verbonden. Electro-chemische signalen worden verzameld of verzonden van het ene naar het andere neutron over soms grote afstanden. Zo worden ‘boodschappen’ gestuurd. Elk van deze neuronen kan zo geactiveerd worden. In een neuron is de frequentie van het aantal activatie’s belangrijk om te kunnen werken. Des te meer stimulans het neuron krijgt van verbonden neuronen, des te meer het neuron geactiveerd zal worden. Eén van de meest voorkomende abstracties is wanneer we gebruik maken van een activatie h gedefinieerd als: h = f(

N X

wi x i )

(1.1)

i=1

Hierbij zijn de xi de stimulansen van de N neuronen die een invoer geven aan het betreffende neuron en de wi zijn de bijhorende gewichten die een relatieve sterkte tussen de verschillende invoeren tot stand kunnen brengen. De activatie is dan de functie een gewogen som van de invoerstimulansen. Deze functie stelt voor hoe rap een neuron gaat vuren. In een biologisch neuron zal vanaf een bepaalde drempelwaarde het neuron vuren. De functie f bij een artificieel neuron zal veelal de biologische functie benaderen, maar onder een makkelijkere wiskundige vorm. Voorbeelden zijn de sigmo¨ıde functie en de tangens-hyperbolicus functie.

1.3 Neurale netwerken

1.3 1.3.1

4

Neurale netwerken Types

Onder de term neurale netwerken verstaat men een breed gamma aan architecturen. Hieronder worden de meest voorkomende en meest relevante voor deze thesis overlopen:

Eén verborgen laag: Dit netwerk bestaat uit één laag neuronen. Hieraan is een invoer verbonden en een uitvoer zoals te zien is op Figuur 1.4. Dit één-lagig netwerk is het eenvoudigste neurale netwerk. Met de invoer wordt in ieder neuron op een andere manier een gewogen som gemaakt, waarna de activatiefunctie f erop inwerkt en ieder neuron een activatiewaarde krijgt. We kunnen de invoergewichten schrijven als een matrix V . Daarna wordt met de activatiewaarden van de neuronen opnieuw een gewogen som genomen om de uitvoer o te bekomen. Schrijven we de uitvoergewichten als de matrix A dan bekomen we:

o = g(A f (V x))

(1.2)

Waarbij g een outputfunctie is die meestal lineair wordt gekozen. Merk nog op dat de activatiefunctie f niet-lineair moet zijn. Een lineaire combinatie van een lineaire combinatie is immers terug een lineaire combinatie en zou deze functie overbodig maken. Het trainen van het netwerk bestaat er dan in om de correcte gewichtenmatrices V en A te vinden om een zo goed mogelijke uitvoer te bekomen.

1.4 Diepe recurrente neurale netwerken

5

Figuur 1.4: Links zien we een NN met één verborgen laag, rechts zien we een diepe architectuur met meerdere lagen. Deze figuur is overgenomen van de doctoraatsthesis van M. Hermans met toestemming.

Diepere structuren: Een diepere structuur is nu het op elkaar bouwen van deze tussenliggende verborgen lagen neuronen. We zien dit rechts in Figuur 1.4. Deze structuur maakt het mogelijk om complexere data en taken te verwerken aangezien de hiërarchische structuur van het netwerk makkelijker een hiërarchische structuur in data kan modelleren. Deze architectuur is vaak moeilijker te trainen, maar daar komen we in volgend hoofdstuk op terug. Recurrente netwerken: Deze architectuur is centraal in deze thesis. Bij sequentiële data is het zo dat een context vaak belangrijk is. Een recurrent neuraal netwerk is een éénlagig netwerk ’in de tijd’ waarbij de activatiewaarde van het vorige neuron in de tijd gebruikt wordt als extra invoer. Dit zorgt voor een context-afhankelijkheid. We komen later uitgebreid terug op dit recurrente netwerk.

1.4

Diepe recurrente neurale netwerken

In deze thesis onderzoeken we de mogelijkheden van een speciale architectuur van zo’n recurrent neuraal netwerk, namelijk het diepe recurrent neuraal netwerk(of DRNN). De combinatie van een diepe architectuur met een recurrent netwerk zou zo mogelijks extra complexiteit kunnen modelleren in de tijd, analoog als de uitbreiding van een éénlagig neuraal netwerk naar een diep

1.5 Verdere verloop thesis

6

neuraal netwerk. Specifieker worden van twee taken (spraaktechnologie en Symbolische muziek modelleren) gebruik gemaakt om dit onderzoek te doen.

1.5

Verdere verloop thesis

In het volgende hoofdstuk geven we een gedetailleerder overzicht van neurale netwerken in het algemeen. Zowel de types, wiskundige werking als de trainingsalgoritme’s komen in dit hoofdstuk aan bod. Net als de problemen die dat met zich kan meebrengen. Het derde hoofdstuk gaat dan specifiek in op het Diepe Recurrente Neurale Netwerk waarbij eerst wordt uitgelegd hoe een DRNN in elkaar zit, daarna overlopen we kort resultaten uit de literatuur. De twee laatste hoofdstukken handelen dan over het uitgevoerde onderzoek met deze DRNN’s. Het vierde hoofdstuk gaat over de spraakherkenningstaak die wordt uitgevoerd op de TIMITdataset. Het vijfde hoofdstuk over de modellering van symbolische muziek a.d.h.v. een eigen dataset. Om dan uiteindelijk tot een conclusie te komen.

NEURALE NETWERKEN

7

Hoofdstuk 2

Neurale netwerken 2.1

Het artifici¨ ele neuron en ´ e´ enlagig netwerk

In hoofdstuk 1 hebben we de werking van een artificieel neutron al besproken en hebben we kort vermeld hoe dit een éénlagig netwerk vormt. Om dit iets duidelijker te maken gaan we de werking van dit éénlagig netwerk illustreren met een voorbeeld. In hoofdstuk 1 vermeldden we de MNIST-dataset voor handschriftherkenning bij cijfers. Deze taak is eenvoudig om de werking uit te leggen. Het begint met de invoervector x. Zoals je kan zien is die samengesteld met de invoeren xj . Voor de MNIST-afbeeldingen zou x een 785-dimensionale (28 × 28 + 1) input worden. Met elke xj voor j ≤ 784 de grijswaarde van 1 pixel en een bias x785 die standaard op 1 wordt gezet. Op het nut van deze bias komen we verder terug.

Figuur 2.1: Eén-lagig neuraal netwerk horende bij MNIST handschriftherkenning

2.1 Het artificiële neuron en éénlagig netwerk

8

Om nu van deze invoer gebruik te maken gaan we aan iedere xj een gewicht meegeven, namelijk wj en dat voor ieder neuron in het éénlagig netwerk. De gewichten zijn uiteraard verschillend bij verschillende neuronen. De gewichten gaan bepalen hoe zeer een bepaalde input (of pixel in het geval van MNIST) belangrijk is in de classificatie die het netwerk uitvoert. Het is logisch dat een pixel in de rechterbovenhoek minder belangrijk zal zijn dan een pixel in het midden. Het zijn tevens ook diezelfde gewichten die in het leerproces telkens aangepast worden. n P In het k-de neuron wordt de lineaire combinatie xj wjk gemaakt. Na de activatiefunctie f te j=1

laten inwerken, bekomen we de activatie hk voor dit neuron. In matrixvorm wordt dit dan voor

alle neuronen h = f (W x) waarbij de activatiewaarden hk in de vector h en de gewichten voor ieder neuron gebundeld worden in de matrix W . Om nu een uitvoer te bekomen herhalen we ongeveer de vorige stap. We vermenigvuldigen nu met de uitvoergewichtenmatrix A en activeren met een outputfunctie g. De uitvoer o wordt dan: o = g(A f (W x)). In bijvoorbeeld classificatie is het nodig om een probabiliteit als uitvoer te verkrijgen. Nul staat dan voor ‘is geen onderdeel van de klasse’ en één staat dan voor ‘is wel onderdeel van de klasse’. In dat opzicht is de activatiefunctie f belangrijk. In deze thesis gebruiken we daarvoor telkens de tanh-functie, mits deze overal voldoende glad is en mathematisch makkelijk te gebruiken is.

Figuur 2.2: De gladde tanh-functie als activatiefunctie

2.1 Het artificiële neuron en éénlagig netwerk

9

Met deze activatiefunctie is het nu makkelijk in te zien waarom een bias-invoer wordt gebruikt. Om dit te illustreren gebruiken we een 1-dimensionele invoer. De activatie wordt dan h = tanh(wx). Als we nu enkel de gewichten w kunnen aanpassen dan kunnen we de tanh-functie niet horizontaal opschuiven, zie Figuur 2.3 links. Als we nu een biasterm toevoegen dan bekomen we h = tanh(wx + wb ) waar wb voor het gewicht horende bij de bias-waarde staat. Dit zien we rechts op Figuur 2.3. De bias kan dus de treshold verplaatsen.

Figuur 2.3: Links: Tanh-functies met verschillende gewichten. Rechts: Tanh-functies met verschillende biaswaarde.

Merken we nog op dat in ons MNIST voorbeeld er meerdere uitvoerkanalen nodig zijn. Het geschreven cijfer kan 10 verschillende waarden aannemen en dus moeten er ook 10 uitvoerkanalen zijn. Eén neuron zou dus nooit voldoende zijn geweest en een eenvoudig éénlagig netwerk biedt hier dus een oplossing. Ondanks de eenvoudige structuur van dit netwerk, bestaan toch vele toepassingen waarin het nut van dit neuraal netwerk bewezen kan worden. Een neuraal netwerk is dan ook een universele approximator, d.w.z. dat indien er genoeg neuronen beschikbaar zijn, het elke functie arbitrair dicht zal kunnen benaderen. Naast dit eenvoudige neurale netwerk bestaan er andere architecturen die elk hun voordelen hebben. We denken bv aan de eerder vermelde diepe neurale netwerken en de recurrente neurale netwerken. Aangezien we deze laatste twee combineren en deze architectuur in deze thesis willen onderzoeken, zullen ze in wat volgt uitgebreid aan bod komen.

2.2 Diepe neurale netwerken

2.2

10

Diepe neurale netwerken

Een diep neuraal netwerk (DNN) heeft in principe dezelfde werking als het één-lagig neuraal netwerk. Enkel zijn er nu meerdere lagen verborgen neuronen. Deze meerdere lagen zorgen ervoor dat er complexere niet-lineaire relaties gemodeleerd kunnen worden. Diepe neurale netwerken zorgen voor een betere prestatie in tal van gebieden waaronder beeldverwerking en classificatie, spraakherkenning en tijdssequenties [LeCun and Bengio, 1995]. Nemen we het voorbeeld bijvoorbeeld van visuele taken om beter te duiden hoe dit komt. Iedere extra laag brengt een verdere vorm van abstractie met zich mee. Zo zal een neuron in de eerste laag geactiveerd worden door een punt, een neuron in een volgende laag door een verticaal streepje en in een nog verdere laag door een lusje of een hoekje. Dit stemt overeen met de echte werking van de hersenen ( [Chen, 1982]). Maw, de capaciteit om complexere zaken te modelleren wordt groter en er ontstaat een hiërarchisch verband tussen de lagen.

Figuur 2.4: Schematische voorstelling van een diep neuraal netwerk

Ook wiskundig is er geen grote verandering als we gaan van een éénlagig netwerk naar een diep neuraal netwerk. Ieder neuron heeft een activatie die functie is van alle inkomende signalen. Deze kunnen dus ofwel uit de invoer komen, ofwel uit een voorgaande laag neuronen. Noemen we de invoergewichtenmatrix tussen invoer en laag 1, V(0) en de gewichtenmatrix tussen laag i

2.3 Recurrente neurale netwerken

11

en i + 1 V(i) , dan hebben de neuronen in laag i de volgende activatie: h(i+1) = f (V(i) h(i) )

(2.1)

Analoog is dan na de laatste laag N de uitvoer:

o = g(A h(N ) )

(2.2)

Ook de hiërarchische structuur is te zien in het wiskundige gedeelte. De lagen zijn telkens afhankelijk van de vorige lagen en geven er zelf een nieuwe vorm aan. Op de training van dit netwerk komen we later uitgebreid terug. De gewichtenmatrices spelen hierbij een grote rol. Alvorens dat te doen behandelen we eerst de recurrente neurale netwerken.

2.3

Recurrente neurale netwerken

Om te kaderen waar het belang van recurrente neurale netwerken (RNN) net ligt, gaan we kijken naar hoe om te gaan met een discrete tijdsreeks. Stel dat we het volgende karakter in een tekst willen voorspellen bijvoorbeeld, dan is een bepaalde context erg belangrijk. Als we gebruik zouden maken van een diepe architectuur, dan moeten we als invoer een bepaald venster kiezen. Dat venster bepaalt hoeveel van de vorige karakters we als invoer meegeven, zeg maar welke context we meegeven aan het netwerk. De moeilijkheid ligt erin om te weten hoe lang de nodige context moet zijn die wordt meegegeven aan het netwerk. Daarnaast is in een tijdsreeks vaak een oorzaak-gevolg verband aanwezig. Ook daarvan maakt het DNN geen gebruik. Recurrente neurale netwerken behandelen het voorgaande probleem op een andere manier. De reden waarom een RNN context kan onthouden zit hem in zijn architectuur. Om deze uit te leggen vertrekken we terug van een één-lagig standaard neuraal netwerk als op Figuur 2.1. Het recurrente neurale netwerk heeft één zo’n netwerk per tijdsstap in de sequentiële reeks, echter zijn de tussenliggende gewichten dezelfde voor ieder van die één-lagige netwerken. Met andere woorden kopiëren we het ene één-lagig netwerk telkens opnieuw in de tijd. Om nu een context te kunnen onthouden moeten deze subnetwerken met elkaar verbonden worden. Dit gebeurt door de tussenliggende lagen neuronen te verbinden met elkaar zoals in Figuur 2.5. We noemen de gewichten die met deze linken overeenstemmen de recurrente gewichten. Op die manier kunnen de activatiewaarden van de neuronen uit een vorige tijdsstap dus meegenomen worden naar toekomstige tijdsstappen om zo een ‘geheugen’ in de tijd te creëeren. Om schematisch afbeeldingen te vereenvoudigen in wat volgt, zullen we elke laag neuronen vervangen door één knooppunt in


12

onze graaf als in Figuur 2.6. Een recurrent netwerk kan dan eenvoudiger voorgesteld worden als Figuur 2.7.

Figuur 2.5: Een recurrent neuraal netwerk als verbonden één-lagige netwerken in de tijd

Figuur 2.6: Schematische vereenvoudiging van de grafische voorstelling RNN

Figuur 2.7: Vereenvoudigde voorstelling RNN

Om kort samen te vatten wordt dus één invoer per tijdsstap door een één-lagig netwerk gepropageerd. Er wordt een output (groen) gegenereerd en de activatiewaarden van de neuronen(zwart) worden met de recurrente gewichten naar de volgende tijdsstap overgebracht. We gebruiken de invoeren uitvoergewichtenmatrices V en A uit de vorige paragrafen en voegen daar de


13

recurrente gewichtenmatrix W aan toe. We krijgen dan in voorwaartse richting op tijdsstip t: h(t) = tanh(V x(t) + W h(t−1) )

(2.3)

o(t) = tanh(A h(t) )

(2.4)

en

Op deze manier ontstaat dus ‘fading memory’ [Boyd and Chua, 1985], de activaties zijn afhankelijk van de invoer en de activaties uit de vorige tijdsstap. Die laatste zijn dan weer afhankelijk van de tijdsstap ervoor enzovoort. Zo ontstaat mogelijks een oneindig lange context die steeds kleiner wordt in de tijd. In tegenstelling dus met het DNN die enkel een venster kon bepalen waarin context werd gebruikt. Naast tekstvoorspelling [Sutskever et al., 2011], zijn er tal van andere toepassingen zoals voorspelling van de beurs [Roman and Jameel, 1996], geautomatiseerde controlesystemen [Ku and Lee, 1995] en vele andere..

2.4 Het backpropagation algoritme

2.4 2.4.1

14

Het backpropagation algoritme Gradient descent

Om een neuraal netwerk te trainen (m.a.w. de prestatie van het netwerk te verbeteren), moeten we dus de gewichten zodanig kunnen bekomen dat ze een zo goed mogelijke set uitvoeren geven bij een gegeven set invoeren. Een zo goed mogelijke set uitvoeren is deze die het best overeenstemt met een meestal gegeven set targets. Hoe worden deze gewichten nu getraind? Om dat te kunnen doen hebben we een kostfunctie nodig. De kostfunctie E is een maat voor hoeveel de bekomen uitvoeren y afwijken van de vooropgestelde doelen (targets) t. Veelgebruikte kostfuncties zijn de kwadratische kostfunctie, de cross-entropy kostfunctie of de softmax kostfunctie. Deze laatste wordt de softmax kostfunctie genoemd omdat de activatie van de output dan de softmax-functie wordt: yk =

exp(ak ) m P exp(ak )

k=1

Deze softmax wordt gebruikt bij een multiclass classificatie taak en geeft een kans terug dat de input correspondeert met de klasse k. Het voordeel van de voorafgenoemde kostfuncties is dat ze allen een gelijkaardige vorm aannemen als we gaan afleiden naar de activaties van een neuron. We zullen later zien waarom dit zo belangrijk is.

1 E(y) = (y − t)2 2 m 1 X [tk ln(yk ) + (1 − tk ) ln(1 − yk )] E(y) = m

kwadratische : cross − entropy :

sof tmax :

(2.5) (2.6)

k=1

E(y) =

m X k=1

tk ln(yk )

(2.7)


15

De kostfuncties zijn nu afhankelijk van de gewichten want de uitvoer van het netwerk y is i . We krijgen dus E(y(W ). Om nu deze kostfunctie te minimaliseren met afhankelijk van alle wjk

behulp van de gewichten is de volgende stap om de gewichten aan te passen in dalende richting van E per iteratie t. Om dat te doen berekenen we de gradiënt van E ten opzichte van alle gewichtsparameters. We gebruiken dan de volgende formule om de gewichten aan te passen: W ← W − η ∇E(W )

(2.8)

Waarbij η de leersnelheid van het proces is. Dit proces heet gradient descent. De gradient van de kostfunctie naar de gewichten wordt berekend. De gewichten worden in kleine stapjes aangepast in deze richting (en dus in dalende richting van de kostfunctie) en het proces herhaalt zich tot we in een minimum terechtkomen van de kostfunctie. Nu rest nog de vraag hoe we de gradient berekenen. Dit is het eenvoudigst met het error backpropagation algoritme.

2.4.2

Error backpropagation

We starten met het bekijken van een eenvoudig netwerk waarbij de uitvoer yk een lineaire comP binatie is van een invoer x zodat: yk = wki xi . De kostfunctie E kunnen we schrijven als i P : E = 21 (yk − tk )2 waarbij de tk de targets zijn. De afgeleide van de kostfunctie naar een k

gewicht wji is nu:

∂E ∂wji

= (yj − tj )xi . Deze gradiënt kunnen we nu beschouwen als een product

van een fout (yj − tj ) aan de uitgaande kant van de relatie met de invoer van de relatie xi . In het geval er een niet-lineaire activatiefunctie g wordt gebruikt aan de uitvoer moet volgens de kettingregel enkel de afgeleide g 0 met de gradiënt vermenigvuldigd worden.

Als we nu gaan kijken naar een éénlagig netwerk zullen we hetzelfde patroon zien verschijnen bij de berekening van de gradiënt van de kostfunctie E. In dit eenlagig netwerk zal de activatie hj van het neuron j in de verborgen laag de volgende activatie van een gewogen som van de invoeren x aannemen: hj = f (

X

vji xi )

(2.9)

i

Daarna wordt een uitvoer gegenereerd:

yk = g(ajk hj )

(2.10)

Dit deel is de voorwaartse propagatie die we voordien al hadden besproken bij het eenvoudige neuraal netwerk. Om dit netwerk te trainen moeten twee gewichtenmatrices aangepast worden.


16

De gewichtenmatrix A naar de uitvoer en de invoergewichtenmatrix V. De berekening van de gradiënt naar de uitvoergewichtenmatrix A is compleet analoog als in het voorvermelde eenvoudige voorbeeldje. We vervangen enkel de invoeren uit het eenvoudige voorbeeldje door de activatiewaarden h uit de tussenliggende laag neuronen. We krijgen dus: ∂En = (ynj − tnj ) hni ∂aji

(2.11)

Voor de invoergewichtenmatrix V ligt het iets ingewikkelder. Bekijken we nu de afgeleide van En naar een gewicht vji . De kettingregel geeft ons: ∂En ∂En ∂hj = ∂vji ∂hj ∂vji aangezien de uitvoer y berekend wordt als de gewogen som g(

(2.12) P

A hj ). We gebruiken een

j

vereenvoudigde notatie: δj =

∂En ∂hj

en berekenen

∂hj ∂vji

= xi f 0 uit formule (2.9) om te bekomen:

∂En = δ j xi f 0 ∂vji

(2.13)

Formule (2.13) zegt ons dat de gevraagde afgeleide bekomen wordt door de fout δj in de uitgaande kant van de relatie te vermenigvuldigen met de invoer van die relatie en wegens de kettingregel ook nog te vermenigvuldigen met de afgeleide van de activatiefunctie, namelijk f 0 . Bemerk dat dit dezelfde vorm heeft als de gradient naar de uitvoergewichten A. We moeten nu dus nog de fout δj =

∂En ∂hj

berekenen. Opnieuw gebruik makend van de kettingregel krijgen we: ∂En X ∂En ∂yk = ∂hj ∂yk ∂hj

(2.14)

k

De eerste term is dus de fout aan de uitvoer: (ynj − tnj ). De tweede term kan berekend worden uit (2.10):

∂yk ∂hj

= akj g 0 . Merk op dat in deze terugpropagatie, de indices k en j voor de

uitvoergewichten omgedraaid zijn en we dus in matrixnotatie enkel de uitvoergewichtenmatrix A moeten transponeren. Bovenstaande notatie’s zijn nogal omslachtig. Vandaar gaan we ze even herhalen in matrixvorm. We starten met de voorwaartse en al gekende propagatie. We berekenen de fout aan de uitvoer als δuitvoer = Y −T Waarbij de matrix T staat voor alle targets. De fout kan dan teruggepropageerd worden naar de verborgen neuronenlaag: δneuronenlaag = δuitvoer AT g 0 . Daarna kunnen op gelijkaardige manier de gradiënten naar de matrices A en V worden berekend als: ∂E = δuitvoer h g 0 ∂A ∂E = δneuronenlaag x f 0 ∂V

(2.15) (2.16)


2.4.3

17

Backpropagation bij Diepe Neurale Netwerken

We kunnen nu voorgaand algoritme makkelijk uitbreiden naar een meerlagige structuur. Dit is makkelijk in te zien als we ons neuraal netwerk omzetten naar een graaf. De uitvoerlaag, iedere tussenliggende neuronenlaag en de invoer zijn knooppunten in de graaf. Iedere gewichtenmatrix daartussen is een pijl tussen 2 knooppunten. Om nodeloos ingewikkelde berekeningen te vermijden verwijzen we voor een volledige uitwerking van het backpropagation algoritme bijvoorbeeld naar [Bishop et al., 2006] en gaan we schematisch de stappen (analoog aan het backpropagation algoritme in een éénlagig neural netwerk) vermelden.

1. Propageer de invoer X voorwaarts doorheen het netwerk zoals we hebben gezien in sectie 2.2 om een uitvoer Y te bekomen. 2. Bereken de fout δuitvoer aan de uitvoer als Y − T . 3. Propageer de fouten achterwaarts doorheen het netwerk door ze te vermenigvuldigen met de getransponeerde gewichtenmatrices van de relatie en de afgeleide van de gebruikte activatiefunctie. Tel fouten op indien ze van verschillende knooppunten naar één knooppunt gaan. 4. Zodra elk knooppunt geassocieerd is met een fout, bereken dan de gradiënten van de gewichtenmatrices door het product te nemen van de fout aan de uitgaande kant van de relatie en de invoer van die relatie, opnieuw vermenigvuldigd met de afgeleide van de activatiefunctie. 5. Bereken de nieuwe gewichten met Formule (2.8). 6. Herhaal dit proces tot de optimale gewichtenmatrices zijn bereikt.

Dit is dus het backpropagation algoritme dat gebruikt kan worden in elk feed-forward netwerk en eenvoudig te implementeren is. Merk op dat als we nu één van de voorgaand vermelde kostfuncties willen gebruiken, er geen aanpassing is aan het algoritme. De afgeleide

∂En ∂hk

zal im-

mers een gelijkaardige vorm blijven aannemen. Dit geeft als gevolg dat diepe neurale netwerken kunnen gebruikt worden voor zowel regressie, binaire of multiclass classificatie problemen als voor andere toepassingen. Het error backpropagation algoritme is dus een krachtige tool om diepe neurale feed-forward netwerken te trainen en heeft op zichzelf een hele vooruitgang van het onderzoeksgebied in de hand gewerkt.


2.4.4

18

Backpropagation Through Time

Het trainen van het RNN is grotendeels gelijkaardig aan het error backpropagation algoritme. Dit aangepaste algoritme heet het ’backpropagation through time’ algoritme of kortweg BPTT [Werbos, 1990]. Het maakt opnieuw gebruik van de recursieve formule die we gezien hebben in het backpropagation algoritme. Het komt er op neer dat we het RNN ’ontplooien’ in de tijd en gaan bekijken als een diep neuraal netwerk in de tijd. Voor de aanpassing van de uitvoergewichten A kunnen we rechtstreeks de fout op de uitvoer berekenen en vermenigvuldigen met de activatiewaarden van de neuronen. Er verandert dus niets om de gewichten A te trainen in vergelijking met het gewone BP-algoritme. In het geval van de recurrente en invoergewichten is dit anders... We beginnen met op de laatste tijdsstap de fout op de uitvoer te berekenen en terug te propageren naar de laatste tussenliggende laag neuronen. Deze fout wordt dan teruggepropageeerd naar de laag tussenliggende neuronen uit de vorige tijdsstap, waar ook de fout van de uitvoer uit die tijdsstap terug wordt gepropageerd en erbij opgeteld alvorens een volgende tijdsstap terug te keren. Schematisch ziet dat er uit als in Figuur 2.8.

Figuur 2.8: Schematische voorstelling BPTT. De blauwe cirkels zijn invoer, de zwarte tussenliggende neuronenlagen en de groene zijn de uitvoerlagen. Wanneer deze rood gekleurd worden, zijn ze geassocieerd met een fout.


19

Slechts als de fout doorheen de hele sequentie is teruggepropageerd kunnen de gewichtenmatrices V en W worden aangepast op dezelfde manier als in het BP-algoritme. De gradiënten worden dan over alle tijdsstappen uitgemiddeld en daarmee worden dan de gewichtenmatrices aangepast.

Het gradient descent algoritme met BPTT dat gebruikt wordt bij de training van het RNN blijkt niet altijd stabiel en onmiddellijk naar een oplossing te convergeren. Er zijn enkele bijkomende problemen die het RNN met zich meebrengt. Eén daarvan zijn bifurcaties. Het kostlandschap kan erg ruw zijn. Dit zorgt voor dit bijkomende probleem. Een bifurcatie kan herkend worden aan een onstabiele fout en een plotse stijging ervan zoals in Figuur 2.9.

Figuur 2.9: fout tijdens het leerproces met een bifurcatie

De oorzaak hiervan is een erg grote gradiënt die de gewichtsaanpassing bepaalt. Door een discontinu¨ıteit in de kostfunctie zal een kleine gewichtsaanpassing de kostfunctie erg sterk verhogen. Deze verhoging zal dan bijgevolg ook de fout aan de uitvoer snel en sterk doen stijgen. Daardoor zal de nieuw berekende gradiënt dus veel hoger zijn dan in de vorige iteratie en de nieuwe gewichten zullen een veel te grote stap nemen en terechtkomen in een gebied ver van de optimale oplossing en dus in een onberekenbaar gebied. M.a.w. moet de training daar van nul opnieuw beginnen. Een heuristieke oplossing voor dit probleem bestaat erin de gradiënt voor de gewichtsaanpassing te normaliseren. Dit zorgt ervoor dat deze laatste niet kan ontploffen en dat het leerproces


20

stabieler verloopt. Een uitgebreidere behandeling van de rol van bifurcaties in het trainen van RNNs is te vinden in [Doya, 1993].

Figuur 2.10: stabilisatie fout na normalisatie gradiënt

Een ander bijkomend probleem bij de RNN heet het vanishing gradient probleem. Het komt erop neer dat in bepaalde tijdsreeksen, een uitvoer sterk afhankelijk kan zijn van een invoer die heel wat tijdsstappen terug ligt. Het is veelal zo dat wanneer een fout die terugpropageert in de tijd, sterk daalt en uiteindelijk verdwijnt. Daardoor zal de gradiënt wanneer die berekend wordt aan de tijdsstap van die vroegere invoer al te klein zijn om nog een efficiënte aanpassing in gewichten te kunnen bekomen. Oplossingen hiervoor zijn bijvoorbeeld Long-Short Term Memory (geheugenblokken expliciet aanwezig in de architectuur) [Hochreiter and Schmidhuber, 1997] of een uitgebreidere trainingsmethode zoals de Hessian free trainingsmethode [Martens, 2010].

Als illustratie van de werking van zo’n RNN bekijken we tekstvoorspelling. De te volbrengen taak bestaat erin om het volgend teken te voorspellen in een tekst, op die manier zelf een stuk tekst te creëeren. Om het netwerk te trainen gebruiken we het verhaal van roodkapje. Een invoer per tijdsstap wordt dan één teken. Vertaald in een 29-dimensionale input (26 letters uit het alfabet + spatie, punt en komma). Bij de letter A wordt dat dan bijvoorbeeld [1...0 0 0 ]T . De gewenste uitvoer of targets per tijdsstap zijn dan van dezelfde 29-dimensionale vorm en zijn het volgende teken in de sequentie. ‘De wolf ’ wordt zo opgesplitst in de tijd als de invoersequentie [D E ‘spatie’ W O L F] en de bijbehorende targets zijn [E ‘spatie’ W O L F ‘spatie’].

2.5 Training

21

Figuur 2.11: Inputs en gewenste outputs bij roodkapje:illustratie Met de 2898 tekens en dus 2898 tijdsstappen waaruit het sprookje bestaat wordt het netwerk dan getraind zoals hiervoor beschreven met gradient descent en het BPTT. Gebruiken we dan de getrainde gewichtenmatrices V ,W en A om tekst te voorspellen na een initialisatie: ‘de wolf peuzelde roodkapje op. de jager (die ’ krijgen we bijvoorbeeld: ‘ snielons wolf. en grote stenorman het ploemen was in het grotemen beslook vajl bestmenen op hij maar erien en bijloi dal ni roodkapje was die bij de oma nakr waa’. Met een heel simpel RNN met 50 neuronen zien we dat er al herkenbare woorden of woordgroepen worden geproduceerd. De initialisatie wordt gebruikt zodat een andere context wordt meegegeven dan in het sprookje zelf voorkomt, om te voorkomen dat er letterlijke stukken tekst uit het sprookje worden gekopieërd.

2.5

Training

Bij het gebruik van BP of BPTT duiken nog verschillende andere problemen op tijdens het trainen. We overlopen in wat volgt kort nog enkele van de belangrijkste waar in ieder trainingsproces rekening mee moet gehouden worden.

2.5.1

Stochastic Gradient Descent

Bij het gebruik van gradient descent ontstaat een groot probleem wanneer de dataset te groot wordt. Om de kostfunctie te berekenen voor alle datapunten loopt de computationele kost erg sterk op. Het wordt ondoenbaar om met die hele dataset het gradient descent algoritme uit te voeren. Om dit te verhelpen gaan we uit een reeks invoer een batch ‘knippen’. Die batch bestaat uit een kleiner aantal elkaar opvolgende datapunten en we gaan daarmee het algoritme uitvoeren.

2.5 Training

22

Deze variatie van het gradient descent algoritme wordt stochastic gradient descent genoemd. Als ervoor wordt gezorgd dat de batch toch voldoende relevante context met zich meedraagt (d.w.z. groot genoeg is), zal het uiteindelijke model voor de taak dezelfde eigenschappen hebben in vergelijk met het gewone gradient descent algoritme. De batchgrootte wordt dus een hyperparameter van de training en er moet een afweging komen tussen prestatie/precizie van het model en rekentijd afhankelijk van de batchgrootte. Om ervoor te zorgen dat toch de hele dataset gebruikt wordt om te leren en dus om een optimaal model te verkrijgen voor de uitgevoerde taak, gaan we per iteratie een andere batch willekeurig gaan kiezen.

2.5.2

Validatieset

Hoe kunnen we nu de geschikte batchgrootte vinden bij een taak? We kunnen de prestatie vergelijken na een training, maar het leerproces is erg afhankelijk van verschillende parameters. Zowel de leersnelheid, het aantal iteraties als de initialisatie-gewichten hebben een grote invloed op de uiteindelijke prestatie van het netwerk. Om deze hyperparameters te optimaliseren maken we gebruik van een trainings- en validatieset. Om die te bekomen gaan we een deel van de trainingsdata nemen om te valideren en dus niet om te leren. We laten het leerproces starten en berekenen dan om de zoveel iteraties de prestatie op de validatieset. Door verschillende parameterwaarden te gebruiken kunnen we de beste parameters vinden om dan het definitieve leerproces te starten op de gehele trainingsdata (dus ook met validatieset.) Om dan uiteindelijk met de beste parameters het netwerk te testen op de testset. Het gebruik van een validatie-set voorkomt ook overfitting.

Overfitting is het fenomeen waarbij het netwerk de data zou ‘van buiten’ leren in plaats van een onderliggend model te gaan zoeken (Dit laatste wordt generalisatie genoemd). Bij overfitting zou het resultaat op de trainingsset erg goed zijn, maar dan zal bij de ongeziene validatieset de prestatie veel kleiner zijn. Door het controleren met een validatieset gaan we dus zien wanneer het netwerk start met overfitten en wanneer het leerproces beter gestopt kan worden. Een voorbeeld van het verloop van een trainings- en validatiefout zien we in Figuur 2.12. Als validatieset gebruiken we in deze thesis 10% van de gegeven trainingsdata.

Door verschillende hyperparameters te sweepen, d.w.z. verschillende waarden gebruiken en

2.5 Training

23

diegene zoeken die de laagste validatiefout geven, gaan we het netwerk dus optimaliseren.

Figuur 2.12: Trainings-(onderste) en validatiefout (bovenste) van een overgefit netwerk

2.5.3

Initialisatie gewichten

Het leerproces start met de initialisatie van de gewichten. Er wordt in het algoritme echter niets gezegd over waar het startpunt van de gewichten moet liggen. Hoe verder van het optimale minimum van de kostfunctie er gestart wordt, hoe langer het leerproces zal duren en hoe meer kans om vast te raken in een lokaal minimum onderweg. Om de grootteorde van de initialisatiegewichten te kunnen be¨ınvloeden voeren we factor in. Deze factor wordt dan elementsgewijs vermeningvuldigd met een matrix willekeurige getallen uit een normaalverdeling met gemiddelde 0 en variantie 1. Voor de recurrente gewichtenmatrix W is een vuistregel om de inverse van de vierkantswortel van het aantal gebruikte neuronen per laag te nemen als factor. Deze keuze zorgt steeds voor een goed resultaat. Voor de uitvoergewichts- en invoergewichtsfactor is het bepalen van een optimale factor minder eenvoudig. Om de invoergewichtsfactor te kiezen kijken we het best naar de activatiewaarden van de neuronen uit de eerste laag. Deze worden berekend als h1 = tanh( .. + V1 ∗ x). Als we nu naar deze waarden gaan kijken, willen we voorkomen dat de tanh gesatureerd is geraakt, d.w.z. dat alle waarden -1 of 1 zijn. Het liefst willen we dat de waarden vooral tussen -1 en 1 liggen en normaler verdeeld zijn. Het opvolgen van een histogram zoals in Figuur 2.13 is dus een goeie manier om de invoerfactor te bepalen. Er rest nog de uitvoerfactor te bepalen. In deze thesis is over de uitvoerfactor gesweept, m.a.w. verschillende factoren zijn gebruikt en diegene die het

2.5 Training

24

beste resultaat geeft op de validatieset (zie vorige sectie), werd gekozen.

Figuur 2.13: Voorbeeld histogram van activatiewaarden eerste laag neuronen. We zien dat de activatiewaarden goed verdeeld zijn tussen -1 en 1.

2.5.4

Leersnelheid + aantal iteraties

Bij iedere aanpassing van de gewichten wordt de gradiënt vermenigvuldigd met de leersnelheid η (zie Formule 2.8). Een andere leersnelheid zal de grootte van de stapjes in het gradient descent algoritme veranderen en kan ook de prestatie van het neuraal netwerk veranderen. Daarom is het nodig ook over deze parameter te sweepen. Naast een constante leersnelheid, kan men er ook voor kiezen om deze te laten afnemen per iteratie. Op die manier worden steeds kleinere stapjes richting het optimale minimum gezet en kan het dus preciezer benaderd worden. De leersnelheid η kunnen we op twee manieren laten afnemen: lineair en exponentieel. Door telkens te vermenigvuldigen met een factor of met een contant getal af te trekken. In ons geval hebben we gekozen om lineair te laten dalen naar 0 als: η0 = η −

η aantal iteraties

(2.17)

Het aantal iteraties is belangrijk om overfitting te voorkomen zoals hiervoor uitgelegd. Een goeie combinatie van leersnelheid en aantal iteraties wordt dus gekozen aan de hand van de geleverde prestatie op de validatieset.

2.6 Samengevat

2.6

25

Samengevat

Neurale netwerken en uitbreidingen als diepe neurale netwerken en recurrente neurale netwerken zijn krachtige concepten om taken op te lossen die expliciet moeilijk te programmeren zijn en die lijken buiten de beschouwing van computerprogramma’s te vallen. De verschillende types hebben elk hun eigen voordelen. Diepe neurale netwerken hebben een hoger vermogen complexere data te ontleden en gebruiken. Recurrente netwerken tenslotte hebben dan weer het vermogen om een ‘oneindinge’ context te onthouden en blinken uit in sequentiële data. Daarnaast zijn ze ook relatief eenvoudig te trainen met gradient descent en het backpropagation algoritme waardoor hun gebruik enkel maar bevorderd kan worden. Naast de gebruikte algoritme’s moet nog rekening gehouden worden met tal van andere problemen tijdens de training.

DIEPE RECURRENTE NEURALE NETWERKEN

26

Hoofdstuk 3

Diepe Recurrente neurale netwerken Een recente architectuur, een diep recurrent neuraal netwerk, probeert de voordelen van een diepe architectuur te combineren met die van een recurrent neuraal netwerk. De reden waarom we dit willen onderzoeken, is om tegemoet te komen aan de tekortkomingen die een recurrent netwerk met zich meebrengt. We zullen deze eerst kort bespreken waarna we in meer detail de diepe recurrente neurale netwerken (DRNN’s) zullen bespreken en kort enkele recente artikelen zullen bespreken die over deze DRNN’s gepubliceerd zijn geweest.

3.1

Tekortkomingen recurrente neurale netwerken

De recurrente netwerken besproking in vorig hoofdstuk hebben een grote vooruitgang geboekt in hun gebied. Prestaties op taken werden verbeterd en bijhorende trainingsalgoritme’s werden bedacht. Toch hebben ze nog enkele tekortkomingen. In de eerste plaats schuilt er achter bepaalde invoer een hoge complexiteit. Aangezien een recurrent netwerk binnen één tijdsstap slechts door één neuronenlaag gaat, mist het RNN het vermogen om de complexiteit van die data te verwerken. Vandaar dat we een grotere diepgang in het netwerk willen krijgen. Die zou volgens ons een oplossing bieden voor bovenstaand probleem. Daarnaast is het ook zo dat data een hiërarchisch verband kan hebben op verschillende tijdsschalen. Met deze assumptie wordt niet expliciet rekening gehouden in de architectuur van het RNN. Naar analogie met de uitbreiding van een eenvoudig neuraal netwerk naar een diep netwerk willen we rekening houden met de hiërarchiën in de tijd.

3.2 Concept en doel DRNN

3.2

27

Concept en doel DRNN

Om nu de diepgang in de recurrente neurale netwerken te verkrijgen, gaan we verschillende recurrente neuronenlagen uit het normale RNN op elkaar stapelen. De activatie van de ene recurrente laag is dan de invoer voor de volgende. Zo verkrijgen we een diepte in zowel tijd (door de recurrente gewichten) als in ruimte (door de verschillende lagen op elkaar te stapelen). Zo zijn er verschillende niet-lineariteiten voor de invoer de uitvoer bereikt en bestaat de mogelijkheid dus dat complexere verbanden gemodelleerd worden. Op Figuur 3.1 zien we hoe dit schematisch in elkaar zit.

Figuur 3.1: Een drie-lagig diep recurrent neuraal netwerk In deze thesis gaan we uitgebreid onderzoeken welke toegevoegde waarde de extra lagen met zich meebrengen. Zowel qua prestatie als qua context. De bedoeling is om aan te tonen dat een extra laag zou instaan voor een langere meegenomen voorgeschiedenis. Op die manier zou dus een betere modellering kunnen ontstaan voor bepaalde taken. Voor we de gedetailleerde werking van deze DRNN’s in detail gaan bespreken, bekijken we enkele recente artikelen die ook een uitbreiding van het RNN beschouwen.

3.3

Literatuur DRNN

Het fading gradient probleem van een RNN met een enkelvoudige recurrente neuronenlaag bespraken we eerder. Een voorgestelde oplossing voor dit probleem heet LSTM of long-short term memory [Hochreiter and Schmidhuber, 1997]. Dit speciale type neuraal netwerk maakt gebruik

3.3 Literatuur DRNN

28

van geheugenblokken om vele tijdsstappen terug te kunnen gaan kijken. Het netwerk leert dan zelf hoe het die geheugenblokken gebruikt maar ze zorgen voor een rechtsstreekse verbinding in plaats van de context door iedere recurrente stap mee te nemen. Deze blokken zijn expliciet in de architectuur aanwezig. [Graves et al., 2013] combineert in zijn artikel deze LSTM-blokken met een meerlagig recurrent netwerk en verschillende trainingsmanieren. De nadruk in dit artikel ligt vooral in de prestatie op de spraakherkenningsdataset TIMIT en niet in de precieze functionaliteit of analyse van hun resultaten. Diezelfde [Graves, 2013] heeft dan dezelfde architectuur gebruikt om handschrift te voorspellen en uiteindelijk te genereren. Ook op tekstvoorspelling aan de hand van een wikipedia-dataset heeft hij de structuur getest. De resultaten werden zeer positief bevonden en het netwerk kon zelfs handschriften leesbaarder maken met de juiste instellingen. Opnieuw lag de focus op prestatie. [Pascanu et al., 2013] bekeek het probleem dan weer iets theoretischer. Er werden verschillende manieren voorgesteld om een RNN dieper te maken. Het voorvermelde DRNN die in deze thesis wordt onderzocht is er daar één van. Daarnaast stelt hij ook voor om tussen de recurrente neuronenlagen in de tijd een extra diepte te creëeren. Beide architecturen werden getest op muziekvoorspelling en taalmodellering en bereikten state-of-the-art resultaten. Het dieper maken van een RNN heeft dus al verschillende veelbelovende resultaten geboekt. In [Hermans and Schrauwen, 2013] wordt het DRNN gebruikt die ook in deze thesis onderzocht wordt. Na de introductie ervan, wordt ze toegepast op tekstvoorspelling op een wikipediadataset. Met een simpele trainingsmanier worden toch betere resultaten geboekt dan met een ingewikkeld RNN, namelijk het MRNN [Sutskever et al., 2011]. Dit laatste werd getraind met een geavanceerdere trainingstechniek: Hessian-Free training [Martens, 2010]. Daarnaast wordt ook een analyse van de resultaten en het nut van de extra lagen gemaakt. Het lijkt zo te zijn dat de hoogste laag van het DRNN instaat voor de abstractere concepten en lagere lagen voor de minder abstracte. Ook op lange termijn boekt het DRNN goeie resultaten. Zo wordt er gekeken naar het openen en sluiten van haakjes. Terwijl er een lange woordreeks tussen het openen en sluiten van haakjes kan staan, slaagt het netwerk er toch in om daar rekening mee te houden. Dit blijkt vooral door de hoogste laag te zijn. Daaruit kunnen we besluiten dat extra lagen, extra tijdsschalen kunnen modelleren. Deze thesis gaat dus verder op het werk van [Hermans and Schrauwen, 2013]. We gebruiken het DRNN zonder LSTM-blokken en gaan deze testen op de TIMIT-spraakherkenningsdataset en

3.4 Werking DRNN

29

op het modelleren van symbolische muziek in de twee volgende hoofdstukken. Hierbij focussen we niet enkel op prestatie maar ook op de analyse van de functionaliteit van de lagen.

3.4

Werking DRNN

Het voorwaarts propageren om een uitvoer per tijdsstap te genereren verschilt niet veel van het gewone RNN. Voor de duidelijkheid gaan we dit toch even kort overlopen. Gaan we eerst even inzoomen op één tijdsstap dan zien we schematisch hoe dit in elkaar zit in Figuur 3.2.

Figuur 3.2: Een tijdsstap uit een drie-lagig DRNN Iedere pijl staat voor een gewichtenmatrix zoals voorheen. Merk op dat ook in iedere tussenliggende neuronenlaag een pijl zou moeten toekomen. Omdat de gewichtenmatrices per tijdsstap dezelfde zijn, is ervoor geopteerd deze pijlen niet nog eens bij te tekenen. Aangezien er meerdere tussenliggende lagen zijn moeten we nu ook extra gewichtenmatrices invoeren. Als conventie nemen we Vi voor een relatie tussen input en tussenliggende laag of tussen een tussenliggende laag naar een hogere tussenliggende laag. Van een tussenliggende laag naar een output gebruiken we Ai en voor de recurrente gewichten nemen we Wi met i van één tot en met het aantal lagen dat gebruikt werd. Deze conventie staat ge¨ıllustreerd op Figuur 3.3.

Het voorwaarts propageren is analoog als in het diepe of in het recurrente neurale netwerk. Bij (t+1)

de activatie-waarden van de neuronen hebben we nu hj

(t)

(t+1)

= f (Wj hj + Vj h(j−1) ). h0 wordt P (t) hier dan gelijkgesteld aan de invoer x. De uitvoeren hebben de vorm: y (t) = g( Aj hj ). Als j

activatiefunctie f in de neuronen werd telkens de tanh-functie gebruikt. De uitvoer-functie g is

afhankelijk van de toepassing. Staan we nog even stil dat iedere laag een verbinding heeft met

3.4 Werking DRNN

30

Figuur 3.3: Een drie-lagig DRNN met bijhorende gewichtenmatrices

de uitvoer in plaats van enkel de bovenste. Deze keuze is gemaakt om het vanishing-gradient probleem te voorkomen. Iedere laag dat de gradiënt doorloopt wordt hij kleiner. De onderste lagen zouden dus in dat geval erg klein kunnen worden en de lagen zouden ineffectief getraind worden. Door een verbinding te maken tussen iedere laag en uitvoer wordt dit dus verholpen. Het is ook makkelijker om de functionaliteit van een laag te bekijken. Maar daar komen we later op terug. Het trainen van het netwerk kan nog steeds met BPTT. In een neuronenlaag komt een fout toe vanuit de corresponderende neuronenlaag één tijdsstap verder. Daar komt ze samen met een fout die rechtstreeks van de uitvoer komt. En dan moet ze opnieuw doorheen de hele laag terug worden gepropageerd om dan hetzelfde proces te herhalen in de laag daaronder en zo verder. Het gradient descent algoritme is dus nog steeds eenvoudig uit te voeren en wordt in volgende hoofdstukken dus ook gebruikt bij de training.

TOEPASSING 1: TIMIT

31

Hoofdstuk 4

Toepassing 1: TIMIT Onze eerste toepassing voor de DRNN’s is spraakherkenning. We maken gebruik van de TIMITdatabase [Garofolo et al., 1993]. Deze bestaat uit ingelezen tekst door 462 engelstalige sprekers met verschillende dialecten. De audio-signalen worden verwerkt in 39 dimensionale vectoren om classificatie van fonemen mogelijk te maken. Elk van deze vectoren zijn manueel gelabeld als een foneem. Ieder sample is dus een 39-dimensionele inputvector corresponderend met een foneem. De database bestaat uit 1 010 659 trainingssamples en 350 343 testsamples. De stateof-the-art classificatiefout ligt onder de 20% PER of phoneme error rate [Graves et al., 2013]. Deze foutmaat is een andere dan de simpele fout die wij in wat volgt zullen gebruiken. Het is echter niet de bedoeling in deze thesis om dat te evenaren, maar om te onderzoeken of een diep recurrent neuraal beter scoort dan een één-lagig recurrent neuraal netwerk.

4.1

training

Zoals in hoofdstuk 2 en 3 besproken gebruiken we het simpele stochastic gradient descent algoritme in combinatie met backpropagation through time bij de training. Om het netwerk te trainen moeten zoals in vorige hoofdstukken vermeld een aantal metaparameters gesweept worden. We maken dus gebruik van een validatieset om de beste parameters te vinden. Die worden dan gekozen en daarna trainen we het netwerk opnieuw met de trainings- en validatieset samen om dan de prestatie op de testset te bekijken. Als validatieset gebruiken we ongeveer 10 % van de gegeven trainingdata. Aangezien we bezig zijn met een multi-class classificatietaak gebruiken we als uitvoerfunctie g de softmax. Deze geeft een probabiliteit terug dat het te schatten foneem tot de k-de klasse behoort en dit voor elke klasse.

4.2 Resultaten

4.2

32

Resultaten

4.2.1

Hoe vergelijken?

Eén van de doelen van deze thesis, bestaat erin een DRNN met verschillende lagen te vergelijken met een RNN met één laag. Aangezien beide configuraties niet van hetzelfde aantal gewichtenmatrices gebruik maken moet er dus een eerlijke manier gevonden om onderling de prestaties te vergelijken. Aangezien het aantal coëfficiënten van de gewichtenmatrices afhangt van het aantal gebruikte neuronen per laag, zullen we deze zo aanpassen dat het totaal aantal gebruikte parameters (gewichtscoëfficiënten in alle gewichtenmatrices) gelijk is. Voor iedere invoermatrix Vi met i 6= 1 hebben we N × (N + 1), voor V1 hebben we N × d met d de dimensie van de invoer, voor Ai hebben we d × N en voor Wi hebben we N × N . Na optellen bekomen we voor het aantal parameters p in functie van het aantal neuronen per laag N en het aantal lagen L dat het DRNN bezit:

p = N d + (L − 1) N (N + 1) + L N 2 + L (N d)

(4.1)

= (2L − 1) N 2 + N [(d + 1) L + (d − 1)]

(4.2)

' (2L − 1) N 2 + d (L + 1) N

(4.3)

Deze tweede-graadsvergelijking in N kan dan gebruikt worden om, gegeven het totaal aantal parameters dat gebruikt kan worden, het juiste aantal neuronen per laag te berekenen. Bij de TIMIT-taak hebben we gebruik gemaakt van 400 000 parameters. Voor een DRNN van 1 tot en met 5 lagen geeft dit dan het aantal neuronen per laag in onderstaande tabel:

Aantal lagen L Aantal neuronen N

1 600

2

3

4

5

348

269

227

200

Eens we het aantal neuronen per laag weten, gaan we nu de metaparameters sweepen. Het is belangrijk dat we bij ieder netwerk (dus de DRNN’s met verschillend aantal lagen) dezelfde parameters gebruiken. Daarom gaan we het gemiddelde van de validatiefouten gebruiken als maat voor de prestatie van de metaparameters. Als batchgrootte hebben we een invoer van 50 tijdsstappen gekozen. Daarna is een invoerfactor gekozen van 0.005 a.d.h.v. het histogram van de activaties in de eerste laag. De uitvoerfactor kiezen we nul. De leersnel-

4.2 Resultaten

33

heid en het aantal iteraties zijn gesweept. − 38

[10−3 ,10

− 37

,10

− 53

,10−2 ,10

− 34

,10

,10−1 ,10

− 32

We hebben de leersnelheid η laten variëren in 1

,10− 3 ,1]. De beste validatiefouten werden bekomen

bij η = 0.1. Aangezien we η lineair laten dalen over het aantal iteraties is ook deze parameter niet vrij te kiezen. Na sweepen kiezen we 1.5M iteraties.

4.2.2

Vergelijken prestatie

Na het trainen willen we in eerste instantie weten hoe de prestatie zich verhoudt tot het aantal lagen er gebruikt worden in het DRNN. Als prestatie hebben we het volgende foutpercentage: De verhouding van het aantal misgeclassificeerde fonemen op het totaal aantal geclassificeerde fonemen. Net zoals bij het trainen laten we door het getrainde netwerk een uitvoer genereren aan de hand van de invoer van de testset. Dit geeft dan opnieuw een kansverdeling over de verschillende fonemen. Het foneem met de hoogste kans wordt gekozen en vergeleken met het targetfoneem van de testset. Herhalen we dit proces voor alle test-invoeren dan bekomen we het testfoutenpercentage. De resultaten voor een DRNN van 1 t.e.m. 5 lagen is te zien op Figuur 4.1.

Figuur 4.1: Testfout in functie van het aantal lagen L

We zien dat de trend die we hoopten te bekomen zichtbaar is. Bij een éénlagig RNN hebben we een testfout van 0,2856. De fout daalt per extra laag tot een fout van 0,2753 in een vijflagig DRNN wat een verbetering geeft van 0,0103. Deze verbetering is zichtbaar maar relatief klein. Hieronder een overzicht van de fout per aantal lagen:

4.2 Resultaten

Aantal lagen L Testfout

34

1 0.2856

2

3

4

5

0.2817

0.2789

0.2764

0.2753

Het eerste deel van het doel van de thesis kan dus bij deze toepassing positief geëvauleerd worden. Rest nog de vraag wat verantwoordelijk is voor deze verbetering in prestatie en of er een verband is met de context die per laag belangrijk is.

4.2.3

Context

Om een schatting te maken welke context onze DRNNs met zich meedragen, gaan we opnieuw gebruik maken van het backpropagation-algoritme. Deze keer echter, gaan we niet de gewichten trainen, maar de invoer. We starten met een willeukeurige invoer, propageren een aangepaste fout doorheen het al getrainde netwerk en passen de invoer aan, net zoals we deden bij de gewichtenmatrices. Zo bekomen we een ‘gewenste’ invoer door het netwerk. De aangepaste fout wordt zo ontworpen dat enkel het targetfoneem in één tijdsstap belangrijk is, wat ervoor gegeven wordt als uitvoer is niet belangrijk en de fout in iedere vorige tijdsstap wordt dus op 0 gebracht en niet teruggepropageerd. Toch zal de gewenste invoer ook vroeger in de tijd aangepast worden door de terugpropagatie doorheen de tijd, zie Figuur 4.2. Door deze gewenste invoeren uit te middelen over verschillende targetfonemen kunnen we dan een schatting van de context bekomen.

Deze schatting kan ons dan een idee geven van de context die het netwerk gebruikt, door te kijken naar hoe ver in de tijd er nog een relatief belangrijke invoer is. Gebruik makend van ridge regression zal ver in het verleden de gewenste invoer naar 0 convergeren. Ridge regression zorgt ervoor dat we bij iedere aanpassing van de te trainen invoer we een deel van de huidige invoer gaan aftrekken. In formule wordt dit: invoer’ = invoer − η gradient − λ invoer

(4.4)

waarbij λ de regressieparameter is. Deze bepaalt hoe sterk we de gewenste invoer willen onderdrukken. Als we geen gebruik zouden maken van ridge regression zou de ge¨ınitialiseerde invoer in het verleden waar ze niet belangrijk is, hoog blijven en dus een slechte schatting geven van de context.

4.2 Resultaten

35

Figuur 4.2: Het trainen van de ‘gewenste’ invoer verloopt in drie stappen: 1) De fout wordt enkel in de huidige tijdsstap (cirkel rechts) naar de laag in kwestie teruggepropageerd, hier is dat de tweede laag. Ze wordt dan doorheen die hele laag teruggepropageerd (boven). 2) De fout wordt doorheen het hele netwerk naar de invoer gepropageerd (onder). 3) De invoer wordt aangepast en dit proces herhaalt zich.

We willen nu, in plaats van de context-afhankelijkheid van heel het netwerk, laag per laag gaan schatten of elke toegevoegde laag ook een toegevoegde context heeft. In analogie met de hogere complexiteit per laag van een Diep Neuraal Netwerk. Om per laag te kunnen de gewenste invoer trainen, gaan we enkel de aangepaste fout terugpropageren naar de laag in kwestie. En niet naar alle lagen zoals wel werd gedaan in het gewone trainingsproces. Het trainingsproces werd gedaan met 1000 iteraties en een leersnelheid van 0.1. Het resultaat voor iedere laag is mooi samengevat in onderstaande figuur. We geven de genormeerde grootte’s weer van de gewenste invoer gesommeerd over alle invoerkanalen. Met andere woorden hebben we de gewenste invoer van elke laag gedeeld door de maximale waarde over alle tijdsstappen in de gewenste invoer van

4.2 Resultaten

36

die laag om beter te kunnen vergelijken tussen de verschillende lagen.

Figuur 4.3: Schatting context voor de verschillende lagen: We zien een steeds grotere context (grotere relatieve waarden in vroegere tijdsstappen per laag)

We zien mooi dat voor elke laag, de temporele context langer is. Bij de eerste laag wordt er slechts tot ongeveer 15 tijdsstappen teruggekeken om een schatting te maken van de uitvoer. Bij de vijfde laag wordt er al tot ongeveer 30 stappen teruggekeken in de tijd om diezelfde schatting te maken. We zien dus duidelijk dat een hogere laag, een langere context draagt. Vanzelfsprekend is het zo dat de eerste tijdsstappen terug in de tijd het belangrijkste zijn. Vandaar de hogere waarden.

Merk op dat we voor de regressieparameter met verschillende waarden hebben gewerkt (0.01 0.1 1 10) om te controleren dat de waarneembare trend geen gevolg is van louter ridge regression. Als we enkel met één regressieparameter zouden trainen, zou mogelijks de te observeren trend geforceerd zijn door ridge regression. De trend werd bij elke waarde van λ opnieuw gezien en dus is het voorgaande niet het geval. bovenstaande figuur is één voorbeeld met λ=10.

4.2 Resultaten

37

Om de gewenste invoer op een andere manier te trainen hebben we ook nog een variatie van het vorige algoritme gebruikt. Bij het vorige trainingsalgoritme werd in de voorwaartse propagatie niets veranderd in vergelijking met de normale training van de gewichtenmatrices van een DRNN.

We kunnen nu ook, om nog specifieker de functionaliteit van een enkele laag te gaan bekijken, ervoor zorgen dat enkel de laag in kwestie een verbinding met de uitvoer heeft. En dus wordt de uitvoer enkel berekend vanuit die laag als y = g(Alaaginkwestie hlaaginkwestie ) en is ze niet meer afhankelijk van de andere lagen. De andere lagen hebben dus geen rechtstreekse bijdrage meer en kunnen het resultaat van de gewenste invoer niet be¨ınvloeden. In het terugpropageren verandert er niets aangezien we al enkel terugpropageerden naar de laag in kwestie. De resultaten bij deze variatie zijn gelijkaardig. Dezelfde trend werd gezien en ook hier is de temporale context groter bij een hogere laag:

Figuur 4.4: Schatting context voor de verschillende lagen op de tweede manier: Dezelfde trend is te observeren als hiervoor)

4.2 Resultaten

4.2.4

38

Vergelijken invoer

Als laatste test kunnen we nu nog de gewenste invoer bekomen uit vorige paragraaf gaan vergelijken laag per laag en met een echte invoer uit de dataset bij het gegeven target. In onderstaande figuren zien we telkens dat de gewenste invoer voor iedere laag sterk verschilt met de echte invoer. Toch, kunnen we per stijgende laag telkens zien dat de gewenste invoer verder in het verleden teruggaat en dus de temporale context groter wordt. De bovenste figuur heeft targetfoneem 24 en werd getraind met λ=1. De middenste figuur heeft targetfoneem 17 en werd getraind met λ=0.1. En de laatste figuur heeft targetfoneem 6 en is getraind met λ = 0.03.

Figuur 4.5: Targetfoneem 21. Van linksboven naar rechtsonder: Echte invoer, Gewenste invoer laag 1 t.e.m. 5

4.2 Resultaten

39



4.3 Samengevat

4.3

40

Samengevat

De TIMIT-toepassing toont heel mooi aan wat nu net het voordeel is van de DRNN-architectuur. De extra lagen zorgen voor een betere prestatie met eenzelfde aantal toegelaten parameters. Dit kan worden uitgelegd door te kijken naar de gebruikte context. Iedere toegevoegde laag gaat rekening houden met fonemen uit een verder verleden. Zo kan een betere schatting worden gemaakt over welk foneem op de huidige tijdsstap gezocht wordt en dit vertaalt zich in de verbetering van de prestatie.

TOEPASSING 2: SYMBOLISCHE MUZIEK

41

Hoofdstuk 5

Toepassing 2: Symbolische muziek 5.1

introductie

Na de TIMIT-toepassing, is er als tweede toepassing symbolische muziek gekozen. Een DRNN immers is uitermate geschikt om een hiërarchie in de tijd te modelleren. Het ritme van muziek zou daar dus perfect bij moeten aansluiten. Na een korte literatuurstudie werd gevonden dat het aanleren van jazz-ritmes mogelijk is a.d.h.v. LSTM of long short term memory [Franklin, 2005] [Eck and Schmidhuber, 2002]. Dit is een speciaal type recurrent neuraal netwerk dat gebruik maakt van geheugenblokken om vele tijdsstappen terug te kunnen gaan kijken. Deze blokken zijn expliciet aanwezig in de architectuur terwijl het ons doel is om zo’n functionaliteit impliciet in de DRNN-architectuur te verkrijgen.

Het doel bij deze toepassing is dus een model van de muziek te maken en dan zo uiteindelijk ritme’s te leren of genereren. Om de moeilijkheid van de taak enigzins te beperken, is er gekozen om enkel te werken met klassieke pianomuziek. De zelfgemaakte dataset bestaat uit 106 muziekstukken in MIDI-formaat. Bij het MIDI-formaat, dat veel wordt gebruikt bij keyboards, wordt opgeslaan wanneer een noot ‘ingedrukt’ is en wanneer ze weer losgelaten wordt. Om nu deze MIDI-bestanden te verwerken naar een ideale invoer, is er een raster gemaakt met 25 punten per seconde voor iedere noot. Een rasterpunt staat aan als de noot speelt; het staat af als de noot niet aan het spelen is. Voor alle 127 noten in het MIDI-spectrum ontstaat dus een invoervector met dimensionaliteit 25 keer het aantal seconden. Kortweg wordt er dus om de 0.04 seconden gekeken welke noten aanliggen op dat moment. Diegene die aanliggen krijgen een 1 op die tijdsstap, de andere krijgen een 0 en dan wordt overgegaan op de volgende tijdsstap.

5.1 introductie

42

De grootte van de sample rate, m.a.w. het aantal rasterpunten per seconde, is een belangrijke afweging tussen het verliezen van informatie en de moeilijkheid voor het netwerk om een ritme te leren. Een noot die twee maal kort na elkaar gespeeld zou worden, zou met een te kleine samplerate als één noot ge¨ınterpreteerd worden, zie Figuur 5.1. Daar staat tegenover dat hoe meer tijdsstappen een DRNN in het verleden context nodig heeft, hoe moeilijker het wordt deze nog mee te dragen (door onder andere het vanishing gradient probleem) en dus hoe moeilijk het zal worden om een ritme aan te leren.

Figuur 5.1: Raster voor verschillende samplerates Het trainingsalgoritme vertoont kleine aanpassingen t.o.v. de TIMIT-toepassing. Daar verschillende noten tergelijkertijd kunnen gespeeld worden, kunnen we dus geen gebruik meer maken van de softmax uitvoerfunctie. Deze waarborgt immers één gespeelde noot in plaats van verschillende noten tergelijkertijd. Om dit probleem op te lossen gaan we voor ieder kanaal apart, dus voor iedere noot, een sigmoidfunctie als uitvoer gebruiken. Deze zal dan ook per kanaal (en niet meer gezamenlijk zoals bij de softmax) een probabiliteit als uitvoer geven of de noot al dan niet gespeeld wordt. Deze aanpassing van de softmax-functie in de sigmoidfunctie verandert niets aan het backpropagation trainingsproces. Om dezelfde reden als hiervoor, namelijk dat er meerdere noten tergelijk kunnen gespeeld worden, zal ook de kostfunctie en de fout anders gedefinieerd worden. We gebruiken nu de crossentropy kostfunctie en fout. Met t de targets en p de probabiliteiten gegeven als uitvoer wordt deze gedefinieerd als: cross-entropy error = −

N X i=1

[ti log pi + (1 − ti ) log(1 − pi )]

(5.1)

Deze cross-entropy fout zal gebruikt worden om de prestatie van het netwerk te kunnen beoor-

5.2 Prestatie

43

delen. Het geeft een maat voor de overlap tussen de berekende probabiliteiten door het netwerk en de targets. De targets in het geval van een voorspellend netwerk zijn de invoeren van de volgende stap, net zoals bij de roodkapje taak.

5.2

Prestatie

Na dezelfde stappen te doorlopen als bij de TIMIT-toepassing (sweepen hyperparamaters met validatieset, netwerk trainen en testen op testset) bekomen we de prestatie voor de muziektoepassing. Als validatieset hebben we hier de middenste 10% gekozen van de data. Als leersnelheid η hebben we 0.5 met 20000 iteraties. Opnieuw daalt de leersnelheid lineair naar nul. Als invoerschaling gebruiken we 0.1 en in tegenstelling tot de TIMIT-taak hebben we hier wel een uitvoerschaling gebruikt. Als we alle uitvoergewichten op nul zetten om te initialiseren merken we dat de uitvoeren allen identiek blijven en dus geen ritme wordt geleerd. Vandaar is de uitvoerschaling 2 gekozen om te starten met een variatie in de uitvoeren. Om een ritme te kunnen leren is er gekozen voor een grote batchgrootte van 500 ofwel 20 seconden aan een samplerate van 25. Bij deze toepassing maken we gebruik van een netwerk van 166 200 parameters. Dit komt overeen met het volgende aantal neuronen per laag voor ieder DRNN:

Aantal lagen L Aantal neuronen N

1 300

2

3

4

5

180

138

115

100

Op Figuur 5.2 zien we dat er een nog relatief grote verbetering is door het toevoegen van lagen. De prestatie verbetert met 0.0155. De fout per laag wordt gegeven in onderstaande tabel: Aantal lagen L Cross-entropy fout

1 0.0390

2

3

4

5

0.0265

0.0249

0.0243

0.0235

Om te onderzoeken hoe dit komt, gaan we opnieuw een gewenste invoer laten trainen door het netwerk. Net als bij TIMIT slaan we de gewichtenmatrices op na de training van het vijflaagse DRNN en gebruiken we die om de invoer te gaan trainen. De leersnelheid hier werd groter gekozen, namelijk 10. De regressieparameter is echter kleiner, namelijk 10−4 . Na 1000 iteraties en uitmiddelen over verschillende targetnoten, bekomen we dan zo Figuur 5.3. Deze is genormeerd zodanig dat we een zicht krijgen op de relatieve context die werd gebruikt. We zien

5.2 Prestatie

44

Figuur 5.2: Cross-entropy fout in functie van het aantal lagen L inderdaad dat de eerste 3 lagen een steeds langere context dragen. Het gedrag van de vierde en vijfde laag wijkt af van wat we eerder zagen. Alle 50 tijdsstappen in het verleden die getraind werden, blijken even belangrijk te zijn. De reden hiervoor is dat we de relatieve waarde bekijken t.o.v. het maximum in elke laag. Stellen we Figuur 5.3 voor op een absolute niet-genormeerde manier dan bekomen we Figuur 5.4. Hier is duidelijk te zien waarom elke invoer even belangrijk is bij de vierde en vijfde laag. De absolute waarde van de gewenste invoer van de vierde en vijfde laag is immers veel kleiner dan bij de eerste 3 lagen, en is zo goed als nul. Vandaar dat de relatieve gewenste invoer overal groot was.

Figuur 5.3: Relatieve gewenste invoer per laag

5.2 Prestatie

45

Figuur 5.4: Absolute waarde gewenste invoer per laag

Als laatste bekijken we dan nog eens of dit zich op een gelijke manier vertaald in de functionaliteit van een drie-laags DRNN. Het resultaat van de gewenste invoer is te zien in Figuur 5.5. Inderdaad, de context-afhankelijkheid van de derde laag in een drie-laags DRNN blijkt even groot te zijn als in een vijf-laags DRNN, desondanks dat er meer neuronen per laag gebruikt worden. Het lijkt erop dat bij het gebruikte trainingsproces we niet de benodigde context kunnen aanleren aan de vierde en vijfde laag van het DRNN.

Figuur 5.5: Relatieve gewenste invoer per laag

5.3 Alternatieve leermethode

46

Als we nu de context beter bekijken zien we dat er in de derde laag tot ongeveer 30 tijdsstappen terug wordt gegaan. Aan een samplerate van 25 per seconde, staat 30 tijdsstappen voor amper 1.2 seconden aan context. Gezien de taak is om ritme’s in muziek zelf te leren en dan voornamelijk om te leren wanneer een nieuwe noot wordt gespeeld, lijkt een context van 1.2 seconden erg weinig en onvoldoende om de taak op een goeie wijze te volbrengen, ondanks de lage crossentropy error. Dit vraagt dus om een nadere vergelijking van de output y van het netwerk en de targets die hierbij horen. Het resultaat van één zo’n noot zien we gedeeltelijk in Figuur 5.6. Om duidelijk te tonen waar het probleem zit is er sterk ingezoomd op de overgang van een niet gespeelde noot naar een wel gespeelde noot. Het probleem lijkt zeer duidelijk. Het netwerk leert enkel om noten te herhalen, maar heeft moeite om zelf de overgangen te voorspellen. Daarom komt de output y, dus één tijdsstap achter de targets. Niet enkel bij deze noot en deze overgang is dit zo, het blijkt bijna overal zo te zijn. Het vermoeden van een niet lang genoege context wordt door dit fenomeen dus versterkt. In een laatste poging om toch een netwerk te verkrijgen die wel ritme’s kan modelleren, is er voor de taak nog een andere leermethode gebruikt.

Figuur 5.6: Vergelijking uitvoer netwerk versus target

5.3

Alternatieve leermethode

Om nu te focussen op het leren van de overgangen en niet op het enkel reproduceren van de laatste gespeelde noten, gaan we een alternatieve leermethode gebruiken. Deze is deels vergelijkbaar met de leermethode van de gewenste invoer. In die zin dat we een speciale fout gaan gebruiken om terug te propageren doorheen het netwerk en om dus de gewichtenmatrices te trainen. Op de tijdsstappen waar een overgang is, gaan we de fout vermenigvuldigen met een factor, zodanig dat deze tijdsstappen belangrijker zijn in het trainingsproces. Op die manier hopen we toch een

5.3 Alternatieve leermethode

47

DRNN te krijgen die overgangen en ritme’s in muziek kan leren. Als factor hebben we 2, 5, 10 en 100 geprobeerd. De prestatie van het netwerk bleef grotendeels onveranderd zoals te zien op Figuur 5.7. De kleine cross-entropy error van ongeveer 0.0245 is dus bijna volledig ontstaan door het herhalen van de laatste invoer en niet door het leren van de overgangen. Zelfs wanneer we de fout enkel behouden bij een overgang en op nul zetten bij een niet-overgang kwam er geen verbetering in.

Figuur 5.7: Prestatie alternatieve leermethode t.o.v. het aantal lagen Wanneer we dan gaan vergelijken tussen de uitvoer en de targets, zien we inderdaad in elk van voorgaande gevallen dat opnieuw de uitvoer één tijdsstap achterloopt op de targets. Een voorbeeld is gegeven in Figuur 5.8.

Figuur 5.8: Voorbeeld bij vergelijken uitvoeren van alternatieve leermethode t.o.v. targets

5.4 Voorspellen muziek

5.4

48

Voorspellen muziek

Desondanks het minder presteren van het netwerk op het leren van ritme’s, zijn we toch gaan kijken of het zelf muziek kan genereren. Om dat te doen starten we met een initialisatie en laten we het netwerk dan verder aanvullen. De uitvoer op de eerstvolgende stap na de initialisatie geeft dan de probabliteit weer van de noot staat aan of uit. Uit deze probabiliteiten voor iedere noot worden dan de nieuwe invoeren gesampled. Op die manier wordt er ‘muziek’ gegenereert door het netwerk. Hieronder staan verschillende voorbeelden van de gegenereerde uitvoer. De initialisatie is te zien vanaf tijdsstap 1200.

Figuur 5.9: Gegenereerde muziek door het getrainde netwerk. De initialisatie loopt tot tijdsstap 1200.

Figuur 5.10: Gegenereerde muziek door het getrainde netwerk. De initialisatie loopt tot tijdsstap 1200.

5.5 Samengevat

49

We zien dat er door het netwerk overgangen worden gemaakt van noot aan naar noot uit. Toch hebben deze overgangen al heel snel niets meer te maken met het ritme dat de initialisatie aangeeft. Als we eens gaan inzoomen naar net na het einde van de initialisatie zien we volgende figuur:

Figuur 5.11: Gegenereerde muziek door het getrainde netwerk. Ingezoomd rond het einde van de initialisatie. De eerste tijdsstappen lijkt het nog deftig te verlopen, maar na 20 tijdsstappen is het het ritme dus al volledig kwijt. De generatie van muziek vertoont dus alles behalve ritme, maar creëert wel overgangen van aan naar uit.

5.5

Samengevat

Ondanks de goeie prestatie en de aangetoonde langere context per laag, lijkt het DRNN niet geschikt voor deze taak. De gebruikte context is niet groot genoeg om muzikale ritme’s te kunnen aanleren. Dit komt waarschijnlijk door een te hoge samplerate, deze kan moeilijk verder gereduceerd worden zonder verlies van informatie en dus de invoer muzikaal te vervormen. Het netwerk heeft grote moeilijkheden met het zelf voorspellen van overgangen in geleerde data en blijft vaak enkel de vorige invoer reproduceren. Zelfs bij een alternatieve leermethode die focust op enkel de overgangen van de noten tussen aan en af, blijkt er weinig verbetering te zijn. Het doel van de thesis is dus wel aangetoond (betere prestatie en hogere context), maar de taak op zich is niet echt geslaagd.

CONCLUSIE

50

Hoofdstuk 6

Conclusie Het Diep Recurrent Neuraal Netwerk (DRNN) is een interessante uitbreiding van een gewoon recurrent neuraal netwerk terwijl het trainingsalgoritme weinig complexer wordt. Naar analogie met een diep neuraal netwerk, zouden de extra toegevoegde lagen een stijgende complexiteit moeten waarborgen en dus een betere prestatie. De hypothese dat het een betere prestatie zou teweeg brengen werd in deze thesis getoetst aan twee toepassingen. De betere prestatie werd verwacht vooral een gevolg te zijn van een verbetering van de grootte van de context. Deze grotere context wordt gebruikt om een betere invulling van de taak in kwestie te verkrijgen. De eerste toepassing is een eerder standaard taak. Spraakherkenning aan de hand van de TIMIT dataset moest aantonen of de hypothese al dan niet correct is. En inderdaad, de prestatie afgebeeld op Figuur 4.1 blijkt te verbeteren in functie van het aantal lagen dat het DRNN gebruikt. Dat dit het gevolg is van de stijgende context-afhankelijkheid volgt uit de gewenste invoer voor iedere laag in een getraind DRNN. Figuur 4.3 toont op een mooie manier het vorige aan. Hoe hoger de laag, hoe verder in het verleden gekeken wordt om een schatting te maken van het juiste target-foneem. De tweede meer uitdagende taak bestond erin ritme’s te leren uit symbolische muziek. Aan de hand van een eigen dataset gemaakt uit klassieke piano muziek werd een DRNN getraind. Hoewel de prestatie en de context-afhankelijkheid positief kunnen beoordeeld worden op Figuur 5.2 en Figuur 5.3 bij een stijgend aantal lagen, toont deze taak toch een pijnpunt aan van het DRNN. Het lijkt zo te zijn dat de correcte context aanleren erg uitdagend is. De context in ons DRNN is maar 1.2 seconden (aan een samplerate van 25/sec) en dus te weinig om echte ritme’s in muziek te kunnen ontdekken en aanleren. Overgangen tussen noot aan en uit worden dus amper aangeleerd en het netwerk reproduceert vooral de laatste invoer bij de training. Het genereren

CONCLUSIE

51

van muziek lukt dan weer wel, mede door de sampling van de uitvoer. Resultaten daarvan zijn te zien in Figuur 5.9 en Figuur 5.10, maar het DRNN kan geen ritme’s aanhouden.

BIBLIOGRAFIE

52

Bibliografie [Bishop et al., 2006] Bishop, C. M. et al. (2006). Pattern recognition and machine learning, volume 1. springer New York. [Boyd and Chua, 1985] Boyd, S. and Chua, L. O. (1985). Fading memory and the problem of approximating nonlinear operators with volterra series. Circuits and Systems, IEEE Transactions on, 32(11):1150–1161. [Chen, 1982] Chen (1982). Topological structure in visual perception. Science, 218:699. [Doya, 1993] Doya, K. (1993). Bifurcations of recurrent neural networks in gradient descent learning. IEEE Transactions on Neural Networks, 1:75–80. [Eck and Schmidhuber, 2002] Eck, D. and Schmidhuber, J. (2002). Learning the long-term structure of the blues. In Artificial Neural NetworksICANN 2002, pages 284–289. Springer. [Franklin, 2005] Franklin, J. A. (2005). Jazz melody generation from recurrent network learning of several human melodies. In FLAIRS Conference, pages 57–62. [Garofolo et al., 1993] Garofolo, J. S., Lamel, L. F., Fisher, W. M., Fiscus, J. G., and Pallett, D. S. (1993). Darpa timit acoustic-phonetic continous speech corpus cd-rom. nist speech disc 1-1.1. NASA STI/Recon Technical Report N, 93:27403. [Graves, 2013] Graves, A. (2013). Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850. [Graves et al., 2013] Graves, A., Mohamed, A.-r., and Hinton, G. (2013). Speech recognition with deep recurrent neural networks. In Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on, pages 6645–6649. IEEE. [Hermans and Schrauwen, 2013] Hermans, M. and Schrauwen, B. (2013). Training and analysing deep recurrent neural networks. In Burges, C., Bottou, L., Welling, M., Ghahramani, Z.,

BIBLIOGRAFIE

53

and Weinberger, K., editors, Advances in Neural Information Processing Systems 26, pages 190–198. Curran Associates, Inc. [Hochreiter and Schmidhuber, 1997] Hochreiter, S. and Schmidhuber, J. (1997). Long shortterm memory. Neural computation, 9(8):1735–1780. [Ku and Lee, 1995] Ku, C.-C. and Lee, K. Y. (1995). Diagonal recurrent neural networks for dynamic systems control. Neural Networks, IEEE Transactions on, 6(1):144–156. [LeCun and Bengio, 1995] LeCun, Y. and Bengio, Y. (1995). Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, 3361. [LeCun and Cortes, 1998] LeCun, Y. and Cortes, C. (1998). The mnist database of handwritten digits. [Martens, 2010] Martens, J. (2010). Deep learning via hessian-free optimization. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), pages 735–742. [Mitchell, 1999] Mitchell, T. M. (1999). Machine learning and data mining. Communications of the ACM, 42(11):30–36. [Pang et al., 2002] Pang, B., Lee, L., and Vaithyanathan, S. (2002). Thumbs up?: sentiment classification using machine learning techniques. In Proceedings of the ACL-02 conference on Empirical methods in natural language processing-Volume 10, pages 79–86. Association for Computational Linguistics. [Pascanu et al., 2013] Pascanu, R., Gulcehre, C., Cho, K., and Bengio, Y. (2013). How to construct deep recurrent neural networks. arXiv preprint arXiv:1312.6026. [Rabiner, 1989] Rabiner, L. (1989). A tutorial on hidden markov models and selected applications in speech recognition. Proceedings of the IEEE, 77(2):257–286. [Roman and Jameel, 1996] Roman, J. and Jameel, A. (1996). Backpropagation and recurrent neural networks in financial analysis of multiple stock market returns. In System Sciences, 1996., Proceedings of the Twenty-Ninth Hawaii International Conference on,, volume 2, pages 454–460. IEEE. [Samuel, 1962] Samuel, A. L. (1962).

Artificial intelligence–a frontier of automation.

Information Technology, 4(1-6):173–177.

it-

BIBLIOGRAFIE

54

[Sutskever et al., 2011] Sutskever, I., Martens, J., and Hinton, G. E. (2011). Generating text with recurrent neural networks. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pages 1017–1024. [Vallabhaneni et al., 2005] Vallabhaneni, A., Wang, T., and He, B. (2005). Braincomputer interface. In Neural Engineering, pages 85–121. Springer. [Viola and Jones, 2001] Viola, P. and Jones, M. (2001). Rapid object detection using a boosted cascade of simple features. In Computer Vision and Pattern Recognition, 2001. CVPR 2001. Proceedings of the 2001 IEEE Computer Society Conference on, volume 1, pages I–511. IEEE. [Werbos, 1990] Werbos, P. J. (1990). Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10):1550–1560.

het leren van hiërarchieën van tijdsschalen met diepe recurrente neurale netwerken

Recommend Documents