Multi Layer Perceptron Part 2 (Java by example) Video Lecture | Machine Learning with Java - AI & ML

hi and welcome to another Java by
example and today we're gonna continue
to translate this file from C++ or C to
Java where we looked into the model
last time where we talked about this
neural network where the signal was
actually transmitted through the
different layers of the network and back
again to figure out how to adjust the
weights inside of the network to get a
more correct result for each point of
the learning data today today so we're
gonna go more into coding and actually
translating a bit of code so think we
gotta start with creating a class here
call that a multi-layer perceptron so
that's our class we put it there and
then we need some values from this
5 here I think we are going to copy most
of these things in here because these
are going to get translated quite
directly to Java code so here we have
first off a few vectors of float and
some ints that we need then we need to
create some functions to do each of
these different things here so let's
start with creating I think a list of
float
floats let's say you put it neuron here
as float then we don't need a file
reader these int values are good and here
we have some functions that we need to
define because we don't have simple
defines in C you can define
different subroutines to be yeah macros
perhaps into different other codes so
where you write some code you actually
switch that out with different
kind of code so let's see here we need
an constructor so create that here that's
a public constructor we need two int
values to that constructor so that's a
I like to have my constructors first in
the class to simplify things and then we
have all these functions quite similar
to their earlier values one with a bool
think we can make that private populate nooo
those a public of course calculate
network is public we call all these
public and think it's a keep all the
difference
comments here so here we just create each
of these functions and I think we need
to be more verbose in our speech so we
change those two booleans and then
because we don't have defines we need to
change all of these two actual functions
I think they all will return floats they
can be private as we only use them inside
of our and then we just say that we use
them inside function here see weights
and that's a list so I think we have a
functional lists and yeah I think we
need some import here java.util.list
perhaps get that from this one set up
SDK okay I didn't do that now that's
much better now i can import
that class this makes much more sense
so and here we will get a value at a
specific point and that's input plus
these values these values I guess are
just ints so that's specific points
inside of this
let me just continue to translate each
of these defines here we go here we go
there we go, let's see here
lot of defines and here we have those
math function sigmoid and their sigmoid
lot of defines and here we have those
math function sigmoid and their sigmoid
these out and I think we just need to
take each of these fix their meaning so to say
I think IntelliJ does a good job of
helping us with indentation would like to
I think IntelliJ does a good job of
helping us with indentation would like to
help us put these phrases inside as well
that's not the obvious choice so oh they
doing a fine job making this work quite
painless
place inside the list not the actual
value that could be something less
place inside the list not the actual
value that could be something less
this correct someone can change all
these to get that's that and we'd few int
values, we have a little bit more
definitions here bit more verbose
language this see here so the previous
definitions here bit more verbose
language this see here so the previous
weights is not defined yet that's
defined inside of this which could make
things a bit more yeah so we have
templates and previous weights they are
defined inside of the training function
I guess we will then just translate like
these huge functions later and perhaps
put them inside of that or we might want
to make that we can try to make the
that thing but let's go with that for the moment
continue with you lists here and they
are same as weights at the moment hmm I
guess we will need to define those
later on there we go and believe we need to copy them
as well later and here I guess we have floating
later on there we go and believe we need to copy them
as well later and here I guess we have floating
value for those oh I'm not sure think we
need to look at the actual code to
see here this should be a value so
this is a float value and then we have
this expression I guess that's inside of
math so that's double that we get from
that I guess that we need to, each of these in java you
need to that I guess that we need to, each of these in java you
need to it that float should come back so we
don't deal with large double values when
it's not needed mm-hmm helper macro
to locate the appropriate
neurons Delta output at hidden Delta
at we need to look at that later so
here we have some more ints and here we look at hidden neurons we will
here we have some more ints and here we look at hidden neurons we will
so here we had the constructor of this
code so we put that in our class here so
as well yeah so let's look at the actual
implementation of the constructor here
we have output numbers in this case we have
10 of those and then we have the hidden
layers and I guess these are setters
for the values inside these are the same
values so therefor we need to define these with this we have the initializer for the file reader
layers and I guess these are setters
for the values inside these are the same
weights and the weight should be a value
of this size so that's a lot of memory
so new arraylist I wonder if you can just say that it should be a specific size maybe you
can maybe you can't import that class
explicit argument float can replace with
we don't need that so what does this
actually mean initial capacity so
that sounds good yeah so then we just do
the same with these other input neurons,
hidden neurons and output neurons we get all
actually mean initial capacity so
that sounds good yeah so then we just do
here push back mmm randomized ways for
inputs and the first layer and then we
these values as well
and then we need to put some values in
here push back mmm randomized ways for
inputs and the first layer and then we
thing we actually randomize floating
point value and try to get it between
minus 0.5 and 1 which the
randomization function actually does and
thing we actually randomize floating
point value and try to get it between
so why not just say weights size put that
there and put that value over there and
then just have a for loop from I where I is see if we can
get this right
until the max size of this increment
over that and then we weights and see here
add some values to the weights and here
we need to add math.random that's a double
we could say math.random times one but i
think that random is a function that see
add some values to the weights and here
we need to add math.random that's a double
we could say math.random times one but i
think that random is a function that see
it 0.5 less than the value we actually
get we get the value between minus 0.5
less than 1 so this should do exactly
what we want to accept we want to make
suffice i guess to fill out the weights
so all this is a redundant i think
and the maximum value and then we turn
that into float as well so this should
suffice i guess to fill out the weights
so all this is a redundant i think
because then we have filled everything
why should you do three different loops
have a destructor that's not needed i
guess in java if you kill a class it
me in a comment below but I really don't
see any reason for it so yeah then we
have a destructor that's not needed i
guess in java if you kill a class it
function so let's start with that
populate input we have that here let's see
and we have the calculate network
populate input I think there's a simpler
function so let's start with that
populate input we have that here let's see
do this a bit easier we just say that
instead of a file number here we'll get
bitmap then we put the values into the
neurons hmm this could be think we can
do this a bit easier we just say that
instead of a file number here we'll get
information from that image back as a
data property of the ints and I think
the ints will be somewhere between 0 and
255 and in this case when we have black
and white and all the pictures are
actually either 0 or 255 so that
could make it very easy for us so we
just put that in right here we say data
and white and all the pictures are
actually either 0 or 255 so that
could make it very easy for us so we
just put that in right here we say data
and then we go through the input array
exactly the same that's no reason to
necessary if a specific pixel is set on
the corresponding neuron okay i divided
by 8 I divided by 8 if we go through each of
these and I believe that get the pixel
necessary if a specific pixel is set on
the corresponding neuron okay i divided
by 8 I divided by 8 if we go through each of
these and I believe that get the pixel
yep I think so let's think say
that our data is structured so we can
get data I is larger than zero and
we do that else do that so in one case
we set it to one the other case we set it to zero so it's either on or off can do that more sophisticated later required why it
get data I is larger than zero and
we do that else do that so in one case
read the actual file and here we set the
value at index that should be good and if we go
through yeah let's do that we can change later required could be that we can't set the
value to the neurons if we don't have
every value that we need to add them so
the capacity in most cases just gives
us the maximum size of the array
before or the list before it actually
goes and change it's
but I guess here we have lists why
not be even because we do actually say
each time where we want to pick the
value from let's try to do it with
arrays because that's very much more
efficient when it comes to memory so
here we can create float array of the size
oh sorry there so this should be much
arrays because that's very much more
efficient when it comes to memory so
here we can create float array of the size
oh sorry there so this should be much
that in the array on the correct position
and here are the neurons yes this I and
I think we still can use this value here
only difference is that we need to put
populate input so let's go back and pick
some code from this calculate network
set the values well so that should
suffice so now we have created the input
populate input so let's go back and pick
some code from this calculate network
so here we get hidden at put that to 0 so
that's why we got and yeah this will not
layer towards the hidden layer okay
layer minus one that's zero times the
hidden n value times hidden so this should
just be hidden value them because that's
layer one so that's an easy one and so
we can just say this value should be zero layer one neuron is the actual spelling of that so we continue here
we still want the layer neuron down there so that
should continue to be simple and last
we want it here too so then we should need
the input neuron as input that's just
that and then we need to multiply that
with input to hidden that's this one
we want it here too so then we should need
the input neuron as input that's just
value input to hidden so that should be good
I can continue to use that and here we
that's from the weights and I guess that
this actually works for fetching that
value input to hidden so that should be good
I can continue to use that and here we
just want to continue using that in
memory point to do the sigmoid of that
to fix up the value a bit and then we go
into the layers so this is a bit more
tricky and because here we do for each
of the layers we will create a
hidden to hidden at continue that whoa did I
do something bad? we want to keep the input
hidden at we don't want to remove that
because it's hard to read something
hidden to hidden at continue that whoa did I
do something bad? we want to keep the input
hidden at we don't want to remove that
because it's hard to read something
inside of C here we need to use
the actual values I think
something to an address as you can do in
inside of C here we need to use
the actual values I think
hidden at I minus 1 and then k so that
should be a k then and then we multiply
that with hidden to hidden and I get
this was an okay implementation of hidden to hidden so
each of these more harder functions
that is a bit more verbose those just
that with hidden to hidden and I get
this was an okay implementation of hidden to hidden so
each of these more harder functions
that is a bit more verbose those just
is quite readable to I like my for
loops to start on the same row that's just an esthetical
and probably some more are not as good
so we need to replace those I think this
is quite readable to I like my for
loops to start on the same row that's just an esthetical
everybody have different reasons for doing things
but I think this is more readable for me so where we just continue to
fetch the specific value that we need to
change up and then set that value wow sorry we still
need this minus 1 because we are now
talking about the layer from one and up
so this starts at two for some reason and because this function uses that
I think it's easier to keep it at two
perhaps can change that later as well so
why do you put that i outside of the for
loop I don't really get that either some coding are
strange then again you can't understand
everyone there short life choices so
then we need to populate the outputs
here this should be straightforward I
just can't see my mouse here quite
annoying that it seems to be there one
minute and gone the next so here we need
to use the function up here and
before but we want the largest hidden
layer minus one so that's the last row
and then j value and then you just take
that hidden to output j i and this
hidden output should be fine as well so
now I think we have translated the
function that
calculates the network so that should be
good think we should just change to
these up so we can have those working
later on as well see what we have time so
ya think this is a good chunk of
translation for this episode in the next
episode I'll try to translate see where I can
find this train network function we
should be a bit more verbose and we also
have this recall network that we need to
translate as well and I think this is
much simpler I even think that we don't
need this output down here could use it
but the important part is the first
things here to figure out the winner of
the network so this should be quite easy
to translate the large part is actually
translating the training function
because that is a lot of code so i hope
you liked this episode i know it's just
half of the other translation but i
think we did a lot of good things and we
talked a bit about verbose code and
looked into different kinds of
the changes you can make on the on the
way to enhance the flow and also what
kind of data models you should use to be
as efficient as possible in different
languages
and we also looked a bit into how to
structure code and read code from
different languages so if you are
familiar with C and familiar with Java this
episode should be quite easy for you but
if you haven't seen these languages and
how they translate in between I hope you
learned something please share this with
colleague or a friend leave a nice comment subscribe if you want to see more videos like this one
And I really hope to see you in the next one