Original subtitles

1

Hello and welcome back to the course on computer vision.

2

Today we're going to find out how Gannes work.

3

So this is gonna be an interesting tutorial.

4

Some exciting slides prepared ahead.

5

It's going to be quite long so prepare yourself for that.

6

And let's dive straight into it.

7

All right.

8

So as we discussed Gannes stands for generative adversarial networks and we're going to go through these

9

letters one by one and then we'll get to the training part of the gang which is the exciting part.

10

All right so G stands for generative and this is a model which takes as input a random noise a signal

11

and then it can output an image.

12

The adversarial part stands for the discriminator.

13

It's another model which is going to be rivalling the generators going to be the opponent of the generator.

14

You can think of the generator as like a thief or somebody who's trying to forge dollar bills and discriminator

15

as as the police officer as the detective.

16

Oh there you go Dee for Detective so is going to be the revival of the generator and diesel model which

17

is capable of learning about objects animals or people or basically certain features or a cable or blurring

18

features.

19

For instance if you show with lots of dogs and then you show it lots of non dogs it will be able to

20

offer that discriminate between dogs and not dogs.

21

So in an ideal world if you show the discriminator of this image it'll say zero.

22

I will give it a zero probability that it's a dog.

23

And if you show it this image it will give it a warning and give it a 100 percent probability that it's

24

a dog.

25

So that is the ideal world.

26

Now we're going to get oh now we have it.

27

And so that's why this is where we have this little animation you see.

28

There we go the network letters jumping around.

29

And that stands for the fact that these two models are actually neural networks so we're going to replace

30

them with neural networks because that's what they are.

31

So we've got a neural network on the left a neural network on the right and why that's important is

32

because as we discussed in annex to the course about neural networks hopefully you checked that out.

33

They are capable of learning that's where you know the weights of those synopses that we see in blue.

34

They are that's where information that's where the training is going to go that's where the those weights

35

are going to be updated so that the neural networks.

36

All right.

37

So we discussed the letters.

38

Let's go through the training.

39

Exciting times.

40

All right.

41

Step one.

42

Basically all of the steps.

43

It's not like step one step two step three that you need to Conseco really not that different.

44

There is always going to be repeating the same step.

45

We're going to be doing it many times in fact here in this intuition tutorial we're going to do it three

46

times in the practical tutorials are going to do with hundreds and thousands of times.

47

But intuition is going to be enough.

48

But basically you will see how the networks evolve over the iteration.

49

So every step is an iteration.

50

Don't confuse step with espagnol and pork is after you've done your steps.

51

That's one epal and then you do another book that's you do all the steps again and again.

52

So you'll see that in the practice but back here what we have is step one.

53

We input the noise signal into a noise signal a random noise signal into our generator.

54

It just basically kind of like gives it some random this to generate from it.

55

It needs to start somewhere and then it generates some images.

56

These images are as you can see completely useless completely random images.

57

And at this stage what we want to train is we want to train the discriminator.

58

So this is what we're going to be doing and you will see exactly the same steps in the practical tutorials

59

and this is how the generative adversarial networks concept or

60

algorithm was really like was designed in the first place.

61

So first we train the discriminator.

62

And as we discussed we want the descriptor to be able to distinguish between for instance we're going

63

to stick with the example of dogs between dogs and non-dog.

64

So we need to give it in addition to these random images we generated we need to give it some dog images.

65

So there you go.

66

We've got some dog images and so we're going to input these a batch of batch of non-dog images and a

67

batch of dog images.

68

We're going to put them into the discriminator and we'll see what probabilities this community will

69

spit out.

70

And remember the discriminator knows nothing at this stage hasn't been trained at all.

71

This is the very first step.

72

None of these two models have been trained so the discrimination might spit out numbers like this for

73

instance zero point or point trees or open fire like quite high probabilities for the images at the

74

top that they're dogs.

75

Even though we can see they're not dogs discriminate has never seen a dog before so it might give them

76

some you know just based on its initial configuration which is you know some probably doesn't really

77

worry us at this stage.

78

It's got to start somewhere again.

79

But you're going to start somewhere and we will fix this as a goal as a train that will fix this and

80

then it give some probabilities to the images below.

81

Even though we know their dogs discriminate has never seen a dog before.

82

It just gives them some believe that happened to be the outputs of this neural network at this point

83

in time or at this stage.

84

At the very beginning at the very first stage.

85

So what happens next is we take these values and we look at what they should have been.

86

So we as humans because we are training this neural network we know what each of outputs in the ideal

87

scenario and ideal scenario the top values should have been zeros the bottom values should have been

88

ones.

89

So the top owlish top our pictures are not dogs so they should have caught on a 0 percent likelihood

90

of being dogs.

91

Bottom one should have grown 100 percent like a big dog so that's ideal world.

92

Obviously our model isn't ideal but it can learn from this.

93

So what's going to happen is the era is going to be calculated so basically in every single case the

94

values will be subtracted more from each other so zero zero point AIDS or about 0.3 or or 0.5 and 1

95

0.1 minus 1 and so on.

96

So all those will be subtracted then the cumulative error will be calculated and will be back propagate

97

through the network of the discriminator.

98

So if you have and you're not familiar with the term back propagation then I highly recommend checking

99

an annex on this course where you talk about artificial neural networks and can do it on your own networks

100

and you will be up to after that you'll be up to speed with everything we discussed including back propagation.

101

It's quite a lengthy consequence we're going to discuss it here but if you are we're back propagation

102

and this is exactly what's happening here.

103

These errors are back propagated through a network and the weights on the network are a bit dated.

104

So there we go.

105

Now the discriminator has learned that that was basically the learning process of this has learned from

106

his mistakes and next time is going to do a better job.

107

And now we want to train the generator.

108

So this part of our Gamme and how we're going to trend generation is we're going to take the same image

109

images that we've created this batch of images which are supposed to be dogs and we're going to use

110

them again.

111

So a quick note here is that you'll notice that this is exactly what we did in the practical Tauriel.

112

We took the images that were indeed there we had generated for the training of the discriminator and

113

we use the same images in his paper.

114

Ian Goodfellow recommends taking image generating new images.

115

So running the noise part and the generation part again and using those images for the train or generator

116

we just use the same images and it worked fine.

117

It's up to you how you want to go.

118

You might want to experiment with this part in the practical if you like or just follow along with our

119

tutorials and the networks worked really well.

120

But just so that you're aware of what it is.

121

Originally in the paper by in good form.

122

OK so we're going to take those images and we're going to run them through the discriminator again but

123

this time we don't need any dog images because the way that the generator learns is by trying to trick

124

the discriminator and based on whether it succeeds or not it will update its way so it doesn't need

125

to compare to any dogs or dogs it just needs to try and trick the discriminator as the other discriminator

126

will provide an output as you can see the output is different to what it had before because it has already

127

being trained itself and therefore knows what to what a dog can kind of more or less it knows what a

128

dog looks like and it knows what a dog doesn't look like.

129

And as you can see here the numbers are not all like 0 0 0 and they're kind of close to zero they're

130

lower but they're not just older or 0 0 because it takes time for the discriminator to learn is one

131

this illustrates the concept that why these two should be training at the same time because if you for

132

instance the discriminator was very well trained like it was it had been trained for a very long time

133

where I was trained separately and up until two to a very good level then and then and the generator

134

was only being trained now than the discriminator would always like completely completely get leave

135

no chances for the from the generator.

136

And that's why the will be like You're too smart for the generator the it would have no chances of tricking

137

those discriminator.

138

But that would be not good for anybody.

139

They have to they have to train together.

140

They have to kind of get better and better and better with time together and so.

141

So what we're going to do now is we're going to take these values and we're going to compare them to

142

what it should be.

143

And you know what these values should have been like what would you what would you compare them to.

144

You compare them to zero.

145

But this time we're going to compare them to one because now our objective is different prove you are

146

training the discriminator now entering the generator and for the generator it wants to trick the discriminate.

147

Once those values to be ones as it can see those values are much less than ones who calculate the error

148

and calculate the difference between between each value on one and you'll take the aggregate era and

149

it will buy and that era will be back propagated through the network of the discretion of the generator.

150

This time around.

151

And so that's going to allow the generator to now update its way its They go so as you can see it in

152

a day that it's weights there.

153

And now this time.

154

Now next time round they will know it will do a better job will be to do a better job of generating

155

the images because now it knows that this wasn't wasn't good enough.

156

So it knows how to hold that awaits him up there to improve that result.

157

And again this is this all boils down to neural networks and the process of back propagation and gradient

158

descent and the casting gradient descent which happens in the neural network.

159

So those are concepts that are required in order for if you like to understand in in detail how this

160

is happening and those concepts we discussed in the annex.

161

OK.

162

So that was the first step.

163

All right.

164

So let's move on to Step 2.