How to load a custom dataset with tf.data [Tensorflow] Video Lecture | Machine Learning with Java - AI & ML

hello explorers and welcome to another
video today I'm gonna talk a little bit
about TF data or tensorflow data and
this come about because I watched the
tensorflow summit and they talked a lot
about tensorflow data and this new
API that you can use to actually make
things easy for yourself easily read
data into a system and easily make
better performant models and I thought
that that was really interesting so I
wanted to try it out so I went to
their home page and looked at the
documentation and I thought it was quite
hard to follow
so I actually wanted to make this video
to give you an understanding on how you
can set it up and how you can get
started much quicker than I actually got
and everything that I will show today is
up on my github so you can see it there
and let's get started we are talking
about code and first off we have two
feature functions here and these are
just wrapper functions that will take
some value and wrap it inside of a byte
list or an int 64 list so an int of size
64 so these are just some simple
functions to make features of data and
then we have this little load image
function it takes an image it resizes it
to one size and then changes the color
to RGB so that's what I want my image to
be when I actually are working with them
and all the images that I load today
come from a data set that were a
competition of some sort to train cats
and dogs images and see if we can
figure out what's a cat what's a dog and
yeah alone and this image set has a lot
of different sizes of images and so on
so if you actually want
make this viable set you should actually
look at the images maybe filter some of
them out maybe do some pre steps in
the images to actually make the
classification more viable and and get a
better trained model and usually when
you're working with datasets you really
want to find good solutions to actually
clean up your datasets as much as
possible and of course if you want to
find things in dirty datasets then you
might might want to train with dirty
datasets as well but as we don't build a
function that will find let's say a dog
in an image we just want to see if this
is an image of a dog then it might be
better to do that beforehand and then we
have the next function here will
actually create a data record and these
are the TF record files that the data TF
data will use when it reads in TF data
can read CSV files and other files but
they are good at reading binary TF
records so these this is the way to
create those and you create a
writer from Python io TF record right
there
and the output file name and then I have
an little function here so I go through
all the addresses of all the images and
I take a little print out each thousand
that I do because there are think twenty
five thousand images so we could be good
to have some progress you know how much
you have actually read I load the image I
take the label for that image if I
didn't get any image then skip this one
and then I create a new feature with the
wrapping of bytes for the image and then
I wrap the label with an int 64 and then
I create an example so I wrap everything
in the feature with a which I wrap in an
example
that example I will serialize to the
writer and write out the file and what
I've done I close to the file and I'm
and flush everything out and when I
create this you will get three
different files I will look at those
later and those are in the range of
eight gigabytes and to gigabytes so
they're quite large so you need to have
some space on your disk if you want to
run this example and then I set up at
path a glob to where my images are so in
my directory pet images I have cats and
dogs so this star here is the
cat directory and the dog directory and
then I have some jpegs and all the
jpegs are one two three four five
dot jpg and I read the addresses from
this glob command and the labels will
actually take the address and then look
if the address has the word cat in it so
if the directory is cat you will set 0
in the label else it will get a 1 in the
label and we'll have created these I
will actually zip these together and
create a list I will shove that list and
then I will unzip that list again so I
will actually get the address and labels
back it's a really neat feature in
Python actually I didn't know that you
could do things like this I'm not
usually writing that much Python code so
it was really nice to see this another
nice feature that you see down here is
where I split up my training set into
60%
training 20% validation and 20% test
data it's very easily done with these
array ranges and when I've done this I
will create records for the training
addresses their validation addresses and
the testing addresses and I will put
those in different files with their
labels
so what I've done that prepared the data
and have these large files then we will
go into the training part of of this
video so this is the training and we
first off look at setting up a new
session and initializing the global
variables and then I have this parse
function I have up here and that will
actually take one record from the TF
record file and parse it out so I
actually get the label and the image out
so first off I need to say what kind of
features I actually had in my file I
have this image raw and the label and these
are strings and int 64 so this is just to
define how the data structure in the
file is set up and then I will read one
record from the file and then I will
take the image raw part out and take
bites out of it and decode the raw image
here I will cast the image to floats
because that's what the model needs and
I will also reshape the image so it
actually is in the shape of the size of
the image so it's at 224 times 224 and
three colors or a depth of three and
then I will read out the label and I
will cast that to int 32 because that
will be used in the model as well and
that I will return that from my parser
and the estimate I will use later will
need an input function and I will create
this input function from this helper
function I have here and it will first
off create my data record so this is a
dataset of the TF record so this is the
TF data we talked about earlier that you
could do a lot of performance
enhancements on and so on since this is
the API that I want to do showcase in
this video and also I created my data
set I will map it through my parser so I
actually will parse the labels and the
images
and if I'm in training that I will
shuffle them up and if not in training I
will only repeat ones and not
shuffle them because I want to have a
good evaluation every time the same and
then I will repeat and setup the
batch size the batch size is 32 in this
case I make a one-shot in iterator and I
get the batch of the iterators and
return that batch back to the training
function so then I set up a training
function here with the train records and
the test records and I set training to
true and then I do the same with
the validation records but I set
training to false and so these are the
train input function and the validation
input function and the first and you see
here I have some code add commented out
here it's just to print the image I
wanted to see that after had saved it
down and read it again I want to see
that I had this same image I can verify
that I didn't do anything wrong in that
process and here I have feature columns
that I want to run through a fully
connected classifier so I set up this
one and it has layers here 128 64 32
and 16 and so this is what was one of
the networks that I tried and it has an
adam optimizer and I ran it through
100,000 steps and it ran I think four
thousand per 10 minutes so night I was
able to run this little classifier and I
got about forty nine fifty percent right
so it was just like a coin flip
it was totally worthless or it wasn't it
wasn't more wrong than if I just guessed
but it wasn't
good either and so that I wanted to try
a little bit more sophisticated model so
I have my model function here and I set
up in network that we have seen
before it's one convolution with some
pooling then a convolution again with
some pooling we flatten the net and then
we do two fully connected layers and
then we take the predictions down here
if you want to actually do predict
something so this is if we want to go
into the predict mode of the estimator
then we need to take out the prediction
and the prediction class and if not
then we just put this result of the
network into the sparse soft max cross
entropy with logits function and we
reduce and find how much loss we have we
run that through an adam optimizer and
we return some metrics so we can see how
accurate we are now and then we create
this estimator specification down here
that we actually return and in order to
set up a new estimate that we want to
run we put our model function into it we
give it a learning rate and that
learning rate is used inside of the adam
optimizer we set the model dir so it
knows where to save all the all the
files when it does snapshots and then we
have a little function here while I go
through 100,000 times again but in this
case I actually want to evaluate off the
thousand print the result and the
accuracy and then I flush it out and
then I try around another pass and I've
run this for a little while I was a
little bit pressed on time but the best
it started somewhere around 70% and I
think the best result I got was 71 or 72
something like that and that could
either
mean that I have an unclean dataset so I
might want to find a good function to
clean it up and maybe another function
to crop the images so I don't lose that
much when I actually resize them maybe I
used too little image maybe I want to
use larger images but that will also
slow down the training and maybe I could
fix my model maybe I can have a better
model I've just tried with this model
and but that could be tweaked as well to
get a better performance or accuracy in
the model and but I think this is a good
starting point so you can see how you
can set up things and actually get the
TF record working with tensorflow data
and everything else after that is
optimization I hope that you found this
video interesting I hope that you
learned something today if you have any
questions about tensorflow data or this
set up then please ask in the comments
below all the code you can find on
github I will leave the link below as
well and if you like this video give it
a like share it with your friends and
colleagues and if you haven't subscribed
yet please do that and I really hope to
see you in the next video