Original subtitles

1

Hello and welcome to this new tutorial.

2

Previously we did find a generator through our class C which contains the architecture of the neural

3

network inside the init function and the forward function to propagate the signal inside this architecture.

4

And now that we have defined the class we were ready to create as many objects as we want there is as

5

many generators as we want but we only need one and that's the one we'll create.

6

And the Statoil.

7

So to create an object of the class we need to choose a name for this object.

8

And the name will choose is not g for as you might have guessed the neural network of the generator

9

G and then to create a new object of the class.

10

While there is nothing more simple you take your G class and then you add some parenthesis.

11

Why do you only need to add some parenthesis.

12

It's because in the arguments of the class we only inherited from the end module and we didn't put any

13

argument.

14

So basically there is no argument and therefore there is an argument in put here.

15

Hence the only parenthesis.

16

Perfect.

17

And so in the flashiest of the flashes we got our generator neural network.

18

Congratulations.

19

And now as I said in the end of the previous Statoil we need to initialize the weights the proper way

20

to respect the convention of the adversarial networks and to do this we have the weights in a function

21

that can do that for us.

22

So I'm quickly going to explain what it's going to do.

23

As you can see we start with the class name variable.

24

There is some kind of a research tool that will look for some names in the definition of the class so

25

it will look for some names inside this class and the names it's going to look for are gone and Bajan

26

on and since can be transposed to the contained can.

27

Well it will find Canth transposed to the.

28

And then it will initialize the weights to 0.00 and 0.02 for the convolution modules and then Same for

29

Birgeneau.

30

It's going to look for any name in the class that contains Bache norm which of course the budget norm

31

to D2 budget normalized feature map.

32

And on each of these layers related to the batched norms and inside each of these best layers it will

33

initialize the weights to 1.0 0.02.

34

And remember in each layer we also have some bias and all the bias at the batch on levels will be initialized

35

to zero.

36

So that's exactly what it's going to do and it's using this class name trick to look for the convolutions

37

and the budget formalizations inside the class to initialize these ways the right way.

38

All right so that's how it works.

39

And now to apply this function we just need to take our generator neural network which is which we've

40

just called Net G and then we added that then we're going to use the plie function to apply the weights

41

in its function.

42

So I'm just copying this and pasting it inside.

43

All right and this will just apply the weight in function to our Najia object.

44

That is the neural network of our generator.

45

All right.

46

So congratulations.

47

We now have a generator a real generator neural network.

48

So basically we are done with the first big step of this implementation of the deep convolutional Ganns

49

which was all about defining and creating the generator.

50

Now we're going to move on to the second big step of this implementation which will be about defining

51

and creating this time the discriminator.

52

So we'll do that in the next three to two year olds.

53

We will start by defining the class then we'll define the forward function and then eventually we'll

54

create our discriminator object.

55

Until then enjoy computer vision.