Kaaris?

Kras?

Keras?

Carrots?

Keras.

What is Keras, and how can you use

it to get started creating your own machine learning models?

Stay tuned to find out.

[ELECTRONIC BEEPING]

Welcome to Cloud AI Adventures, where

we explore the art, science, and tools of machine learning.

My name is Yufeng Guo.

And on this episode of AI Adventures,

I'll show you how to get started with Keras in the quickest way

possible.

It's never been easier to get started with Keras.

Not only is Keras built into TensorFlow

via tensorflow.keras, you also don't even

have to install or configure anything

if you use a tool like Kaggle Kernels.

All you need to do is create your Kaggle account if needed

and sign in.

Then you have access to all that Keras has to offer.

Keras also exists as a standalone library,

but the TensorFlow version has the exact same APIs

and some extra features.

Let's head over to my Kaggle Kernel,

where I'll show you how to get started using Keras right now.

In a previous episode, we did some machine learning

on the dataset Fashion-MNST.

It's a dataset of 10 different types of fashionable items,

from pants and shirts to shoes and handbags,

all presented in 28 by 28 pixel grayscale.

Mmm, grayscale.

Today, we'll do a similar analysis using Keras.

So to use Keras, we'll just import TensorFlow like usual.

These imports are actually identical to what

we had before.

And we'll pull in numpy, and pandas, and natplotlib

just as we normally would.

And we continue operating kind of in the usual way.

We'll pull in our training and test CSVs

and load them up in pandas and take a look

at what they look like.

We've got our Label column on the far left

with numbers from zero through nine.

And we have our Pixels--

pixel 1, 2, 3, all the way up to pixel 784.

I've got a function here to preprocess

our data a little bit.

It's similar to what we had before.

I've just cleaned it up and made it a little more concise.

I'm pulling out the features and dividing by 255,

so we normalize all the grayscale values

to be between zero and one.

And I'll pull out the labels as well

and have them both be represented as an numpy arrays.

We use that function to pull out our training and test

data from the data frame and associate them

to explicit variables-- train_features

and train_labels, test_features and test_labels.

And we can see that the final shape of these variables

are exactly as we would expect--

60,000 examples with 784 columns.

And then our labels are just the 60,000 values.

And we're going to take a peek at one of them.

This is our 20th training_feature set.

And some pixels in the middle, we

can see that they're indeed values between zero and one.

And we can also visualize it.

Here we have a shirt, and we can see that it looks exactly

as you'd expect--

kind of grainy and grayscale.

Now, with Keras in this particular case,

we're going to need to one-hot hot encode our data.

And what that means is we're going to take our training

labels, which used to be just values like zero, three, seven,

and turn them into--

each of them-- into an array of length 10.

All 10 values in the array will be zeros except for one value.

That one value will be a 1.

And so that's why it's called one-hot encoding.

Now, where is that one located?

It's going to be exactly the number that it came from.

So, for example, if the value was seven,

the seventh zero will be a one.

If the number was four, then the fourth zero will be a one--

hence one-hot encoding.

And so we'll run Keras wtils.to_categorical,

which is a handy utility function that will just do this

for us.

And we'll observe that the train labels have now

turned from 60,000 rows of numbers

to 60,000 rows with 10 columns.

And we can see that indeed, in that same example label that we

saw before now, the zeroth index has a 1,

and everything else remains a zero.

And now comes the really fun part of working with Keras--

creating our model.

Keras supplies a really easy and intuitive way

to build up your model from the ground up.

In this case, we're going to make a sequential model

and add layers on top of it.

The first letter we'll have has 30 nodes

and has an activation function of a rectified linear unit

for relu, which in the case of TensorFlow that we used before,

was the default activation function.

Then we'll have another fully-connected layer

or dense layer with 20 neurons, this time

also with a relu function.

And finally, we'll do our final mapping to the 10 output

values of zero through nine and have an activation

of the softmax, which basically just distributes

power probabilities across the 10 buckets.

And now we're ready to compile our model.

Keras uses this notation of compiling

a model as similar to when you do something

like string builder or something to just say, I'm done.

Put it all together for me.

And we'll supply a loss, optimizer, and metrics

for what kind of values we want to get out of it, for how

to optimize for the best values, as well as

how we want to measure loss.

In this case, we're using categorical cross entropy

because our outputs are categorical.

And cross entropy, in this case, happens to be a nice way

to measure our loss or error.

With our model created, we're ready to run training.

Training with Keras is as easy as calling .fit.

When we call .fit, all we need to supply are

the training_features and training_labels.

It's also a good idea to supply epochs and batch_size

so that we can control the training a little more.

In this case, we have supplied an epoch

of two, which means we'll go through the entire dataset

twice over.

And we'll supply a batch_size of 128.

This means that with each training step,

the model will see 128 examples which will help guide

it to adjust its parameters.

And so we can see here Keras has some really useful helpless

as the training happens and gives us

a sense of the progress.

It also then prints out the loss and accuracy

at the end of each epoch.

But seeing the accuracy at the end loss at the end of training

isn't nearly as useful as evaluation.

We need to see the accuracy against our actual test

dataset.

So let's call our model.evaluate function

and this time pass in our test_features and test_labels.

This will give us an accuracy, and we can

print that out and take a look.

We can see we got 84.7% accuracy.

And of course, we could certainly

do better than that with increased epochs,

a more sophisticated model, and other approaches.

But this is just an intro to Keras.

And hopefully, this will give you a good starting point

to start playing around with Keras

and seeing all that Keras can do.

Keras has an amazing community and lots

of samples which, when you combine

with Kaggle's community, gives you

a truly epic set of resources to get you started the right way.

Thanks for watching this episode of Cloud AI Adventures.

And if you enjoyed it, please like it

and be sure to subscribe to get all the latest episodes right

when they come out.

Now, what are you waiting for?

Head on over to Kaggle and start playing around with Keras

today.