Convolutional Neural Networks [Part 2] - Filters Video Lecture | Machine Learning with Java - AI & ML

hello world and explorers let's continue
our little view into convolutional
neural network and today we're going to
look at a convolution and how we can do
a convolution how I use filters and how
we can use different filters to display
different data and in the convolution
neural network you take an image you run
a bunch of filter on this image get a
lot of different data from this image
and then you take more steps to hone
this data in to get your actual results
and then you do a backwards computation
in order to find better filters for each
stage to get you closer to the real
result of your data set depending on on
your training so let's look at how we
can apply a filter on an image and see
what different results we get from that
so if we start to look into my main
method here it's pretty simple I read an
image I get the width and height of that
image I get all the raw pixels from this
black and white image and we can look at
the image me fine picture of me from New
Year's Eve a few years back so I take
this black and white image and
then I apply a filter on it and we can
look at these different filter I want to
try to apply to it we have a top filter
top and this will look for edges from
the top so whenever it sees an edge that
goes from you have something
that I have a lower pixel value
and then you get a higher pixel value
then this higher pixel value if it's
from the top counted a value that you
have a higher value further down then
this filter will trigger and then we
have a bottom filter that would trigger
the other way around
so if we have pixels with a higher pixel
value on the top they will get more
affected by this filter and give it a
higher value out and if you have
higher pixels below then this filter
will degrade so these filter uses
plus one to give you more of those
pixels and minus one to give you less of
those pictures and then you have a
neutral line in the middle to say
that these don't account to the current
score and this will give us the edges on
the top side or counted from the bottom
and then we can have a filter from left
to right and one from right to left and
then we have the corners left bottom
right bottom left top and right top and
then I just have these this little nifty
function that goes through each of these
filters and applies them and gives
it a separate output name
so that's the main method and this writeConvFile isn't that interesting it
actually just calls convolution with the
filter and then writes out the
new buffered array so this is not much
to go into its standard way of the
reading and writing image data if you
have pure byte array data so let's go
into the convolution this is a the bulk
worker and but it's also very simple I
just create a new image set all the
image values to 0 and then I apply the
3x3 filter on this old image and
I get a new image back and then I return
that this function doesn't do that much
either so let's go into the function
that is the meat of the matter that
does the most of it and this is also
quite simple all these small parts are
quite simple we have a value that we sum
up for how much the current 3x3 square
in our window will affect the output so
remember we talked that we had a window
that we went through the image and show
the window through the image and
this window it generated an output image
depending on the filter you applied to
this image you would get a specific
result out from that image on that spot
and by applying different filters you
could get different output images and so
applying a filter is pretty much just
doing a dot multiplication on the
matrix and to simplify it even more you
just multiply the filter data on a
specific position
with the same position on the image that
this filter is over so if we have a
three by three over three by three image
then the first pixel position and the
first position of the filter will be
multiplied then we take the second
position of the image the second
position of the filter and multiply
those and those multiplications we add
together and then we do the same with
the third and add that together the
fourth and add that together and so on
and then we get sum and in my case I
divide this sum by nine and also round
it up in order to show it in an image in
a good way so it's we get some image
data out that looks reasonable and so
this little for loop I have here I
actually take the current position in
the image X&Y and I used them to
calculate the image position so I go
through all Y's in the filter and all
X's in the filter I will add the current
Y value to the current filter value Y
because that's the incrementer that
inside of this window and that is then
multiplied with the image width to get
the current row that we are looking at
and then I will take the image x value
as an offset and then add the filter X
value in order to get the current image
position that I want to multiply then we
look at the filter that's much easier
that's just the filter
y-position times 3 to get the current
row and then add the current filter
x-value and then we go down to the last
row here here I just look for the
current image position to change and to
make it easy for myself I kept the image
ratio and the image size the same but
in my case this filter because it has a
stride of 1 and width of 3 I actually
will get a result that is 2 pixels
smaller both in the Y and X axles and to
compensate by that I move the image one
pixel in and one pixel down in order to
get the image centered so this means
that I will have a row of black pixels
around the image but I thought that that
was a good trade-off I didn't want to
change the size of the image because
yeah that would make would make it make
this a little bit harder and I think
it's much easier to see where the
different pixels end up if we keep the
ratio so now I think I have pretty much
explained all the code that goes into
this so let's look at the result I will
bring up my and my results folder here
so let's look at the different images so
this image here this is an image
filtered from the bottom up here we can
see that it's found edges by my shin
here it also found
Edge's in my hair and so on but we can't
see much of edges in the background and
if we look at this that goes from the
left we actually see their edges on this
cupboard up here and we see some edges
on the shin and so on but or so but we
don't see so much edges down here or as
sharp edges and then we have left bottom
then we will get some edges in the
tongue here and the glasses and if we do
the left top we will get the different
kind of edges so all these images
together will get paint a picture of the
different edges that goes into my face
and then we take that one layer further
and make predictions on how much these
kind of edges actually will be a
factor of how we find out if this is a
image of me or not and this is these
layers and these filters are very
simple I wanted to keep it simple in
order to describe it but in in the case
of a real convolutional neural network
these layers will actually compute it
and well the computer will find most of
these layers that goes in the separate
positions of the neural network and this
is what makes this method very
interesting to look into and I hope that
you found this video instructive and that you have a little bit
more insight into how a neural network
find different attributes of an image
and I learn best by actually writing
code and looking into how different
things
works in code if you learn in a
different way and please tell me and
keep it a discussion in the comments
below so I really hope to hear from you
and I hope to see you in the next video