[MUSIC]

We're going to use a Python library called scikit-learn, which includes lots

of well designed tools for performing common machine learning tasks.

We're going to install scikit-learn and its dependencies using Anaconda,

which is a Python based platform focused on data science and machine learning.

If you haven't installed Anaconda already,

check the notes associated with this video for instructions on how to do that first.

It's easy and quick to set up, so if you don't have it yet,

pause this video and come back when you have Anaconda running.

You'll also need to download the project files associated with this video.

Inside the ZIP file, you'll find a file called environment.yml.

Remember where you save this file, because you'll need to find it again later.

Once you have Anaconda Navigator open on your computer and

the environment.yml file downloaded, you're ready to get started.

Inside Anaconda Navigator, click the Environments tab on the left.

And by default, you should have at least one environment already, called base.

But to make sure that you have all the dependencies installed that you'll need,

I've created an environment for us to use.

Click the Import button at the bottom of the environments list.

Then click the folder icon on the right side.

And locate the environment.yml file

that you saved earlier and click Open.

The .yml file will suggest a name for your environment.

In this case, it's MachineLearningBasics, which is the name of this course.

However, you can rename the environment to something else if you'd prefer,

when you're done, choose Import, This will

begin the process of downloading and installing all the dependencies

you'll need to use scikit-learn, including scikit-learn itself.

This might take a few minutes,

depending on the speed of your Internet connection and your computer.

While that's running, let's take a look at the documentation for

scikit-learn to get a little more familiar.

Point your web browser to scikit-learn.org, you

can find a link in the notes associated with this video if that's easier for you.

And, well, you've already seen the home page in a previous video,

let's click on Classification.

This is a list of all the different types of supervised learning functions and

algorithms within scikit-learn.

It's quite a long list and

it can be challenging to understand which tools we should use.

That's not something we'll be able to get into in this course.

But as we learned previously, supervised learning starts with a dataset.

And that's what we want, so we know we're in the right place.

Scroll down to the section labeled 1.10, Decision Trees.

Then click the first link underneath that header that says 1.10.1, Classification.

DecisionTreeClassifier is the class that we'll use.

It says, DecisionTreeClassifier is a class

capable of performing multi-class classification on a dataset.

As with other classifiers,

DecisionTreeClassifier takes as input two arrays.

An array x, sparse or dense, of size n_samples and

n_features, holding the training samples.

And an array y of integer values size n_samples,

holding the class labels for the training samples.

In other words, a DecisionTreeClassifier is one type of classifier.

In this case, it's model that tries to predict a value by making

its own choices and rules that are inferred from the data features.

The programming behind this is pretty complicated, but essentially,

the computer tries to fit the data to a pattern.

And using other methods in the DecisionTreeClassifier class,

you can visualize the decision path of the tree and

have the computer show how it arrived at a certain prediction.

Looking at the example here, the DecisionTreeClassifier

starts with a dataset in the form of an array.

This data will be all of our examples, broken out by feature.

And then we have another array that contains our labels for the data.

Then we create a DecisionTreeClassifier object and

use its function called fit to build a DecisionTreeClassifier from the dataset.

In other words, this is where the decision tree is created.

And using that same decision tree,

we can now predict new examples that don't have labels.

That's a lot of information to take in, and for the sake of keeping this

overview at a high level, I've simplified a lot of the details.

But by now, your environment should be done installing.

And in the next video,

we're going to go over that same code again by writing it ourselves.

To learn more right now, I highly recommend you check out the notes

associated with this video, and read the scikit-learn documentation for yourself.