Welcome back.

We've covered a lot of ground already,

so today I want to review and reinforce concepts.

To do that, we'll explore two things.

First, we'll code up a basic pipeline

for supervised learning.

I'll show you how multiple classifiers

can solve the same problem.

Next, we'll build up a little more intuition

for what it means for an algorithm to learn something

from data, because that sounds kind of magical, but it's not.

To kick things off, let's look at a common experiment

you might want to do.

Imagine you're building a spam classifier.

That's just a function that labels an incoming email

as spam or not spam.

Now, say you've already collected a data set

and you're ready to train a model.

But before you put it into production,

there's a question you need to answer first--

how accurate will it be when you use it to classify emails that

weren't in your training data?

As best we can, we want to verify our models work well

before we deploy them.

And we can do an experiment to help us figure that out.

One approach is to partition our data set into two parts.

We'll call these Train and Test.

We'll use Train to train our model

and Test to see how accurate it is on new data.

That's a common pattern, so let's see how it looks in code.

To kick things off, let's import a data set into [? SyKit. ?]

We'll use Iris again, because it's handily included.

Now, we already saw Iris in episode two.

But what we haven't seen before is

that I'm calling the features x and the labels y.

Why is that?

Well, that's because one way to think of a classifier

is as a function.

At a high level, you can think of x as the input

and y as the output.

I'll talk more about that in the second half of this episode.

After we import the data set, the first thing we want to do

is partition it into Train and Test.

And to do that, we can import a handy utility,

and it makes the syntax clear.

We're taking our x's and our y's,

or our features and labels, and partitioning them

into two sets.

X_train and y_train are the features and labels

for the training set.

And X_test and y_test are the features and labels

for the testing set.

Here, I'm just saying that I want half the data to be

used for testing.

So if we have 150 examples in Iris, 75 will be in Train

and 75 will be in Test.

Now we'll create our classifier.

I'll use two different types here

to show you how they accomplish the same task.

Let's start with the decision tree we've already seen.

Note there's only two lines of code

that are classifier-specific.

Now let's train the classifier using our training data.

At this point, it's ready to be used to classify data.

And next, we'll call the predict method

and use it to classify our testing data.

If you print out the predictions,

you'll see there are a list of numbers.

These correspond to the type of Iris

the classifier predicts for each row in the testing data.

Now let's see how accurate our classifier

was on the testing set.

Recall that up top, we have the true labels for the testing

data.

To calculate our accuracy, we can

compare the predicted labels to the true labels,

and tally up the score.

There's a convenience method in [? Sykit ?]

we can import to do that.

Notice here, our accuracy was over 90%.

If you try this on your own, it might be a little bit different

because of some randomness in how the Train/Test

data is partitioned.

Now, here's something interesting.

By replacing these two lines, we can use a different classifier

to accomplish the same task.

Instead of using a decision tree,

we'll use one called [? KNearestNeighbors. ?]

If we run our experiment, we'll see that the code

works in exactly the same way.

The accuracy may be different when you run it,

because this classifier works a little bit differently

and because of the randomness in the Train/Test split.

Likewise, if we wanted to use a more sophisticated classifier,

we could just import it and change these two lines.

Otherwise, our code is the same.

The takeaway here is that while there are many different types

of classifiers, at a high level, they have a similar interface.

Now let's talk a little bit more about what

it means to learn from data.

Earlier, I said we called the features x and the labels y,

because they were the input and output of a function.

Now, of course, a function is something we already

know from programming.

def classify-- there's our function.

As we already know in supervised learning,

we don't want to write this ourselves.

We want an algorithm to learn it from training data.

So what does it mean to learn a function?

Well, a function is just a mapping from input

to output values.

Here's a function you might have seen before-- y

equals mx plus b.

That's the equation for a line, and there

are two parameters-- m, which gives the slope;

and b, which gives the y-intercept.

Given these parameters, of course,

we can plot the function for different values of x.

Now, in supervised learning, our classified function

might have some parameters as well,

but the input x are the features for an example we

want to classify, and the output y

is a label, like Spam or Not Spam, or a type of flower.

So what could the body of the function look like?

Well, that's the part we want to write algorithmically

or in other words, learn.

The important thing to understand here

is we're not starting from scratch

and pulling the body of the function out of thin air.

Instead, we start with a model.

And you can think of a model as the prototype for

or the rules that define the body of our function.

Typically, a model has parameters

that we can adjust with our training data.

And here's a high-level example of how this process works.

Let's look at a toy data set and think about what kind of model

we could use as a classifier.

Pretend we're interested in distinguishing

between red dots and green dots, some of which

I've drawn here on a graph.

To do that, we'll use just two features--

the x- and y-coordinates of a dot.

Now let's think about how we could classify this data.

We want a function that considers

a new dot it's never seen before,

and classifies it as red or green.

In fact, there might be a lot of data we want to classify.

Here, I've drawn our testing examples

in light green and light red.

These are dots that weren't in our training data.

The classifier has never seen them before, so how can

it predict the right label?

Well, imagine if we could somehow draw a line

across the data like this.

Then we could say the dots to the left

of the line are green and dots to the right of the line are

red.

And this line can serve as our classifier.

So how can we learn this line?

Well, one way is to use the training data to adjust

the parameters of a model.

And let's say the model we use is a simple straight line

like we saw before.

That means we have two parameters to adjust-- m and b.

And by changing them, we can change where the line appears.

So how could we learn the right parameters?

Well, one idea is that we can iteratively adjust

them using our training data.

For example, we might start with a random line

and use it to classify the first training example.

If it gets it right, we don't need to change our line,

so we move on to the next one.

But on the other hand, if it gets it wrong,

we could slightly adjust the parameters of our model

to make it more accurate.

The takeaway here is this.

One way to think of learning is using training data

to adjust the parameters of a model.

Now, here's something really special.

It's called tensorflow/playground.

This is a beautiful example of a neural network

you can run and experiment with right in your browser.

Now, this deserves its own episode for sure,

but for now, go ahead and play with it.

It's awesome.

The playground comes with different data

sets you can try out.

Some are very simple.

For example, we could use our line to classify this one.

Some data sets are much more complex.

This data set is especially hard.

And see if you can build a network to classify it.

Now, you can think of a neural network

as a more sophisticated type of classifier,

like a decision tree or a simple line.

But in principle, the idea is similar.

OK.

Hope that was helpful.

I just created a Twitter that you can follow

to be notified of new episodes.

And the next one should be out in a couple of weeks,

depending on how much work I'm doing for Google I/O. Thanks,

as always, for watching, and I'll see you next time.