PyTorch Lecture 11 Advanced CNN Video Lecture - Pytorch A Complete Guide

in this lecture we are going to talk
about advanced CNN from last winter now
we can understand what is compilation'
and what is pulling and if we can
connect them together with a multiple
conversion Aires and then finally we can
connect it with a fully connected layers
so for given image it's natural that we
can use a filter and then try to extract
some output however we can use different
size of filters one by one three by
three five by five for example like this
so which one we have to use for keep an
image this is really a big question mark
so the idea of Inception is quite simple
why we not try all possible for some
more possible combinations so for
example here we're going to use five
five filter Li by 3 and the one by one
and then basically we're going to
concatenate them all together but if you
look at a little bit closely we are
using one by one convolution first in
here and then you gonna connect them to
5 5 3 3 and so on here with a bridge if
link so this is very interesting in some
times why we are using one y one
composition in here what is this one by
one convolution suppose we have image
with a 56 by 56 and then the depth of
this image is 64 so we want to apply
this one by one compulsion on this image
what will be the output so obviously
this is 1 by 1 are both sides of the
image or activation map is just a fit is
656 it's not changed however because
this is basically that product operation
each conversion operation will change is
just the one number and then we just go
over entire this image so the channel
output is going to be 1 because if we
are using only 1 1 by 1 composition so
this is exactly the goal of using 1 by 1
composition so using this one by one we
can decide the channels our channels
so for example here we want to use 32
filters one by one then you're gonna put
this kind of produce to exactly same
size at the original input but this
channel more tabs can be decided to by
number of filters you're using so by
reducing these steps we can
significantly save our computations for
example let's say we will have image 28
by 20 with a 192 in channel and then by
applying some conclusions we want to
make a 32 channels without the same size
of image so here we're gonna apply this
5x5 kernel and then with some padding so
we can generate the same size so here
how many colors do you need so we need
to pay to click 32 kernels size of 5x5
and then we can apply convulsions and
continue this image but on the other
hand we can use this 1 by 1 composition
so for keeping this image we can create
the same size but with a different depth
so here out channel size is 16 so we're
gonna use 16 of this one by one kernel
and you can generate this feature map
and then we can apply another compulsion
which is 5 by 5 and then we want to
generate exactly the same size of each
image so we can apply this 132 with 32
kernels but it sounds like a little bit
inefficient because we are applying this
convolution twice but however if you can
really compare number operations we need
to generate is the same size of future
Maps it's gonna be very interesting so
for example here how many operations
doing it basically we can compute rid of
this 5 because it's 5 square and then
the input is 28 square and then we have
this machine channel and this much out
channel this is how we can compute so
it's roughly 120 million operations but
how it is you can try to compute this
one
and if you complete this one its release
priding so because this one is one by
one just one and then 28 and then 192
channel times 16 this is how much how
many operations we need and then we have
a second one plus v square 28 square and
this input is 16 a potato so 16 by 32
and surprisingly this requires only 12
million operations if you compare these
two this is really small so this is one
of the reasons that why we are using
this one by one compulsion before we
apply other compulsions let's try to
implement this so now this is our input
and then we're gonna apply various size
of the compositions and then eventually
we're gonna concatenate all the output
so let's go one by one here so this
looks really simple only one
convolutions read try to implement is
how we're gonna do this so we're gonna
use this come to D and the input
channels are given so it's some input
channels and then the output channel is
16 so we're gonna use 16 and then what's
the Cano size Kanak size is obviously 1
and then for given input we're gonna
pass through and twist come to D and
that's it and how about that
that sounds also very very easy so what
we need to do is that first of all
you're going to define this element
sneer come to D and the input is given
so output is 24 and then the kernel size
is obviously 1 then average pooling is
this function so we put the input in
here and then cannot size 3 and we put a
stride and padding to generate the
Radian size of the input and then we
pass just input 2 here and how about
this it's just the two layers we can
just follow exactly same
procedure so here the once again in
channels are given so we're gonna
produce 16 and the current size is 1 and
then we're gonna define these elements
this in sizes 16 because these two
numbers should be equal and then doubt
channel size is 24 what is the size of a
comma is st pine 5x5 so we're gonna use
5 and the fading is here - to generate
the same size of image and then for
input we're going to put here and then
this output you wanna put here again to
generate is the lastly this tree it
sounds like a little bit complicated but
we can just follow you directly same
idea so you can define three different
components in and out and then size it's
exactly same as there and then padding
just we want to generate the same size
so a missile fading is one here and then
16 is input 24 Cotto's 24 this is final
and then X we just push one by one here
and then eventually cut is and finally
if you get all this result what we
cannot do is that just to concatenations
it's like a list in the Python and
that's it this will be our final output
so even though this network sounds a
little bit complicated
our implementation if you just to one by
one it's quite simple and very intuitive
let's look at our entire module
so this is our inception and this is a
very common practice that once we have
very complicated models we want to make
small subsets and a separate class and
each one has initialized and then each
one has forward so here it has to
connect it all in sections and in our
main module we are just using them as
one of the components in here so we have
component convolutional and the max
pooling linear
also have inceptions and in forward we
just connect them all together so for
given input we've first test two
convolutional and then this output will
be finally we're gonna flip this output
and then feed to fully connect a layer
and then will return with logs of X now
we can train our model using this main
network so using exactly the same loss
functions and same forward backward and
update training cycle even as you
probably can see this loss is going down
and then sprite in me we are going to
have very high accuracy 99% and then at
an exercise we just implemented this
very small but we can implement the full
inception version number three and
version number four so it's very obvious
that if you have more layers it's
scaling better result so can you just go
deeper and differ anyway wait on
unfortunately the answer is no based on
the experiments on the data set called C
410 so if they use the different size of
layers with a six layer and 20 layer
this is nutrition's
and this is Error so surprisingly if you
are using 56 layers the error and
training error is a higher not only
training but also test error is higher
than just the 20 layer so he also tried
with the auto dataset like image net and
then it has very similar result 34 layer
and 18 year 18 years
what's better than 34 years why this
happens basically once we have a tip
layer like more than pity layers the
vanishing gradient problems happens
again so our paper operation does not
work very well in this case so one of
the solutions is using tip residual
running this is our plain a talk
basically it's connect to multiple
layers like a stack
however in proposed residual learning
what we do have is that little
connection which is set up by passing
this and then we add these two values
and then use this one as next input in
the very tip layer the flame that looks
like justice which is taking all the
layers but however in resonate they have
uh bypassing connections like that then
basically this can help to propagate all
the gradients so that they can train
much much better in order to implement
this we can have a period size of canals
inside but one limitation here is that
because we can add on these two values
to the size of the input here let's call
this an X and this one let's say this
one is F X so the size should be the
exactly the same this is one limitation
so when I design inside the canals we
have to be very careful also we can make
one by one three by three and another
one by one so often this one by one is
called as a paddling layer which you can
reduce the number of operations
significantly also the original also
coming here actually tried many many
different models and really admire him
because he really tried a lot and then
eventually it was a successful so in
year 2015 he actually won all five main
tracks of competition imagenet image net
detection and then using this model he
won everything
so at an exercise you can implement this
resonate so you can get a lot of help
from internet also we do have many other
interesting networks like including
tents net so basically as all to upload
over previous layers we can add them
together and then we can have much
better result so we can try to implement
Internet as an exercise in our next
lecture we finally talked about very
interesting your net called
RNN