Practical 3.1 – CNN internals Video Lecture | Torch: A Practical Hands On Tutorial - AI & ML

in this short practical we will go over
the internals on the most common layers
of a convolutional neural network we
will start with looking at the spatial
convolution layer where we can find the
padding stride channel and kernel size
parameters moreover we will get
acquainted with the 4t kernels that are
called weight and the 3d feature maps
which are called output the same we will
do for the NN reloj the rectifying
leaner unit non-linearity and we will
see how the 3d feature Maps look like
finally we will see the NN spatial max
pooling where we again see the padding
stripe channels and kernel size
parameters and then we will visualize
the 3d feature Maps let's see now in
greater detail the last neural network
architecture we have presented in the
previous lecture we can start kilowatt
and require the and display package then
I can set torch dot minus it to 0 so
that all the values will be random but
still will be all the same for every
trial then I can require my three
convolutional coding architecture we
have defined in the previous lecture and
finally I require the image package that
will allow us to see some internals of
these networks our input X will be the
classical elena which we will rescale
1256 256
so we can print X now we have three
channels RGB 256 pixels in height and
256 pixels in width we can visualize
this match with image display image
equal x and legend equal my input X to
the network we can have a look and here
she is now we can ask to print the size
for example of when I forward to the
network our input X we fixed 1,000
classes I will explain the network in
half-speed screen so that we can keep an
eye on the layers so I can draw a
require T and then nine equal require
so if I print just net just gonna give
us the whole negative definition and
let's say if I'd like to get the first
module I can do net get first water and
here we have this special convolution
and if you'd like to see the internals
we can use the curly breakers coded
bracket operator and we see what's
inside but I will use this double screen
just for displaying the network
architecture so we can go here for
example you can display the first one
so what we see is that we have three
input planes because we get the RGB
input we get six output planes because
that's where we decided to have the
first contribution shooting it then we
have a stride of two in height in a
stride of two in width as we have said
and then if we check the kernel size K H
and K W they are five and also five as
we said we see that the Cardinal is
four-dimensional we have six as M 1 3 is
the N 1 as the input and 5 & 5 are P 1
and P 2 respectively
moreover the grant wave will have the
same dimensionality of course and we can
also check that the dimension of the
output it's 3 D tensor so why is 3 D
tensor of six names and one of height M
to 128 times M 328 moreover we can see
the pasture which is a singular vector
is a one D tensor of six elements which
is one for each of the six maps of the
output Y regard bias will have the same
dimensionality let's display now this
Karnas this network has not been trained
so the kernels will be completely random
we'll see later how the kernels of train
will look like so to visualize the
canals we can simply - image node
display my image is going to be equal
net again one dot wave then we can say
legend equal K 1 so the kernel of the
first convolution we also apply and 3 of
18 otherwise we don't see anything
otherwise the are five pixels by 5
pixels we also use some padding to
distinguish one kernel to the other
and here we can see the six kernels of
five pixels by five pictures of the
first convolutional layer in order to
display the other layers output I will
write a helper function which is gonna
shorten the title so I can write
function so my layer L and the text T so
we'd like to print the layer N and then
we are going to have image display image
it's equal to L dot output and then we
have latent click on my text T and then
we have skid each equal true which is
going to basically set a dynamic range
for visualization for each of these
separate maps and and so now we can show
net get first and the first output of my
first convolutional code why of the
first convolution let's see how it looks
like and here it is so this is the
output of the first convolution and
layer each of these maps are being
produced by converting this I kernels
with the input image RGB here let's step
back here let's show now number two so
let's check off number two we have a
good and text is going to be why because
it's a very low so this one being by one
with the plus we can send enter and we
can see here the the dimension height of
the output is the same so it's six times
128 x 128 and if we check the result
we have that the maps are simply pin
zero when the values were negative so we
can see a greater deal of black because
all negative values are now zero before
the Blake was the center button since
the values in the first output of the
convolution can range from the negative
to the positive range now everything is
being clipped to zero that whatever was
below zero let's keep going so let's so
now net gate 3
what is 3 we can check here net 3 is the
next convolution so this one is going to
be y2 and we see that we input plains
are 6 in this case not 3 anymore output
planes are also 6 therefore the weight
the kernels are 6 which is the m-16 R
and 1 5 5 are the height and width we
can check now the result and this is the
output of the second convolutional layer
let's go back here so after the number
thing we are going to have number 4
which is our own story simply have a
class here and if we check we're gonna
have this one again all the values below
0 help in 0 and the final point is going
to be number 5 which way you can see
it's a polar bear
so this is gonna be a part of the y2
plus we can see now that the tribe DHN
TW r2 and the kernel of the pudding
running window are also 2 into the
referred the output has dimensionality
statistics the same number of channels
but is 64 and 64 where is the input or
the output of the previous layer was 6
times 128 and hundred twenty-eight we
can check the result and here we have
full of white to class I finish with the
last
three later so we have the last
convolution so it's gonna be layer six
and this is going to be our third
convolution
it's basically identical of the second
convolution we have input plane six
output plane six astride of one one and
the clarinet size is five and five
padding is to enter so we preserve
dimensionality the input was six times
64 and 64 and audio out who's gonna be
also six times 64 and 64 and if we check
the other side here we have the y3 we
keep going so after the convolutional
layer the number six you're gonna have
number seven which is our non-linearity
and we can check the result here y3 plus
we have that again the maps with values
below zero help in zero and only the
positive feature have been sent lower
and finally we have layer number eight
which is going to be the core of the
output of the three and here we see that
the output is going to be 16 32 and 32
whereas the input was six times 64 64
and if we check how it looks like and
here we have the tiny small last map the
last two steps will simply have those
little pixels just reshape into one big
long vector so we can actually print
night okay number nine and we see here
that we have just one big vector of six
thousand one hundred and forty four
elements and last one
we have the last linear layer which has
of course matrix of 1000 in height and
6,000 144 in width and well it would be
1145 if we will consider also the bias
together with the matrix and that's
pretty much it in the next tutorial we
will see more advanced architectures and
the underlying principles on which they
are based