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¨urgen 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¨urgen 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¨ele neuron en ´e´enlagig 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¨ele 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¨ele 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´e´enschakeling van artifici¨ele 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¨eeren.
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´en 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´en verborgen laag: Dit netwerk bestaat uit ´e´en laag neuronen. Hieraan is een invoer verbonden
en een uitvoer zoals te zien is op Figuur 1.4. Dit ´e´en-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 ´e´en 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¨erarchische structuur van het netwerk makkelijker een hi¨erarchische 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¨ele data is het zo
dat een context vaak belangrijk is. Een recurrent neuraal netwerk is een ´e´enlagig 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 ´e´enlagig 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 ´e´enlagig netwerk vormt. Om dit iets duidelijker te maken gaan we de
werking van dit ´e´enlagig 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´en-lagig neuraal netwerk horende bij MNIST handschriftherkenning
2.1 Het artifici¨ele neuron en ´e´enlagig 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 ´e´enlagig 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 ´e´en 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¨ele neuron en ´e´enlagig 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´en neuron zou dus nooit voldoende zijn geweest en een eenvoudig ´e´enlagig 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 ´e´en-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¨erarchisch 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 ´e´enlagig 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¨erarchische 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 ´e´en-lagig standaard neuraal netwerk als op Figuur 2.1. Het
recurrente neurale netwerk heeft ´e´en zo’n netwerk per tijdsstap in de sequenti¨ele reeks, echter
zijn de tussenliggende gewichten dezelfde voor ieder van die ´e´en-lagige netwerken. Met andere
woorden kopi¨eren we het ene ´e´en-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¨eeren. Om schematisch afbeeldingen
te vereenvoudigen in wat volgt, zullen we elke laag neuronen vervangen door ´e´en knooppunt in
2.3 Recurrente neurale netwerken
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 ´e´en-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 ´e´en invoer per tijdsstap door een ´e´en-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 invoer- en uitvoergewichtenmatrices V en A uit de vorige paragrafen en voegen daar de
2.3 Recurrente neurale netwerken
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)
2.4 Het backpropagation algoritme
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¨ent 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¨ent 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¨ent vermenigvuldigd worden.
Als we nu gaan kijken naar een ´e´enlagig netwerk zullen we hetzelfde patroon zien verschijnen
bij de berekening van de gradi¨ent 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.
2.4 Het backpropagation algoritme
16
De gewichtenmatrix A naar de uitvoer en de invoergewichtenmatrix V. De berekening van de
gradi¨ent 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¨enten 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 Het backpropagation algoritme
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 ´e´enlagig 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 ´e´en knooppunt gaan.
4. Zodra elk knooppunt geassocieerd is met een fout, bereken dan de gradi¨enten 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 ´e´en 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 Het backpropagation algoritme
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.
2.4 Het backpropagation algoritme
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¨enten 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´en 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¨ent 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¨ent 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¨ent voor de gewichtsaanpassing
te normaliseren. Dit zorgt ervoor dat deze laatste niet kan ontploffen en dat het leerproces
2.4 Het backpropagation algoritme
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¨ent
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¨ent wanneer die berekend wordt
aan de tijdsstap van die vroegere invoer al te klein zijn om nog een effici¨ente 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¨eeren.
Om het netwerk te trainen gebruiken we het verhaal van roodkapje. Een invoer per tijdsstap
wordt dan ´e´en 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¨erd.
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¨ent 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¨ele 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 ´e´en tijdsstap
slechts door ´e´en 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¨erarchisch 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¨erarchi¨en 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 ´e´en van. Daarnaast stelt hij ook voor om tussen de recurrente
neuronenlagen in de tijd een extra diepte te cre¨eeren. 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 ´e´en 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 ´e´en 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¨ent 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 ´e´en 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 ´e´en-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´en van de doelen van deze thesis, bestaat erin een DRNN met verschillende lagen te vergelijken
met een RNN met ´e´en 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¨effici¨enten van de gewichtenmatrices afhangt van het
aantal gebruikte neuronen per laag, zullen we deze zo aanpassen dat het totaal aantal gebruikte
parameters (gewichtsco¨effici¨enten 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¨eren 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 ´e´enlagig 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¨evauleerd 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 ´e´en 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 ´e´en 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 ´e´en 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
Figuur 4.6: Targetfoneem 18. Van linksboven naar rechtsonder: Echte invoer, Gewenste invoer
laag 1 t.e.m. 5
Figuur 4.7: Targetfoneem 8. Van linksboven naar rechtsonder: Echte invoer, Gewenste invoer
laag 1 t.e.m. 5
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¨erarchie 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 ´e´en 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 ´e´en 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 ´e´en 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 ´e´en 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 ´e´en 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¨eert
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.

Manwolf pdf free

PO: Informatica Olympiade 2013-2014

Should I Stay or Should I Go? - UC Leuven

Uitleg over de digitale VDO tachoraaf

Verstoringen Douanesystemen

Verticale plaatsing 143 mm gevelpanelen

Nieuws - meest recent | SOK | Kortrijk

Diamond V XP gistcultuur verbetert groei en opname van HF

Download de samenvatting (PDF)

Aanvullingen Markovketens Alternatief bewijs Stelling 4.21 We

NASIONALE SENIOR SERTIFIKAAT GRAAD 12 GRADE 12

Klik hier voor een PDF overzicht

ER-A411 ER-A421

BAM Groep

"I am a strange loop" by Douglas Hofstadter

Optie waardering: Black-Scholes model In vergelijking met Neurale

Ruimtelijke opgave Atelier 1: draagvlak Atelier 2: voorstellen

Print naar pdf - Gemeente Aartselaar