Multi Layer Perceptron Part 4 (Java by example) Video Lecture - Machine

hi and welcome to another Java by
example today we are going to continue
our series with the multi-layer
perceptron and a method that I
read a blog post about this topic that
Lefteris had the written can't really
pronounce his name I think his Lefteris Karapetsas or something and in
this tutorial he very simply went
through and discussed how you set up and
make multi-layer perceptron and how you
write that in C and the different things
that are involved with that so I thought
to take this example he had and break it
down and do a Java example of it instead
and by breaking it down perhaps
explain a little bit more how
multi-layer perceptron works and the sad
part is that i think this series will
end here because i have tried this one
and results was not that good so i
will come to that later but let's start
with looking at the few changes i had to
make in order to make the example i
implemented earlier to work because i
had done some bugs not that many and
some of them was just yeah choices that
I made that made it look a bit nicer and
maybe they didn't have that much of an
impact first off I had it start off with
saying that this is a git diff output
and when you look at git diff all the red
lines are the removed or the old lines
and all the green lines are the new
lines so
if you haven't seen it before the this
is pretty much what you have to look at
so firstly I imported random because
later on I wanted to use the random of
the random class instead to generate my
random numbers so I could see
them I'm not sure that that is important
that you get a better random seed but I
thought why not I can try that out and
then the next row you have here then I
had switched the nodes and the layers so
i actually created i think three nodes
with 24 layers I thought that was a bit
strange so I changed those up and then
here is a very bad one I didn't set any
value for the input nodes which meant
that I had zero input node so I never
actually sent any data into the network
and 64 is the number of nodes required
because we have an image with eight
pixels by eight pixels
big so that's 64 pixels all in all and
if we continue down in the diff here you see
the random change we have created the
random object and set a seed to the
current time in milliseconds and then we
create floats from that between minus
0.5 and 0.5 so that's not a big change
and then we have this row here where we
if we look over here i have actually you
are transferring from one row to another
row and i actually had minus 1 in both
cases so i never transferred any values
so i just added the same row over and
over again which may that the network
actually didn't have any changes
in the data so that was
a sad mistake that I had to fix and also
when we are working with three different
arrays is a good way to not copy the
pointer so I actually made a full copy
of their array new previous weights and
lastly we have removed the breakpoint at
1000 epochs and I I let it go for all the
epochs it can do and because we have set
a value for the least mean squared error
and we actually hit that value quite
fast i think it was off the like 3,000
epochs or 2000 epochs or
something so I thought that maybe I'll
try that out first and yeah I type out
the error for each one thousand so
I can see how the change is progress and
then I had some changes to the recall
network where I actually sent in the
answer and return a one or a zero
depending on if the answer was correct
so I could calculate and see how many
correct answers I got for this network
and then I changed the output somewhat
so it was easier to read and I could
just see each row one at the time
because I wanted to run these many times
so let's remove this one and open up the
code editor so I can look at this
specific changes are made here and if we
look here I take a key set this key set
and make that into a separate string
array or string list and sort that and
that's because when you are
managing a map or a string or a list or
any collection in Java and you actually
iterate over those you can't really
remove things from them because then you
will have an error that you remove
something that you're iterating over
because that when you iterate over them
they should be immutable and why do I do
this because when you are actually
testing your network the correct way you
should remove the test data before you
train the network so you have a training
set that you use for training and then
you have a different data set that you
actually test on in order to prove that
this network that you have created can
actually find the example of the test
data has never seen before so I had
to make this collection to separate
that out and then we go through this
collection and we pick out the answer we
remove the key we train the network with
the the standard values that we I saw in
the example for this executable that he
had in his blog post and then I recall
the network and if the network is finds
the answer to be correct I return a one
and increment my correct value otherwise
it's not incremented so that will be
the same and then I put the key in the
answer back into my map again so for
each iteration of the key I remove the
one that I want to test and they put
that back again so i can test each of
the answers separately and get a good
feel for it if i have found something
that that works and
when I did this with the network I had
it actually ran through and gave me
eight of 22 correct and that's not that
good number because if I had 11 of 22
then it's just a guess it's a 50-50
guess so I should at least get 11 I
should get a lot more but at least 11 so
what's going on here and I tried to run
this application that he wrote to test
his things and it actually trains the
network first so it has trained a
network with the full day to everything
that is has seen before and then you are
prompted to enter an image to test so
then we have already made a network that
is perfect so it shouldn't have any
defects at all because it should know
every example and when I tried it with
each and every one of them I actually
get the got the result that it got it
right 18 of 22 that's very weird because
it should have gotten every one of them
correct so I implemented a function down
here where I first trained the network
and then went through and recalled all
the values and I actually got the number
22 of 22 so my network was perfect at
recalling what it already knew which his
program wasn't so that's a bit strange
as I said I had actually trained the
network with about 3,000 epochs I
thought that that might be a strange
thing that I shouldn't do because it
could be too good so I changed this
downs I tried with 2,000 I tried with
1,000 i tried with 500
epochs and with 500 books I got zero
results right 1,000 I got the few and
2,000 a few as well but I never
got above 11 which is what I should have
gotten at least so either I have
implemented something very wrong in my
in my code here and if you can find that
please hit me up leave my comment
explaining what I have done wrong but my
thought is that we actually have
implemented this correctly from the
example but our problem is that we have
too few test cases we have 22 test
cases and that is actually too few cases
to train in order to get a good sample
so I think because we have such limited
network such a limited test sample I
think that we are hard pressed to
actually get any a viable results from
this method I hope you learned something
about theories behind multi-layer
perceptrons and that you found this
topic interesting and perhaps you want
to try to implement this in a different
language and I would really want to try
this out with the larger test set so I
will look into finding some more data
and actually running this on a lot more
data and see if I can get any better
results so please if you liked this
video give it a like share it with your
friends and leave a nice comment with
the what you thought about it and if you
have implemented a multi layer
perceptron yourself what your results
was and if you have the any other
comments pretty much and if you want to
see this code it's available on github
my github profile is kalaspuffar and
this is a project called mlp it should
be quite easy to find there and yeah I
hope you like this and I hope to see you
in the next video