Convolutional Neural Networks Basics - Deep Learning withTensorFlow 12 Video Lecture | Machine Learning with Python - AI & ML

what is going on everybody and welcome
to part 12 of our deep learning with
neural networks tensorflow in python
tutorial series in this tutorial what
we're gonna be talking about is the
convolutional neural network or CNN or
convenant if you're a cool kid so the
convolutional neural network is
basically state of the art for
recognizing what an image is what's in
images or even playing roles in doing
things like assigning captions for
images so the convolutional neural
network breaks down into basically the
following structure you have some input
data and with that input data you're
gonna do some convolutions or some
convolving and that generally is just
creating feature Maps and we'll talk a
little bit more about that in a little
bit but for now we'll just stick with
convolve and then you're gonna do some
pooling usually max pooling again we're
gonna talk a little bit more about that
later on and each one of these you do is
going to be a layer or a hidden layer
better put actually so each one of those
is your hidden layer and then generally
you will add one fully connected layer
which would also be a hidden layer as
well and then finally you will output
whatever your output ought to be so
that's kind of the idea so again you
take your input data you can volve it
you pool it you usually will convolve
and pull again just because you're gonna
have two likely hidden layers at least
to start real basic two hidden layers
then you'll have a fully connected layer
a fully connected layer is identical to
the hidden layers of our typical just
simple neural network that multi-layer
perceptron model and then finally the
output again same as the output from a
multi-layer perceptron model
so now let's talk about what convolve is
and what pool is so when you do a
convolution this is generally just any
form of mapping or creating a feature
map from an original data set so
generally what this is going to involve
is it's just going to be this moving
region this moving window over your
image that is looking for something or
in some way is gonna create a feature
out of a window of pixels and some sort
of n-by-n of pixels it's gonna look for
something or do something basically to
take that that region of pixels and
classify it or call it something so
sometimes you might have this searching
through an image looking for horizontal
lines or vertical lines or edges and so
on so you might use something like
OpenCV for example so to visualize this
let's take an image and this will be a
photorealistic
image of a cat okay and the image in
general you're gonna break it down by
pixel but I can't break this image down
by pixel so let's just pretend we're
breaking this one down by pixel good
enough so each of these little squares
is a pixel let's pretend so in the
convolution step let's say you're gonna
take a 3x3 convolution so you might
start with a window that is like this
and that window is gonna only is gonna
basically pertain to a new we'll call it
cell and it'll be that and then we're
gonna shift that window and we could
shift it to spots over so we could make
that window here we can make that next
window right here right so there's a
little bit of overlap there so we'll
make that there just for kicks for now
and that would be here and now we've
reached the edge and we're all set so
then we would move the window down into
that left where now though 3x3 is
here and that would correspond to this
window I didn't draw the line of the
blue one but I'm sure you get it and
then finally our last 3x3 shifted over
it would be like this okay and that
would correspond to this one okay so we
just keep doing that just to the point
where we're not actually shifting any
pixels or rather not shifting to the
point where we're not skipping any
pixels so if this is your convolution
what is pooling so let's say you've done
some convolution and convolution has
just produced values for us so again
when we convolve if you remember from a
few seconds ago if you can remember that
far at long ago we created new boxes in
each of these new boxes or in each of
these new kind of regions of the image
they might actually have values in them
like 2 & 1 & 4 & 3 something like that
so let's imagine this is a new basically
feature map and we'll just add some
values here okay so let's say this is
that new feature map now what we're
gonna do is we're gonna move we're gonna
do pooling and we'll do a will do a 3x3
pooling that'll extremely simplify this
and make this quick so the pooling that
we're going to do is a 3x3 and when we
pool it's a little different from when
we created the feature map yes when we
created the feature map we did what
pooling is actually gonna do for us but
we also kind of extracted value whereas
pooling is simply simplifying so let's
take it 3 by 3 pool and this is going to
be a max pool so we're looking for the
max value that max value is a 4 so in
this case it would be a 4 and we'll just
make a box around it I guess and then we
could shift it over to and then we've
got this box the max value is a 3 and
then we come down and here the max value
is a 4 and then again here the max value
is a 3 so it's extremely simplified
version of what pooling is but and we
never had a value here this was the
great unknown
yeah anyway it's an extremely simplified
version of what puling does but that is
what pooling does and together
convolution plus the pool equals a
hidden layer okay and then you we had
that fully connected term at the end and
that just means a fully connected is
just you've got neurons and they're just
fully connected to each other and we've
kind of already spoken on that so
hopefully you understood that already
and then you finally have your output
which we've also already covered and
this is exactly the same as before let's
say the first one's cat dog then horse
so these might all connect to each other
again so you've got cat dog horse maybe
this outputs a 5 this is a 2 and this is
a 1 so then of course the winner is cat
and in our hypothetical convolutional
neural network we are successful ok so
again we start with input data we do our
convolutions and pooling and together
with convolutional pooling you've got a
hidden layer you'll probably have two
hidden layers at least in our basic
example that we are actually going to do
in tensorflow you'll have two hidden
layers
it's a convolution pooling then you'll
have a fully connected layer and it's
arguable whether or not this is actually
of use but people do it anyway so we're
gonna continue doing it and then you
have the output which again is just the
same as before so basically from fully
connected to output it's the same as any
other neural network so doing this in
tensor flow is actually really simple we
can slightly modify our initial code to
work with this it's actually pretty
impressive how easy it is given how
different the model itself is actually
especially when you have something like
sparsely connected layers and then and
then just pooling which is not quite
something we've done before so anyways
we're gonna do that in tensor flow and
see how just how simple that is and
we're going to do it against the EM nest
set and using that script that we've
been basically using all the way up to
this point those same one that we did
with the simple multi-layer perceptron
model the same one we do with the
recurrent network recurrent neural
network thighs and then here with the
cond the cond the net so anyways
questions comments leave them below
otherwise as always thanks for watching
things for all the support and
subscriptions until next time