LAURENCE MORONEY: Hi, and welcome to part three

of this series on using Google Colab to code, train, and test

neural networks in the browser without needing to install

any kind of a runtime.

In the previous video, I showed you

how you can install TensorFlow with Colab.

In this video, I'll show you then

how you can use TensorFlow to build

a neural network for breast cancer classification.

It runs completely in the browser using Colab,

and it's really quick to train and test.

The data for training this neural network

comes from the Diagnostic Wisconsin Breast Cancer

Database.

You can find it at the URL in the description.

It has close to 600 samples of data,

each from a cell biopsy, where 30 features have

been extracted per cell.

I've pre-processed the data into several CSV files

so we can just focus on the neural network itself.

Let's now take a look at the code

for training this neural network using this data so you

can use that network to then perform breast cancer

classification yourself.

Let's start with uploading the CSV files.

Now, that's a really neat thing in Colab,

that you can load external data into it.

I'm going to load my CSVs into panda

dataframes with this code.

Next, using Keros in the sequential API,

I'm going to create a neural network

with an input dimension of 30.

And that's because each of these cells has 30 features.

And we'll then have a layer of 16, then 8, then 6,

and then, finally, 1.

The final layer will be activated

by a Sigmoid function, which will push it

towards a 1 or a 0.

Now we're classifying two features, so that's perfect.

The network itself will need to have a loss function

and an optimizer defined on it.

On each iteration, it measures how well it did in training

using the loss function.

It then tries to improve on that using the optimizer.

And as you'll see in a moment, the training process

has 100 steps, with this loop happening once per step.

The training itself takes place in the Fit function.

Here, I pass in the training x's and y's, and I

specify how many times it will loop,

where a loop is it making a guess at the relationship

between the x and the y.

It measures how well or how badly it does using the loss

function, and then it improves on its guess

using the optimizer.

It's coded to do that 100 times, but you

can amend that easily and explore the results

for yourself.

As you'll see, once it finishes training,

the loss is 0.0595, showing that it's about 94% accurate.

We can now test that network with data

that the neural network hasn't yet seen.

This is the x-test data.

So we'll get a set of y predictions for this data.

Now, these predictions are going to be a probability.

They're not a 0 or a 1, but values that

are close to 0 or close to 1.

So we'll write this code that takes all of the values that

are less than 0.5 and consider that to be 0

and everything else to be a 1.

And now, here's some simple code that

will compare the predicted values

for the test set against the actual known

values for the same set.

Now, there were 114 values in this test set,

and you'll see it gets it 100% correct.

Now, remember earlier we said it was about 94% accurate.

So why do you think it gets it 100% correct?

Well, that's a little homework for you to do.

Post your answers in the comments below

and let's see who can get it right.

And that's it for this episode.

And in the next video in this series,

my colleague, Paige, will show you

about how to use different runtimes and processors

and how to use your code to take advantage of GPUs and TPUs

right in your browser.

So whatever you do, don't forget to hit that subscribe button,

and you'll be able to catch up with it.

Thank you.

[MUSIC PLAYING]