{ "cells": [ { "cell_type": "markdown", "source": [ "## Example Decision Tree Notebook" ], "metadata": {} }, { "cell_type": "code", "execution_count": 1, "source": [ "# Importing required libraries\n", "\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import warnings\n", "\n", "warnings.filterwarnings('ignore')" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": 2, "source": [ "# Import Car Evaluation Datasetcar.names\n", "# Refer https://archive.ics.uci.edu/ml/machine-learning-databases/car/\n", "df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/car/car.data', header=None)" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": 3, "source": [ "df.shape" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "(1728, 7)" ] }, "metadata": {}, "execution_count": 3 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 4, "source": [ "df.head()" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ " 0 1 2 3 4 5 6\n", "0 vhigh vhigh 2 2 small low unacc\n", "1 vhigh vhigh 2 2 small med unacc\n", "2 vhigh vhigh 2 2 small high unacc\n", "3 vhigh vhigh 2 2 med low unacc\n", "4 vhigh vhigh 2 2 med med unacc" ], "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", "
0123456
0vhighvhigh22smalllowunacc
1vhighvhigh22smallmedunacc
2vhighvhigh22smallhighunacc
3vhighvhigh22medlowunacc
4vhighvhigh22medmedunacc
\n", "
" ] }, "metadata": {}, "execution_count": 4 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 5, "source": [ "# Rename Columns\n", "df.columns = ['buying', 'maint', 'doors', 'persons', 'lug_boot', 'safety', 'class']\n", "df.sample()" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ " buying maint doors persons lug_boot safety class\n", "1465 low high 4 2 big med unacc" ], "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", "
buyingmaintdoorspersonslug_bootsafetyclass
1465lowhigh42bigmedunacc
\n", "
" ] }, "metadata": {}, "execution_count": 5 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 6, "source": [ "# Summary of Data\n", "df.info()\n", "df.describe().T" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", "RangeIndex: 1728 entries, 0 to 1727\n", "Data columns (total 7 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 buying 1728 non-null object\n", " 1 maint 1728 non-null object\n", " 2 doors 1728 non-null object\n", " 3 persons 1728 non-null object\n", " 4 lug_boot 1728 non-null object\n", " 5 safety 1728 non-null object\n", " 6 class 1728 non-null object\n", "dtypes: object(7)\n", "memory usage: 94.6+ KB\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ " count unique top freq\n", "buying 1728 4 high 432\n", "maint 1728 4 high 432\n", "doors 1728 4 5more 432\n", "persons 1728 3 more 576\n", "lug_boot 1728 3 med 576\n", "safety 1728 3 high 576\n", "class 1728 4 unacc 1210" ], "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", "
countuniquetopfreq
buying17284high432
maint17284high432
doors172845more432
persons17283more576
lug_boot17283med576
safety17283high576
class17284unacc1210
\n", "
" ] }, "metadata": {}, "execution_count": 6 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 7, "source": [ "# Frequency Distribution of Attributes\n", "for col in df.columns:\n", " print(df[col].value_counts()) " ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "high 432\n", "low 432\n", "med 432\n", "vhigh 432\n", "Name: buying, dtype: int64\n", "high 432\n", "low 432\n", "med 432\n", "vhigh 432\n", "Name: maint, dtype: int64\n", "5more 432\n", "2 432\n", "4 432\n", "3 432\n", "Name: doors, dtype: int64\n", "more 576\n", "2 576\n", "4 576\n", "Name: persons, dtype: int64\n", "med 576\n", "small 576\n", "big 576\n", "Name: lug_boot, dtype: int64\n", "high 576\n", "low 576\n", "med 576\n", "Name: safety, dtype: int64\n", "unacc 1210\n", "acc 384\n", "good 69\n", "vgood 65\n", "Name: class, dtype: int64\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Data Summary\n", "\n", "There are 7 attributes in the dataset. All the attributes are of categorical data type.\n", "\n", "These are given by buying, maint, doors, persons, lug_boot, safety and class.\n", "\n", "**class** is the target attribute, which has the following values:\n", "- unacc (70%)\n", "- acc (22.22%)\n", "- good (4%)\n", "- vgood (3.8%)" ], "metadata": {} }, { "cell_type": "code", "execution_count": 8, "source": [ "# check missing values in variables\n", "df.isnull().sum()" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "buying 0\n", "maint 0\n", "doors 0\n", "persons 0\n", "lug_boot 0\n", "safety 0\n", "class 0\n", "dtype: int64" ] }, "metadata": {}, "execution_count": 8 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 9, "source": [ "# Split Feature & Target attributes\n", "\n", "X = X = df.drop(['class'], axis=1)\n", "\n", "y = df['class']" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": 10, "source": [ "# split X and y into training and testing sets\n", "\n", "from sklearn.model_selection import train_test_split\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 100)" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": 11, "source": [ "# Check the shapes of training and testing sets\n", "X_train.shape, y_train.shape, X_test.shape, y_test.shape" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "((1209, 6), (1209,), (519, 6), (519,))" ] }, "metadata": {}, "execution_count": 11 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 12, "source": [ "# Encode the categorical variables\n", "import category_encoders as ce\n", "\n", "# encode variables with ordinal encoding\n", "encoder = ce.OrdinalEncoder(cols=['buying', 'maint', 'doors', 'persons', 'lug_boot', 'safety'])\n", "\n", "X_train = encoder.fit_transform(X_train)\n", "\n", "X_test = encoder.transform(X_test)" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": 13, "source": [ "X_train.head()" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ " buying maint doors persons lug_boot safety\n", "774 1 1 1 1 1 1\n", "1021 2 2 2 1 2 2\n", "105 3 3 3 1 3 1\n", "44 3 3 2 2 3 3\n", "1374 4 3 4 1 3 1" ], "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", "
buyingmaintdoorspersonslug_bootsafety
774111111
1021222122
105333131
44332233
1374434131
\n", "
" ] }, "metadata": {}, "execution_count": 13 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 14, "source": [ "X_test.head()" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ " buying maint doors persons lug_boot safety\n", "27 3 3 2 3 1 1\n", "1156 2 4 4 1 2 2\n", "1668 4 1 2 1 2 1\n", "1622 4 1 1 3 1 3\n", "692 1 4 2 2 3 3" ], "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", "
buyingmaintdoorspersonslug_bootsafety
27332311
1156244122
1668412121
1622411313
692142233
\n", "
" ] }, "metadata": {}, "execution_count": 14 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 15, "source": [ "# The dataset is now ready for modelling\n", "# import DecisionTreeClassifier\n", "from sklearn.tree import DecisionTreeClassifier\n", "\n", "# instantiate the DecisionTreeClassifier model with criterion gini index\n", "clf_gini = DecisionTreeClassifier(criterion='gini', max_depth=3, random_state=0)" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": 16, "source": [ "# Fit the model\n", "clf_gini.fit(X_train, y_train)" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "DecisionTreeClassifier(max_depth=3, random_state=0)" ] }, "metadata": {}, "execution_count": 16 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 22, "source": [ "# Predict by using Testing set\n", "y_pred_gini = clf_gini.predict(X_test)\n", "y_pred_gini" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "array(['unacc', 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'unacc',\n", " 'unacc', 'acc', 'unacc', 'acc', 'unacc', 'acc', 'unacc', 'unacc',\n", " 'unacc', 'unacc', 'unacc', 'unacc', 'acc', 'acc', 'unacc', 'unacc',\n", " 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'acc', 'unacc',\n", " 'unacc', 'acc', 'acc', 'acc', 'unacc', 'unacc', 'acc', 'acc',\n", " 'acc', 'unacc', 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'unacc',\n", " 'unacc', 'unacc', 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'unacc',\n", " 'unacc', 'acc', 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'acc',\n", " 'acc', 'unacc', 'acc', 'unacc', 'acc', 'acc', 'unacc', 'unacc',\n", " 'acc', 'unacc', 'unacc', 'acc', 'acc', 'acc', 'unacc', 'acc',\n", " 'acc', 'acc', 'unacc', 'unacc', 'unacc', 'acc', 'unacc', 'acc',\n", " 'acc', 'unacc', 'unacc', 'acc', 'acc', 'acc', 'unacc', 'acc',\n", " 'acc', 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'unacc',\n", " 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'acc', 'unacc', 'acc',\n", " 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'acc', 'unacc', 'acc',\n", " 'acc', 'unacc', 'acc', 'unacc', 'acc', 'acc', 'unacc', 'unacc',\n", " 'acc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc',\n", " 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc',\n", " 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'unacc',\n", " 'acc', 'unacc', 'unacc', 'unacc', 'acc', 'acc', 'acc', 'unacc',\n", " 'acc', 'unacc', 'acc', 'acc', 'unacc', 'acc', 'unacc', 'unacc',\n", " 'unacc', 'unacc', 'acc', 'acc', 'acc', 'acc', 'acc', 'unacc',\n", " 'acc', 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'acc',\n", " 'unacc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc',\n", " 'unacc', 'unacc', 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'acc',\n", " 'unacc', 'unacc', 'unacc', 'acc', 'acc', 'acc', 'unacc', 'acc',\n", " 'acc', 'unacc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'acc',\n", " 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'acc', 'acc', 'unacc',\n", " 'unacc', 'acc', 'acc', 'acc', 'unacc', 'unacc', 'acc', 'acc',\n", " 'unacc', 'acc', 'acc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc',\n", " 'unacc', 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'unacc', 'acc',\n", " 'unacc', 'acc', 'unacc', 'acc', 'acc', 'unacc', 'acc', 'acc',\n", " 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'unacc',\n", " 'unacc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc', 'acc',\n", " 'acc', 'acc', 'acc', 'unacc', 'acc', 'unacc', 'unacc', 'acc',\n", " 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc', 'acc', 'unacc',\n", " 'acc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc',\n", " 'acc', 'unacc', 'unacc', 'unacc', 'acc', 'unacc', 'acc', 'unacc',\n", " 'unacc', 'acc', 'unacc', 'acc', 'unacc', 'acc', 'acc', 'acc',\n", " 'unacc', 'acc', 'unacc', 'acc', 'unacc', 'unacc', 'unacc', 'acc',\n", " 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'acc',\n", " 'unacc', 'unacc', 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'acc',\n", " 'acc', 'acc', 'unacc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc',\n", " 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'unacc',\n", " 'acc', 'acc', 'unacc', 'unacc', 'acc', 'acc', 'acc', 'acc',\n", " 'unacc', 'acc', 'unacc', 'acc', 'acc', 'acc', 'unacc', 'unacc',\n", " 'acc', 'acc', 'acc', 'acc', 'unacc', 'unacc', 'acc', 'unacc',\n", " 'unacc', 'acc', 'unacc', 'unacc', 'acc', 'acc', 'acc', 'acc',\n", " 'acc', 'unacc', 'acc', 'unacc', 'unacc', 'unacc', 'acc', 'unacc',\n", " 'acc', 'unacc', 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'acc',\n", " 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc',\n", " 'unacc', 'acc', 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'unacc',\n", " 'acc', 'unacc', 'unacc', 'unacc', 'acc', 'acc', 'unacc', 'unacc',\n", " 'unacc', 'unacc', 'unacc', 'unacc', 'unacc', 'acc', 'unacc', 'acc',\n", " 'unacc', 'unacc', 'acc', 'unacc', 'acc', 'acc', 'acc', 'acc',\n", " 'unacc', 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc', 'acc',\n", " 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'acc', 'unacc', 'acc',\n", " 'unacc', 'acc', 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'acc',\n", " 'unacc', 'acc', 'acc', 'unacc', 'acc', 'acc', 'unacc', 'acc',\n", " 'unacc', 'acc', 'unacc', 'unacc', 'acc', 'acc', 'acc', 'unacc',\n", " 'acc', 'unacc', 'unacc', 'unacc', 'unacc', 'unacc', 'acc', 'acc',\n", " 'acc', 'acc', 'unacc', 'acc', 'acc', 'unacc', 'acc', 'unacc',\n", " 'unacc', 'acc', 'unacc', 'unacc', 'acc', 'unacc', 'unacc', 'acc',\n", " 'acc', 'acc', 'acc', 'unacc', 'acc', 'unacc', 'unacc', 'acc',\n", " 'unacc', 'unacc', 'unacc', 'acc', 'unacc', 'acc', 'unacc', 'acc',\n", " 'unacc'], dtype=object)" ] }, "metadata": {}, "execution_count": 22 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 18, "source": [ "from sklearn.metrics import accuracy_score\n", "\n", "print('Model accuracy score with criterion gini index: {0:0.4f}'. format(accuracy_score(y_test, y_pred_gini)))" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Model accuracy score with criterion gini index: 0.7842\n" ] } ], "metadata": {} }, { "cell_type": "code", "execution_count": 19, "source": [ "# Let's compare training and test set accuracy to check whether we have overfitting problem\n", "y_pred_train_gini = clf_gini.predict(X_train)\n", "print('Training-set accuracy score: {0:0.4f}'. format(accuracy_score(y_train, y_pred_train_gini)))" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Training-set accuracy score: 0.7750\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Here, the training-set accuracy score is 0.7865 while the test-set accuracy to be 0.8021. These two values are quite comparable. So, there is no sign of overfitting." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Visualising Decision Tree" ], "metadata": {} }, { "cell_type": "code", "execution_count": 20, "source": [ "plt.figure(figsize=(12,8))\n", "\n", "from sklearn import tree\n", "\n", "tree.plot_tree(clf_gini.fit(X_train, y_train)) " ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[Text(267.84000000000003, 380.52, 'X[5] <= 1.5\\ngini = 0.463\\nsamples = 1209\\nvalue = [274, 48, 840, 47]'),\n", " Text(133.92000000000002, 271.8, 'gini = 0.0\\nsamples = 400\\nvalue = [0, 0, 400, 0]'),\n", " Text(401.76000000000005, 271.8, 'X[3] <= 2.5\\ngini = 0.583\\nsamples = 809\\nvalue = [274, 48, 440, 47]'),\n", " Text(267.84000000000003, 163.07999999999998, 'X[0] <= 3.5\\ngini = 0.628\\nsamples = 546\\nvalue = [274, 48, 177, 47]'),\n", " Text(133.92000000000002, 54.360000000000014, 'gini = 0.578\\nsamples = 406\\nvalue = [205, 19, 164, 18]'),\n", " Text(401.76000000000005, 54.360000000000014, 'gini = 0.663\\nsamples = 140\\nvalue = [69, 29, 13, 29]'),\n", " Text(535.6800000000001, 163.07999999999998, 'gini = 0.0\\nsamples = 263\\nvalue = [0, 0, 263, 0]')]" ] }, "metadata": {}, "execution_count": 20 }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Visualising Decision Tree using Graphwiz" ], "metadata": {} }, { "cell_type": "code", "execution_count": 23, "source": [ "y_train.unique()" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "array(['unacc', 'acc', 'good', 'vgood'], dtype=object)" ] }, "metadata": {}, "execution_count": 23 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 24, "source": [ "import graphviz \n", "dot_data = tree.export_graphviz(clf_gini, out_file=None, \n", " feature_names=X_train.columns, \n", " class_names=y_train.unique(), \n", " filled=True, rounded=True, \n", " special_characters=True)\n", "\n", "graph = graphviz.Source(dot_data) \n", "\n", "graph " ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ], "image/svg+xml": "\n\n\n\n\n\nTree\n\n\n\n0\n\nsafety ≤ 1.5\ngini = 0.463\nsamples = 1209\nvalue = [274, 48, 840, 47]\nclass = good\n\n\n\n1\n\ngini = 0.0\nsamples = 400\nvalue = [0, 0, 400, 0]\nclass = good\n\n\n\n0->1\n\n\nTrue\n\n\n\n2\n\npersons ≤ 2.5\ngini = 0.583\nsamples = 809\nvalue = [274, 48, 440, 47]\nclass = good\n\n\n\n0->2\n\n\nFalse\n\n\n\n3\n\nbuying ≤ 3.5\ngini = 0.628\nsamples = 546\nvalue = [274, 48, 177, 47]\nclass = unacc\n\n\n\n2->3\n\n\n\n\n\n6\n\ngini = 0.0\nsamples = 263\nvalue = [0, 0, 263, 0]\nclass = good\n\n\n\n2->6\n\n\n\n\n\n4\n\ngini = 0.578\nsamples = 406\nvalue = [205, 19, 164, 18]\nclass = unacc\n\n\n\n3->4\n\n\n\n\n\n5\n\ngini = 0.663\nsamples = 140\nvalue = [69, 29, 13, 29]\nclass = unacc\n\n\n\n3->5\n\n\n\n\n\n" }, "metadata": {}, "execution_count": 24 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 25, "source": [ "# Decision Tree using Entropy method\n", "clf_en = DecisionTreeClassifier(criterion='entropy', max_depth=3, random_state=0)\n", "\n", "# fit the model\n", "clf_en.fit(X_train, y_train)\n", "\n", "y_pred_en = clf_en.predict(X_test)" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": 26, "source": [ "y_pred_train_en = clf_en.predict(X_train)\n", "print('Training-set accuracy score: {0:0.4f}'. format(accuracy_score(y_train, y_pred_train_en)))\n", "print('Model accuracy score with criterion entropy: {0:0.4f}'. format(accuracy_score(y_test, y_pred_en)))" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Training-set accuracy score: 0.7750\n", "Model accuracy score with criterion entropy: 0.7842\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "We can see that the training-set score and test-set score is same as above. The training-set accuracy score is 0.7865 while the test-set accuracy to be 0.8021. These two values are quite comparable. So, there is no sign of overfitting." ], "metadata": {} }, { "cell_type": "code", "execution_count": 27, "source": [ "# Visalising the Trees\n", "tree.plot_tree(clf_en.fit(X_train, y_train)) " ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[Text(133.92000000000002, 190.26, 'X[5] <= 1.5\\nentropy = 1.217\\nsamples = 1209\\nvalue = [274, 48, 840, 47]'),\n", " Text(66.96000000000001, 135.9, 'entropy = 0.0\\nsamples = 400\\nvalue = [0, 0, 400, 0]'),\n", " Text(200.88000000000002, 135.9, 'X[3] <= 2.5\\nentropy = 1.487\\nsamples = 809\\nvalue = [274, 48, 440, 47]'),\n", " Text(133.92000000000002, 81.53999999999999, 'X[0] <= 3.5\\nentropy = 1.639\\nsamples = 546\\nvalue = [274, 48, 177, 47]'),\n", " Text(66.96000000000001, 27.180000000000007, 'entropy = 1.432\\nsamples = 406\\nvalue = [205, 19, 164, 18]'),\n", " Text(200.88000000000002, 27.180000000000007, 'entropy = 1.762\\nsamples = 140\\nvalue = [69, 29, 13, 29]'),\n", " Text(267.84000000000003, 81.53999999999999, 'entropy = 0.0\\nsamples = 263\\nvalue = [0, 0, 263, 0]')]" ] }, "metadata": {}, "execution_count": 27 }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "code", "execution_count": 29, "source": [ "\n", "dot_data = tree.export_graphviz(clf_en, out_file=None, \n", " feature_names=X_train.columns, \n", " class_names=y_train.unique(), \n", " filled=True, rounded=True, \n", " special_characters=True)\n", "\n", "graph = graphviz.Source(dot_data) \n", "\n", "graph " ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ], "image/svg+xml": "\n\n\n\n\n\nTree\n\n\n\n0\n\nsafety ≤ 1.5\nentropy = 1.217\nsamples = 1209\nvalue = [274, 48, 840, 47]\nclass = good\n\n\n\n1\n\nentropy = 0.0\nsamples = 400\nvalue = [0, 0, 400, 0]\nclass = good\n\n\n\n0->1\n\n\nTrue\n\n\n\n2\n\npersons ≤ 2.5\nentropy = 1.487\nsamples = 809\nvalue = [274, 48, 440, 47]\nclass = good\n\n\n\n0->2\n\n\nFalse\n\n\n\n3\n\nbuying ≤ 3.5\nentropy = 1.639\nsamples = 546\nvalue = [274, 48, 177, 47]\nclass = unacc\n\n\n\n2->3\n\n\n\n\n\n6\n\nentropy = 0.0\nsamples = 263\nvalue = [0, 0, 263, 0]\nclass = good\n\n\n\n2->6\n\n\n\n\n\n4\n\nentropy = 1.432\nsamples = 406\nvalue = [205, 19, 164, 18]\nclass = unacc\n\n\n\n3->4\n\n\n\n\n\n5\n\nentropy = 1.762\nsamples = 140\nvalue = [69, 29, 13, 29]\nclass = unacc\n\n\n\n3->5\n\n\n\n\n\n" }, "metadata": {}, "execution_count": 29 } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Now, based on the above analysis we can conclude that our classification model accuracy is very good. Our model is doing a very good job in terms of predicting the class labels.\n", "\n", "But, it does not give the underlying distribution of values. Also, it does not tell anything about the type of errors our classifer is making.\n", "\n", "Confusion matrix & Classification Report helps us here." ], "metadata": {} }, { "cell_type": "code", "execution_count": 30, "source": [ "from sklearn.metrics import confusion_matrix,classification_report\n", "\n", "cm = confusion_matrix(y_test, y_pred_en)\n", "\n", "print('Confusion matrix\\n', cm)\n", "print('\\nClassification Report\\n', classification_report(y_test, y_pred_en))" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Confusion matrix\n", " [[110 0 0 0]\n", " [ 21 0 0 0]\n", " [ 73 0 297 0]\n", " [ 18 0 0 0]]\n", "\n", "Classification Report\n", " precision recall f1-score support\n", "\n", " acc 0.50 1.00 0.66 110\n", " good 0.00 0.00 0.00 21\n", " unacc 1.00 0.80 0.89 370\n", " vgood 0.00 0.00 0.00 18\n", "\n", " accuracy 0.78 519\n", " macro avg 0.37 0.45 0.39 519\n", "weighted avg 0.82 0.78 0.78 519\n", "\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Thanks" ], "metadata": {} } ], "metadata": { "orig_nbformat": 4, "language_info": { "name": "python", "version": "3.7.7", "mimetype": "text/x-python", "codemirror_mode": { "name": "ipython", "version": 3 }, "pygments_lexer": "ipython3", "nbconvert_exporter": "python", "file_extension": ".py" }, "kernelspec": { "name": "python3", "display_name": "Python 3.7.7 64-bit ('base': conda)" }, "interpreter": { "hash": "bcd536b112177b246be875d0fc803659e1c59a72fc2d6d6ea1bfc9bd71a21aa6" } }, "nbformat": 4, "nbformat_minor": 2 }