Welcome back to the final part of our video series on recurrent neural networks and today

we want to talk a bit about sampling of recurrent neural networks.

And when I mean sampling, I mean that we want to use recurrent neural networks to actually

generate sequences of symbols.

So how can we actually do that?

Well, if you train your neural networks in the right way, you can actually create them

in a way that they predict the probability distribution of the next element.

So if I train them to predict the next symbol in the sequence, you can also use them actually

for generating sequences.

And the idea here is that you start with the empty symbol and then you use the RNN to generate

some output and then you take this output and put it into the next state's input.

And if you go ahead and do so, then you can see that you can actually generate whole sequences

from your trained recurrent neural network.

So the simplest strategy is to perform a greedy search.

So here we start with the empty symbol and then we just pick the most likely element

as the input to the RNN in the next state and generate the next one and the next one

and the next one.

And this then generates exactly one sample sequence per experiment.

So this would be a greedy search and you can see that we exactly get one sentence that

is constructed here and the sentence that we are constructing here is, let's go through

time.

Well, the drawback is of course, there's no look ahead possible.

So let's maybe the most likely after let's go.

So you could be generating loops like let's go, let's go and so on.

So you're not able to detect that let's go through time has a higher total probability.

So it tends to repeat sequences of frequent words and the sum and so on in speech.

And now we are interested in alleviating this problem and this can be done with a beam search.

Now the beam search's concept is to select the K most likely elements and K is essentially

the beam width or size.

So here you then out of all possible sequences, you have the one with these K elements as

prefix and take the K most probable ones.

So in the example that we show here on the right hand side, we start with the empty word

and then we take the two most likely ones, which would be let's and through and then

we generate let's as the next one.

If we take through, if we take let's, we generate go and we can continue this process and with

our beam of size two, we can keep the two most likely sequences in the beam search.

So now we generate two sequences at a time.

One is let's go through time and the other one is through let's go time.

So you see that we can use this beam idea to generate multiple sequences and then in

the end we can determine which one we like best or which one generated the most total

probability.

So we can generate multiple sequences in one go, which typically then also contains better

sequences than in the greedy search and I would say this is one of the most common techniques

actually to sample from an RNN.

Of course, there's also other things like random sampling and here the idea is that

you select the next one according to the output probability distribution.

You remember we encoded our vectors as one hot encoded vectors and then we can essentially

interpret the output of the RNN as a probability distribution and then sample from this distribution.

This then allows us to generate many different sequences.

So let's say if let's has an output probability of point eight, it is sampled eight out of