JavaCNN - Image Readers Video Lecture | Machine Learning with Java - AI & ML

hello explorers and welcome to another
video today I'm gonna talk about different
file formats to the Java CNN that
I built a few months ago and this has
come up due to a question I got from
Muzamil Hussain who write Hi Daniel
I'm working on Java CNN project could
you please let me know how I can prepare
data for face images 19 times 19 images
so 19 squared and then I replied and
asked a little bit more what he actually
had file formats and so on and what his
actual problem was and I got to response
back I'm actually need to know how to
how I can make these MNIST like training
data from my images I have faced non
face images in PGM format so let's go to
my code here and let's first of look at
the definition for PGM because that's a
quite interesting one and here we have
that and PGM specification format they
are quite funny the PGM formas is a low
and common denominator grayscale file
format it's designed to be extremely
easy to learn and write programs for
it's so simple that most people will
simply reverse engineer it because it's
easier than reading the specification
and so their specification says pretty
much that you have a magic number
you have some white space and then you
have a width and height and then you
have some white spacet width and then some
white space height and the white space
and then the maximum gray value
maxval so this is the ASCII decimal
that is the largest that you can have in
the file and then you have a single
whitespace character used to get a
new line and then you have a raster of
height rows in order from top to bottom so
there's pretty much all the values of
that so I have changed my setup a bit in
the mnists test here so I can have
different readers so what is a reader a
reader is an interface that could read
the next label because we had that
before we could read the next image as
int and an int array we can reset so if
we have read all the images or we want
to start over and read from the top
again
we can reset so we can start over again
we can ask how many images there are we
can ask how many classes there are for
instance in my example here I have two
different labelled classes for the PGM
and PNG files and for the mnist data
it's 10 classes because that's all the
numbers and then I can get the max value
so that's the max value in gray scale
that we read from the PGM file and all
the PGM file I have have an max value of
255 the mnist data have 255 and
also the PGM files that I will create
later also have 255 but you can have a
large range there and when
you come into the mnist set I actually
want to divide by that to get a value
between 0 and 1 to have as an input into
my model and then we have the X&Y size
that's width and height of the specific
image that is going in and let's just
fast look at the add image data here it
takes a new image and it takes the max
value now so here we it before we just
divided by 255 now divide by the max
value so that's the this change there
and if we look at the mnist reader it's
pretty much unchanged we still have
something that reads int up here and
then we have the size that I have since
before how many images we have and then
we have some startup initialization this
constructor will set the image and
label file and then prepare them for
reading we now return the max value of
255 we return the number of classes 10
the reset hasn't changed read next label
and read next image haven't changed and
I have a main function here so I can
actually test run it and this width and
height function so let's go to the PGM
then if we look at the actual
constructor here we take an image path
and we in that directory we go through a
list of all the files in that directory
and we create labels from everything
before an underscore and I'm not sure if
you can see my images here but in this
list I have seven dog images and seven
face images so this is one to
seven of dogs and one to seven of faces
so before the underscore and we
actually have the name of the label so I
will fetch all the labels and then I
will create a list of all those labels
first I will add them to the set so I
will get just these unique labels I
don't get any duplicates and then I will
add them to an array so I can easily
fetch them later and then I will go
through the first file in the list
because I depend on that all these files
are
the same width and height and has the
same max value so I will fetch those
values in the first from the first file
in the directory so I will open this
file up with the bufferedreader I will
read lines from it and the first line
should be the header so I check if I get
P5 which is the header on that line
so if I ever get a P5 I will return true
if I ever get a comment I hope it's just
hash and something that it's a comment
then I will just continue and then I
will read the image size and this regex
says that I have some numbers 1
to 9 a X number of times it must be more
than 0 and then I want blank space and
then I want some numbers again and if I
have that then I will actually fetch it
split it by space and add the image size
and in both x and y as parsed int of
these splitted strings and then I will
look if I get a line that just has zero
has numbers and nothing else
then I will fetch that and parse it into
the max value and if I get anything else
on any of the lines before I get
anything of this I will throw an
exception unsupported file format and I
will add to the header size this is the
value that adds how many lines until I
get to the actual data and if I have
read the max value if I found the header
and if I had find the size I will break
this while loop so I will just read
until I fetch the full header of the
file and I have
all the data and I will close this up so
this is my constructor we're reading the
essential information that I need in
order to read this file other things I
have up here defined I have defined two
boolean so I will know if I've read
either the image or the label and then I
have a current image iterator and int
that I will keep track on which image I
am on at the moment so if I've read the
label or the image this will not be
incremented otherwise it will be
incremented have this private function
that we increment the counter so it will
set both the read label and read
image to false and increment the current
image if I read the next label
I will check if I have read label before
then I will increment the counter first
then I will get the file name from my
list of file names I will fetch the
label index of these file names
the first part of this file name so then
I will get a number back and if I have
read the image and then I will increment
the counter after that otherwise I will
say that I've read the label and I will
return the label back so I you know
which integer label that I actually
got as response reading the image
is pretty much the same up here if I
have read the image before our increment
the counter and if the current image is
larger than the size of images then I
will return no data because that makes
no sense should ever had maybe something
up here as well as a safeguard but then
again if it crashes there you should
never get the error that you can't fetch
a file and you have done some logic
wrong yeah in your
program and the data will not be correct
anyway so this is probably not good to
have and then I read the file name and
I'm opening a file input stream and a
date input streams I could read specific
bytes from the from the file I start up
here and say that the header size so the
number of lines that I read and actually
found the header I will set that a
number of new lines and then I will go
through here and read bytes until I
found bytes of newline character that
many times so let's say that I found a
header of five lines then I will look
for five lines until I I'm done here
and when I'm have read all the images or
the header data so I will go past those
then I create this return array with the
image size so x times y and then do a
for loop and read all the bytes in the
image so I will get an array or an int
array full of unsigned bytes and after
that I have read the image so we'll
increment the counter if I've read the
label before
otherwise I will set read image to true
and I will return the data so this is
how I read the image reset then I reset
the current image to 0 and read label
and read image to false number of
classes is the number of labels I had
and the size is the number of files I
have in my file names list and then I
have this data that I read from the
header and then I have a main function
to actually fetch the try the
functionality out so this is my PGM
reader I actually went through and
built an image reader as well so I can
read PNG files and this is very similar
up here the image reader constructor has
pretty much the same logic for the
labels at the start then I fetched the
first file name I use a buffered image
reader and I get the width and height of
those and then I set my Max value to 255
so this is a very short version to get
the same kind of header data that we
read from the file earlier and 255 might
be the wrong value if you have set your
image up in a specific way but I think
it's correct because I will read the
image and create a copy of it as a
grayscale image and I think the max
value there is 255 so reading the next
label is a pretty much identical
function so when we are reading the next
image we fetched the filename we get the
original image we create a new image of
the same size and a buffered image type
byte gray so this is the single value
for each pixel in the image a grayscale
in byte size and then I get the
graphics of this image so I can actually
draw something and then I will draw the
original image on this new image and
that makes a copy of it so after that I
will create my image data array which is
actually this is wrong here it should be
image size x times image size Y in this
case I use the same value for x and y so
it wasn't that big of an issue but it
should be right, right and so here I will
create the buffer first and then I will
get all the pixels of the
the image data buffer so this will get
me a data raster data and then I
will get all the pixels from that and I
need to supply a buffer of image data
that it can fill and then it will return
the same buffer when it's done and this
buffer I will return from this function
after I have incremented the counter and
set the read image boolean to true and
the other functions here are similar as
in the other one and I have my main
function to actually try this
functionality out and if we go back to
my test here I have set it up so now so
read my PGM reader and if I start the
mnist test it will start off here and
when it have run for a while it actually
gets 100% right at some point and it
diverges back and forth a bit and I
think it's not perfect any anywhere but
it's better than guessing I guess but my
setup here has so few examples so I
think it's very hard to train it and
actually make it good at deciding
between if it's a dog or if it's a face
and it's quite a silly example as well
but I thought it was the easiest way to
me for me to fetch some images so I can
try this out and see that it's actually
doing something and just by creating
these two new readers I can use all the
logic I had earlier in my setup here one
of the differences in my input layer
before I sent in the size of 28 times 28
pixels and now I need to actually supply
the
of the image that I have fetched from
the reader so that's one difference very
small difference and the fully connected
layer I have actually added number of
classes to it so it will diverge down to
the number of classes instead of ten
that I had earlier and down here where
I'll print the predictions I actually
give it the number of classes in the
predictions instead of just doing a
while loop of the for loop of ten so
that's why I can print number one and
number one and zero as
predictions I could actually go into the
reader and fetch the actual labels so
that could have been a better output
perhaps but I didn't take the time to do
that so that could be and something that
you can do if you want to build on this
and I hope that I answered the question
and from Musamil and I hope that you
learned something in this episode in
this video and if you haven't subscribed
yet please do that I make videos every
Monday morning and please give this
video a like share it with your
colleagues and friends and I really hope
to see you in the next one