Subtitles section Play video Print subtitles YUFENG GUO: Keeras? 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.