Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.
Start a free Basic trial
to watch this video
A classifier looks at a piece of data and tries to categorize it. In this video, we'll use scikit-learn to write a classifier using the dataset we loaded previously.
Resources
Python Code
from sklearn.datasets import load_iris
iris = load_iris()
print(list(iris.target_names))
from sklearn import tree
classifier = tree.DecisionTreeClassifier()
classifier = classifier.fit(iris.data, iris.target)
print(classifier.predict([[5.1,3.5,1.4,1.5]]))
-
0:00
In order to make predictions, we need to choose a classification model.
-
0:05
And we're going to use the decision tree classifier that we looked at earlier.
-
0:10
Back in your Python file, let's add to the program on the next few lines.
-
0:15
First, we'll import scikit-learn's module,
-
0:20
which includes all of the decision tree models.
-
0:27
So we'll type from sklearn import tree.
-
0:34
Next, we'll create a decision tree classifier and
-
0:38
assign it to a variable so we can work with it.
-
0:42
We'll type classifier as the name of my variable, and we'll set that
-
0:48
to tree.DecisionTreeClassifier and
-
0:56
that's a function, so add parenthesis at the end.
-
1:00
Now, we need to actually build the DecisionTree through which
-
1:05
each new example will flow.
-
1:08
This decision tree can be built by feeding it both the training example and
-
1:13
the target labels using the fit function, like this.
-
1:19
So, again, we'll use our classifier variable and
-
1:27
we'll type classifier.fit
-
1:34
And inside of this function, we'll pass the Iris.data,
-
1:41
and then the iris.target or the labels.
-
1:46
So just to review, we've created a decision tree model.
-
1:52
And now we're actually building the decision tree using its fit function
-
1:56
which takes a set of examples and the target labels.
-
2:00
For more on the fit function, check out the notes associated with this video.
-
2:05
At this point the data is loaded and we've built a decision tree based on that data.
-
2:10
Now we can feed a new example into the top of that decision tree, and
-
2:15
it will flow through each branching decision like a flow chart
-
2:19
until it finally reaches its target label.
-
2:24
Now finally comes the part we've been working toward, making predictions.
-
2:28
We can do this using the predict function on the decision tree classifier,
-
2:34
like this.
-
2:36
So first, this is something I'm going to want to print out.
-
2:39
And inside of the print function, I'll type classifier.predict,
-
2:47
and we'll open and close some parentheses.
-
2:52
I am wrapping this in a print function just so
-
2:54
that we can see the outcome of the code when we run it.
-
2:58
Inside of the predict parentheses,
-
3:02
create two sets of nested square brackets, like this.
-
3:08
So there's the first pair.
-
3:10
And then inside of those square brackets, we'll make another pair of opening and
-
3:15
closing square brackets.
-
3:18
The outermost set of square brackets is an array of our examples.
-
3:24
The innermost set of square brackets
-
3:27
is where we'll put the values of features for a single example.
-
3:33
So in other words, we could predict multiple examples at a time, but
-
3:38
we're just sticking with one for now.
-
3:40
So let's start out by testing the model to make sure it's working correctly.
-
3:47
We can do that by just putting in an example from the data set.
-
3:52
From the Wikipedia page,
-
3:53
I'll type in the first example from the data set which happens to be a setosa.
-
4:01
So inside of the innermost square brackets,
-
4:06
I'll type 5.1, 3.5, 1.4, and 0.2.
-
4:12
And if we go back to the Wikipedia page to look at that,
-
4:18
again, you can see that this first example should be a setosa.
-
4:27
And now let's save it and then back in the terminal, we'll run the code.
-
4:35
So I'll just hit the up arrow to get the previous command and hit Enter.
-
4:42
And the output should be the names of the flowers because we still have
-
4:46
the Iris.target_names printing first.
-
4:50
And then next, we have this index (0), which is exactly what we want.
-
4:57
Remember, arrays start counting indices at 0.
-
5:01
And, in this case, the index is referring to these labels.
-
5:06
A setosa is 0, Versicolor is 1, and virginica is 2.
-
5:13
So zero is indeed a setosa, and so
-
5:16
we know that the model is predicting this correctly.
-
5:21
So now let's mess with this data a little bit.
-
5:24
In the data set, most of the setosas have a pedal width of about 0.2.
-
5:31
With examples ranging from 0.1 up to 0.6.
-
5:36
However, versicolors range from 1.0 to 1.8.
-
5:41
And then virginicas have petal widths from 1.4 to 2.5.
-
5:46
So in our example, let's change this last
-
5:51
feature to something like 1.5 instead.
-
5:57
That would be well above normal for a setosa, but
-
6:01
match the upper end of versicolors and just barely make the cut of virginicas.
-
6:08
Now save the code, and let's run it again.
-
6:15
You should see either a 0 or a 1.
-
6:19
If you hit the up arrow and hit enter, again and
-
6:23
again to execute the same code, you should see both numbers appearing.
-
6:31
That's because the decision tree classifier randomly chooses a feature
-
6:35
that it thinks will make the best comparison.
-
6:38
However, because we're always working with probabilistic behavior in machine
-
6:43
learning, we wont necessarily get the same result on every run.
-
6:48
This can indicate a low level of confidence which make sense.
-
6:53
The other values in our new example
-
6:57
don't line up with any other examples in the data set.
-
7:00
And we've pushed the pedal width enough
-
7:03
that the classifier can't really draw any confident conclusion.
-
7:07
It's somewhere between a setosa and a versicolor.
-
7:13
That's it for coding.
-
7:14
In our next video, we'll review some of the big ideas we've learned.
You need to sign up for Treehouse in order to download course files.
Sign up