Original subtitles

1

Hello and welcome to listen to Tauriel.

2

All right so we have a series of transformations to make so that the input frame can be fed into the

3

neural network.

4

Let's do these four transformations in this tutorial and let's start immediately with the first one.

5

So as we said in the previous Statoil the first one is to apply the transform transformation so that

6

our input frame has a right format meaning the right time dominations and the right colors.

7

So to apply this transformation we're going to introduce a new Voivode which will be frame T and that

8

will respond to this future transform frame.

9

But I'm calling it Frente in that frame because I want to keep the original frame because we will use

10

the original frame and to put the rectangles inside.

11

So Frente will be the transformed frame after applying the transform transformation and to apply this

12

transform transformation.

13

Well we simply need to take that transformation transform and as input as you might guess when put the

14

frame frame then we must understand that this transform function returns two elements and we are only

15

interested in the first element which is actually the transform frame the frame with the right format

16

and therefore to get the first element returned by this function.

17

We simply need to add some brackets here and get the index of the first element which is zero.

18

All right so then we get this new transform frame.

19

Now Frente has the right format that has the right dimensions and the right color values good first

20

transformation done now.

21

Second transformation.

22

Remember Frente is an umpire.

23

We applied the first transformation but it still returns a number by Array.

24

And so the second transformation to make now is to convert this number by Array into the torch tensor.

25

I remind the torch tensor is a much more advanced matrix of a single type than an array.

26

It is very useful for neural networks but it will not be useful enough.

27

You will see we will have still two transformations to make.

28

So let's do this second transformation converting the non-bio right into a torch sensor.

29

So since we're getting closer and closer to the final input that will be accepted by our as is the neural

30

network.

31

I'm going to start to call this input X because then I will just override the x variable with the same

32

name.

33

So X will be this tortured answer that will just be converted from the non-firing.

34

So now it's very simple to convert a non binary into a tortured answer.

35

We just need to take our torched library and then a simple function very intuitive to remember which

36

is from none.

37

All right from run by the function that converts numbers into torsion answers and therefore very obviously

38

what we have to input here in this function is of course our number.

39

Right.

40

That is Frente Okay perfect.

41

But now there is another slight thing to do we could call it a sub transformation.

42

This wasn't a transformation that I mentioned because it's a small thing but anyway this small transformation

43

is to convert the sequence red blue green into green red blue because right now the order of the indexes

44

or the color for our image is red blue green.

45

But the neural network says he was trained under the convention green red blue.

46

So we just need to inverse the order but that's a specific thing to the neural network and therefore

47

this is not the general transformations that we have to make each time remember that the transformations

48

that we're making except the one we're about to make right now is the general process before finding

49

and then put into a new network implemented with torche that's very important to remember but by doing

50

it two or three times it will be very easy for you.

51

So let's do this small and quick transformation that is a permanent nation of colors.

52

So we're going to add a dot here and then we're going to use the permute function and we want to go

53

from red blue green to green red blue.

54

So since Green is the last index number two we always to hear then since Red is the first one we put

55

a zero and since Blue is the second index that is one we put one right.

56

We want to go from red blue green to green red blue.

57

So we want to go from 0 1 to 2 2 0 1.

58

Perfect.

59

So now we have the right torch sensor format with the right order of colors.

60

Perfect.

61

Now next transformation this is the third transformation out of the four.

62

But actually we're going to make the last two transformations in the same one line of code.

63

So the third transformation is to add this fake dimension corresponding to the batch.

64

And the reason for doing this is that the neural network cannot actually accept single inputs like a

65

single input vector or a single input image.

66

It only accepts them in to some batches.

67

So basically the neural network only except batches of inputs.

68

And that's why now we have to create a structure with the first time engine correspond to the batch

69

and then the other dimensions corresponding to the input.

70

That's very very important in PI torch.

71

You will always see that we do it with the squeeze function.

72

So each time you see the squeeze function it's definitely just before feeding the neural network with

73

the input we use the N squeeze function to create that thing domination of the batch.

74

So good thing to keep in mind if you're going to use torture in the future which I highly recommend.

75

But let's do this third transformation.

76

The Squeeze and the good news is that it's very simple.

77

We take our input image which is now a torch sensor.

78

Thanks to the previous transformation we are added and then we use the squeeze function.

79

And now this squeeze function takes one argument which is exactly the index of the dimension of the

80

batch and the batch should always be the first time engine.

81

So it you always have the first index and therefore since indexes and bytes and start at zero.

82

Well we put a zero that zero.

83

Here is the Index of this first diamond and corresponding to the bet that we're adding to our structure

84

of input images.

85

All right so that's the third transformation that's done.

86

Perfect.

87

And now we're going to do the last transformation in that same line.

88

And that last transformation.

89

The final one and then we'll be ready to feed the new one that work with the input image is to convert

90

this batch of torture and sort of input into a torch viable I remind a torch viable is a highly advanced

91

variable that contains both a tensor and a gradient.

92

This torch viable will become an element of the dynamic graph which will compute very efficiently the

93

gradients of any composition functions during backward propagation.

94

So there we go.

95

That's the final transformation.

96

And that is very easy to do.

97

We simply need to take the variable class like that.

98

So this is the variable class which will create an object which will be this towards variable.

99

And therefore since we're creating a new object we need to override the previous variable X because

100

I'm going to call it X again and I'm going to add here X equals variable x and zero.

101

And that's exactly an object which is the torch viable.

102

So now purrfect are four transformations are done.

103

So congratulations you are ready to feed the is the neural network with the input images that are now

104

towards variables.

105

So that's wonderful.

106

We're done with this material.

107

We did very well our four transformations.

108

So in the next time we will feed this torch very well to the neural network SSD which is already pre-trained

109

because you know it's a neural network that was pre-trained to detect between 30 to 40 objects including

110

planes horses dogs cars boats a lot more.

111

So we're not going to do the whole training again.

112

That's the beauty of it.

113

We have a pre-trained model.

114

We're going to feed the input image to this pre-trained model and we will get the output.

115

That is the prediction detection.

116

So let's do this in the next little while and until then enjoy computer vision.