From 446c014d0b63a80d65f2b7cff776b9ee8a9a379c Mon Sep 17 00:00:00 2001 From: Sumedh Date: Fri, 15 Nov 2019 14:32:50 -0500 Subject: [PATCH] update readme --- README.md | 103 +++++++++++++++++++++++++++---------- index.ipynb | 2 +- index_files/index_11_0.png | Bin 0 -> 43209 bytes 3 files changed, 76 insertions(+), 29 deletions(-) create mode 100644 index_files/index_11_0.png diff --git a/README.md b/README.md index 4de80fc..f005693 100644 --- a/README.md +++ b/README.md @@ -3,35 +3,35 @@ ## Introduction -In this lesson, we shall cover decision trees (for classification) in python, using scikit-learn and pandas. The emphasis will be on the basics and understanding the resulting decision tree. Scikit-Learn provides a consistent interface for running different classifiers/regressors. For classification tasks, evaluation is performed using the same measures as we have seen before. Let's look at our example from earlier lessons and grow a tree to find our solution. +In this lesson, we will cover decision trees (for classification) in Python, using scikit-learn and pandas. The emphasis will be on the basics and understanding the resulting decision tree. Scikit-learn provides a consistent interface for running different classifiers/regressors. For classification tasks, evaluation is performed using the same measures as we have seen before. Let's look at our example from earlier lessons and grow a tree to find our solution. + +## Objectives -## Objectives You will be able to: -- Using `pandas` to prepare the data for the scikit-learn decision tree algorithm -- Train the classifier with a training dataset and evaluate performance using different measures -- Visualize the decision tree and interpret the visualization +- Use scikit-learn to fit a decision tree classification model +- Plot a decision tree using Python + -## Import Necessary Libraries +## Import necessary modules and data -In order to prepare data, train, evaluate and visualize a decision tree , we would need a number of packages in python. Here are the packages that you would normally consider importing before moving on. Run the cell below to import everything we'll need for this lesson. +In order to prepare data, train, evaluate, and visualize a decision tree, we will make use of several modules in the scikit-learn package. Run the cell below to import everything we'll need for this lesson: ```python +import numpy as np +import pandas as pd from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeClassifier -from sklearn.metrics import accuracy_score, roc_curve, auc -from sklearn import tree +from sklearn.metrics import accuracy_score +from sklearn.tree import export_graphviz from sklearn.preprocessing import OneHotEncoder from IPython.display import Image from sklearn.tree import export_graphviz -import pandas as pd -import numpy as np +from pydotplus import graph_from_dot_data ``` -## Create Dataframe - -The play tennis dataset is available in the repo as `tennis.csv`. For this step, we'll start by importing the csv file as a pandas dataframe. +The play tennis dataset is available in the repo as `'tennis.csv'`. For this step, we'll start by importing the csv file as a pandas DataFrame. ```python @@ -116,31 +116,31 @@ df.head() -## Create Test and Training sets +## Create training and test sets -Before we do anything we'll want to split our data into **_training_** and **_testing_** sets. We'll accomplish this by first splitting the dataframe into features (`X`) and target (`y`), then passing `X` and `y` to the `train_test_split` function to create a 70/30 train test split. +Before we do anything we'll want to split our data into **_training_** and **_test_** sets. We'll accomplish this by first splitting the DataFrame into features (`X`) and target (`y`), then passing `X` and `y` to the `train_test_split()` function to create a 70/30 train test split. ```python X = df.loc[:, ['outlook', 'temp', 'humidity', 'windy']] y = df.loc[:, 'play'] -X_train, X_test , y_train,y_test = train_test_split(X, y, test_size = 0.3, random_state = 42) +X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 42) ``` -## Encode Categorical Data as numbers +## Encode categorical data as numbers Since all of our data is currently categorical (recall that each column is in string format), we need to encode them as numbers. For this, we'll use a handy helper object from sklearn's `preprocessing` module called `OneHotEncoder`. ```python -#One hot encode the training data and show the resulting dataframe with proper column names +# One-hot encode the training data and show the resulting DataFrame with proper column names ohe = OneHotEncoder() ohe.fit(X_train) X_train_ohe = ohe.transform(X_train).toarray() -#Creating this dataframe is not necessary its only to show the result of the ohe +# Creating this DataFrame is not necessary its only to show the result of the ohe ohe_df = pd.DataFrame(X_train_ohe, columns=ohe.get_feature_names(X_train.columns)) ohe_df.head() @@ -251,27 +251,74 @@ ohe_df.head() -## Train the Decision Tree +## Train the decision tree -One awesome feature of scikit-learn is the uniformity of its interfaces for every classifier--no matter what classifier we're using, we can expect it to have the same important methods such as `.fit()` and `.predict()`. This means that this next part will probably feel a little familiar. +One awesome feature of scikit-learn is the uniformity of its interfaces for every classifier -- no matter what classifier we're using, we can expect it to have the same important methods such as `.fit()` and `.predict()`. This means that this next part should feel familiar. -We'll first create an instance of the classifier with any parameter values, and then we'll fit our data to the model using `.fit()` and make predictions with `X_test` using `.predict()`. +We'll first create an instance of the classifier with any parameter values, and then we'll fit our data to the model using `.fit()`. ```python -#Create the classifier, fit it on the training data and make predictions on the test set +# Create the classifier, fit it on the training data and make predictions on the test set clf = DecisionTreeClassifier(criterion='entropy') -clf.fit(X_train_ohe,y_train) +clf.fit(X_train_ohe, y_train) +``` + + + + + DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=None, + max_features=None, max_leaf_nodes=None, + min_impurity_decrease=0.0, min_impurity_split=None, + min_samples_leaf=1, min_samples_split=2, + min_weight_fraction_leaf=0.0, presort=False, + random_state=None, splitter='best') + + + +## Plot the decision tree + +You can see what rules the tree learned by plotting this decision tree. To do this, you need to use additional packages such as `pytdotplus`. + +> **Note:** If you are run into errors while generating the plot, you probably need to install `python-graphviz` in your machine using `conda install python-graphviz`. + +```python +# Create DOT data +dot_data = export_graphviz(clf, out_file=None, + feature_names=ohe_df.columns, + class_names=np.unique(y).astype('str')) + +# Draw graph +graph = graph_from_dot_data(dot_data) + +# Show graph +Image(graph.create_png()) +``` + + + + +![png](index_files/index_11_0.png) + + + +## Evaluate the predictive performance + +Now that we have a trained model, we can generate some predictions, and go on to see how accurate our predictions are. We can use a simple accuracy measure, AUC, a confusion matrix, or all of them. This step is performed in the exactly the same manner, doesn't matter which classifier you are dealing with. + + +```python X_test_ohe = ohe.transform(X_test) y_preds = clf.predict(X_test_ohe) + +print('Accuracy: ', accuracy_score(y_test, y_preds)) ``` -## Evaluate the Predictive Performance + Accuracy: 0.6 -Now that we have a trained model and we've generated some predictions, we can go on and see how accurate our predictions are. We can use a simple accuracy measure, AUC, a Confusion matrix, or all of them. This step is performed in the exactly the same manner , doesn't matter which classifier you are dealing with. ## Summary -In this lesson, we looked at how to grow a decision tree in scikit-learn and python. We looked at different stages of data processing, training and evaluation that you would normally come across while growing a tree or training any other such classifier. We shall now move to a lab, where you will be required to build a tree for a given problem, following the steps shown in this lesson. +In this lesson, we looked at how to grow a decision tree using `scikit-learn`. We looked at different stages of data processing, training, and evaluation that you would normally come across while growing a tree or training any other such classifier. We shall now move to a lab, where you will be required to build a tree for a given problem, following the steps shown in this lesson. diff --git a/index.ipynb b/index.ipynb index 346f922..1deadef 100644 --- a/index.ipynb +++ b/index.ipynb @@ -1 +1 @@ -{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Building Trees using scikit-learn\n", "\n", "## Introduction\n", "\n", "In this lesson, we shall cover decision trees (for classification) in python, using scikit-learn and pandas. The emphasis will be on the basics and understanding the resulting decision tree. Scikit-Learn provides a consistent interface for running different classifiers/regressors. For classification tasks, evaluation is performed using the same measures as we have seen before. Let's look at our example from earlier lessons and grow a tree to find our solution. \n", "\n", "## Objectives\n", "You will be able to:\n", "\n", "- Using `pandas` to prepare the data for the scikit-learn decision tree algorithm\n", "- Train the classifier with a training dataset and evaluate performance using different measures\n", "- Visualize the decision tree and interpret the visualization\n", "\n", "## Import Necessary Libraries\n", "\n", "In order to prepare data, train, evaluate and visualize a decision tree , we would need a number of packages in python. Here are the packages that you would normally consider importing before moving on. Run the cell below to import everything we'll need for this lesson. "]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": ["from sklearn.model_selection import train_test_split\n", "from sklearn.tree import DecisionTreeClassifier \n", "from sklearn.metrics import accuracy_score, roc_curve, auc\n", "from sklearn import tree \n", "from sklearn.preprocessing import OneHotEncoder\n", "from IPython.display import Image \n", "from sklearn.tree import export_graphviz\n", "import pandas as pd \n", "import numpy as np "]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Create Dataframe\n", "\n", "The play tennis dataset is available in the repo as `tennis.csv`. For this step, we'll start by importing the csv file as a pandas dataframe."]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"data": {"text/html": ["
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
outlooktemphumiditywindyplay
0sunnyhothighFalseno
1sunnyhothighTrueno
2overcasthothighFalseyes
3rainymildhighFalseyes
4rainycoolnormalFalseyes
\n", "
"], "text/plain": [" outlook temp humidity windy play\n", "0 sunny hot high False no\n", "1 sunny hot high True no\n", "2 overcast hot high False yes\n", "3 rainy mild high False yes\n", "4 rainy cool normal False yes"]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["# Load the dataset\n", "df = pd.read_csv('tennis.csv')\n", "\n", "df.head()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Create Test and Training sets\n", "\n", "Before we do anything we'll want to split our data into **_training_** and **_testing_** sets. We'll accomplish this by first splitting the dataframe into features (`X`) and target (`y`), then passing `X` and `y` to the `train_test_split` function to create a 70/30 train test split. "]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": ["X = df.loc[:, ['outlook', 'temp', 'humidity', 'windy']]\n", "y = df.loc[:, 'play']\n", "\n", "X_train, X_test , y_train,y_test = train_test_split(X, y, test_size = 0.3, random_state = 42)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Encode Categorical Data as numbers\n", "\n", "Since all of our data is currently categorical (recall that each column is in string format), we need to encode them as numbers. For this, we'll use a handy helper object from sklearn's `preprocessing` module called `OneHotEncoder`."]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/html": ["
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
outlook_overcastoutlook_rainyoutlook_sunnytemp_cooltemp_hottemp_mildhumidity_highhumidity_normalwindy_Falsewindy_True
00.00.01.01.00.00.00.01.01.00.0
11.00.00.00.01.00.01.00.01.00.0
20.00.01.00.01.00.01.00.00.01.0
30.01.00.00.00.01.01.00.00.01.0
40.01.00.01.00.00.00.01.01.00.0
\n", "
"], "text/plain": [" outlook_overcast outlook_rainy outlook_sunny temp_cool temp_hot \\\n", "0 0.0 0.0 1.0 1.0 0.0 \n", "1 1.0 0.0 0.0 0.0 1.0 \n", "2 0.0 0.0 1.0 0.0 1.0 \n", "3 0.0 1.0 0.0 0.0 0.0 \n", "4 0.0 1.0 0.0 1.0 0.0 \n", "\n", " temp_mild humidity_high humidity_normal windy_False windy_True \n", "0 0.0 0.0 1.0 1.0 0.0 \n", "1 0.0 1.0 0.0 1.0 0.0 \n", "2 0.0 1.0 0.0 0.0 1.0 \n", "3 1.0 1.0 0.0 0.0 1.0 \n", "4 0.0 0.0 1.0 1.0 0.0 "]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["#One hot encode the training data and show the resulting dataframe with proper column names\n", "ohe = OneHotEncoder()\n", "\n", "ohe.fit(X_train)\n", "X_train_ohe = ohe.transform(X_train).toarray()\n", "\n", "#Creating this dataframe is not necessary its only to show the result of the ohe\n", "ohe_df = pd.DataFrame(X_train_ohe, columns=ohe.get_feature_names(X_train.columns))\n", "\n", "ohe_df.head()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Train the Decision Tree \n", "\n", "One awesome feature of scikit-learn is the uniformity of its interfaces for every classifier--no matter what classifier we're using, we can expect it to have the same important methods such as `.fit()` and `.predict()`. This means that this next part will probably feel a little familiar.\n", "\n", "We'll first create an instance of the classifier with any parameter values, and then we'll fit our data to the model using `.fit()` and make predictions with `X_test` using `.predict()`. "]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": ["#Create the classifier, fit it on the training data and make predictions on the test set\n", "clf = DecisionTreeClassifier(criterion='entropy')\n", "\n", "clf.fit(X_train_ohe,y_train)\n", "\n", "X_test_ohe = ohe.transform(X_test)\n", "y_preds = clf.predict(X_test_ohe)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Evaluate the Predictive Performance\n", "\n", "Now that we have a trained model and we've generated some predictions, we can go on and see how accurate our predictions are. We can use a simple accuracy measure, AUC, a Confusion matrix, or all of them. This step is performed in the exactly the same manner , doesn't matter which classifier you are dealing with. \n", "\n", "##\u00a0Summary \n", "\n", "In this lesson, we looked at how to grow a decision tree in scikit-learn and python. We looked at different stages of data processing, training and evaluation that you would normally come across while growing a tree or training any other such classifier. We shall now move to a lab, where you will be required to build a tree for a given problem, following the steps shown in this lesson. "]}], "metadata": {"kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3"}}, "nbformat": 4, "nbformat_minor": 2} \ No newline at end of file +{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Building Trees using scikit-learn\n", "\n", "## Introduction\n", "\n", "In this lesson, we will cover decision trees (for classification) in Python, using scikit-learn and pandas. The emphasis will be on the basics and understanding the resulting decision tree. Scikit-learn provides a consistent interface for running different classifiers/regressors. For classification tasks, evaluation is performed using the same measures as we have seen before. Let's look at our example from earlier lessons and grow a tree to find our solution. \n", "\n", "## Objectives \n", "\n", "You will be able to:\n", "\n", "- Use scikit-learn to fit a decision tree classification model \n", "- Plot a decision tree using Python \n", "\n", "\n", "## Import necessary modules and data\n", "\n", "In order to prepare data, train, evaluate, and visualize a decision tree, we will make use of several modules in the scikit-learn package. Run the cell below to import everything we'll need for this lesson: "]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": ["import numpy as np \n", "import pandas as pd \n", "from sklearn.model_selection import train_test_split\n", "from sklearn.tree import DecisionTreeClassifier \n", "from sklearn.metrics import accuracy_score\n", "from sklearn.tree import export_graphviz\n", "from sklearn.preprocessing import OneHotEncoder\n", "from IPython.display import Image \n", "from sklearn.tree import export_graphviz\n", "from pydotplus import graph_from_dot_data"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The play tennis dataset is available in the repo as `'tennis.csv'`. For this step, we'll start by importing the csv file as a pandas DataFrame."]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"data": {"text/html": ["
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
outlooktemphumiditywindyplay
0sunnyhothighFalseno
1sunnyhothighTrueno
2overcasthothighFalseyes
3rainymildhighFalseyes
4rainycoolnormalFalseyes
\n", "
"], "text/plain": [" outlook temp humidity windy play\n", "0 sunny hot high False no\n", "1 sunny hot high True no\n", "2 overcast hot high False yes\n", "3 rainy mild high False yes\n", "4 rainy cool normal False yes"]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["# Load the dataset\n", "df = pd.read_csv('tennis.csv')\n", "\n", "df.head()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Create training and test sets\n", "\n", "Before we do anything we'll want to split our data into **_training_** and **_test_** sets. We'll accomplish this by first splitting the DataFrame into features (`X`) and target (`y`), then passing `X` and `y` to the `train_test_split()` function to create a 70/30 train test split."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": ["X = df.loc[:, ['outlook', 'temp', 'humidity', 'windy']]\n", "y = df.loc[:, 'play']\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 42)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Encode categorical data as numbers\n", "\n", "Since all of our data is currently categorical (recall that each column is in string format), we need to encode them as numbers. For this, we'll use a handy helper object from sklearn's `preprocessing` module called `OneHotEncoder`."]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/html": ["
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
outlook_overcastoutlook_rainyoutlook_sunnytemp_cooltemp_hottemp_mildhumidity_highhumidity_normalwindy_Falsewindy_True
00.00.01.01.00.00.00.01.01.00.0
11.00.00.00.01.00.01.00.01.00.0
20.00.01.00.01.00.01.00.00.01.0
30.01.00.00.00.01.01.00.00.01.0
40.01.00.01.00.00.00.01.01.00.0
\n", "
"], "text/plain": [" outlook_overcast outlook_rainy outlook_sunny temp_cool temp_hot \\\n", "0 0.0 0.0 1.0 1.0 0.0 \n", "1 1.0 0.0 0.0 0.0 1.0 \n", "2 0.0 0.0 1.0 0.0 1.0 \n", "3 0.0 1.0 0.0 0.0 0.0 \n", "4 0.0 1.0 0.0 1.0 0.0 \n", "\n", " temp_mild humidity_high humidity_normal windy_False windy_True \n", "0 0.0 0.0 1.0 1.0 0.0 \n", "1 0.0 1.0 0.0 1.0 0.0 \n", "2 0.0 1.0 0.0 0.0 1.0 \n", "3 1.0 1.0 0.0 0.0 1.0 \n", "4 0.0 0.0 1.0 1.0 0.0 "]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["# One-hot encode the training data and show the resulting DataFrame with proper column names\n", "ohe = OneHotEncoder()\n", "\n", "ohe.fit(X_train)\n", "X_train_ohe = ohe.transform(X_train).toarray()\n", "\n", "# Creating this DataFrame is not necessary its only to show the result of the ohe\n", "ohe_df = pd.DataFrame(X_train_ohe, columns=ohe.get_feature_names(X_train.columns))\n", "\n", "ohe_df.head()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Train the decision tree \n", "\n", "One awesome feature of scikit-learn is the uniformity of its interfaces for every classifier -- no matter what classifier we're using, we can expect it to have the same important methods such as `.fit()` and `.predict()`. This means that this next part should feel familiar.\n", "\n", "We'll first create an instance of the classifier with any parameter values, and then we'll fit our data to the model using `.fit()`. "]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"data": {"text/plain": ["DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=None,\n", " max_features=None, max_leaf_nodes=None,\n", " min_impurity_decrease=0.0, min_impurity_split=None,\n", " min_samples_leaf=1, min_samples_split=2,\n", " min_weight_fraction_leaf=0.0, presort=False,\n", " random_state=None, splitter='best')"]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["# Create the classifier, fit it on the training data and make predictions on the test set\n", "clf = DecisionTreeClassifier(criterion='entropy')\n", "\n", "clf.fit(X_train_ohe, y_train)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Plot the decision tree \n", "\n", "You can see what rules the tree learned by plotting this decision tree. To do this, you need to use additional packages such as `pytdotplus`. \n", "\n", "> **Note:** If you are run into errors while generating the plot, you probably need to install `python-graphviz` in your machine using `conda install python-graphviz`. "]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": [""]}, "execution_count": 6, "metadata": {}, "output_type": "execute_result"}], "source": ["# Create DOT data\n", "dot_data = export_graphviz(clf, out_file=None, \n", " feature_names=ohe_df.columns, \n", " class_names=np.unique(y).astype('str'))\n", "\n", "# Draw graph\n", "graph = graph_from_dot_data(dot_data) \n", "\n", "# Show graph\n", "Image(graph.create_png())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Evaluate the predictive performance\n", "\n", "Now that we have a trained model, we can generate some predictions, and go on to see how accurate our predictions are. We can use a simple accuracy measure, AUC, a confusion matrix, or all of them. This step is performed in the exactly the same manner, doesn't matter which classifier you are dealing with. "]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Accuracy: 0.6\n"]}], "source": ["X_test_ohe = ohe.transform(X_test)\n", "y_preds = clf.predict(X_test_ohe)\n", "\n", "print('Accuracy: ', accuracy_score(y_test, y_preds))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["##\u00a0Summary \n", "\n", "In this lesson, we looked at how to grow a decision tree using `scikit-learn`. We looked at different stages of data processing, training, and evaluation that you would normally come across while growing a tree or training any other such classifier. We shall now move to a lab, where you will be required to build a tree for a given problem, following the steps shown in this lesson. "]}], "metadata": {"kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3"}}, "nbformat": 4, "nbformat_minor": 2} \ No newline at end of file diff --git a/index_files/index_11_0.png b/index_files/index_11_0.png new file mode 100644 index 0000000000000000000000000000000000000000..683c7e34305151641e9cf3f5b41ff262795c3dd6 GIT binary patch literal 43209 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 xZKUM$$ literal 0 HcmV?d00001