ML0101EN-Clas-Decision-Trees-drug.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decision Trees\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Table of contents</h1>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "    <ol>\n",
    "        <li><a href=\"https://#about_dataset\">About the dataset</a></li>\n",
    "        <li><a href=\"https://#downloading_data\">Downloading the Data</a></li>\n",
    "        <li><a href=\"https://#pre-processing\">Pre-processing</a></li>\n",
    "        <li><a href=\"https://#setting_up_tree\">Setting up the Decision Tree</a></li>\n",
    "        <li><a href=\"https://#modeling\">Modeling</a></li>\n",
    "        <li><a href=\"https://#prediction\">Prediction</a></li>\n",
    "        <li><a href=\"https://#evaluation\">Evaluation</a></li>\n",
    "        <li><a href=\"https://#visualization\">Visualization</a></li>\n",
    "    </ol>\n",
    "</div>\n",
    "<br>\n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the Following Libraries:\n",
    "\n",
    "<ul>\n",
    "    <li> <b>numpy (as np)</b> </li>\n",
    "    <li> <b>pandas</b> </li>\n",
    "    <li> <b>DecisionTreeClassifier</b> from <b>sklearn.tree</b> </li>\n",
    "</ul>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if you uisng you own version comment out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Surpress warnings:\n",
    "def warn(*args, **kwargs):\n",
    "    pass\n",
    "import warnings\n",
    "warnings.warn = warn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np \n",
    "import pandas as pd\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "import sklearn.tree as tree\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"about_dataset\">\n",
    "    <h2>About the dataset</h2>\n",
    "    Imagine that you are a medical researcher compiling data for a study. You have collected data about a set of patients, all of whom suffered from the same illness. During their course of treatment, each patient responded to one of 5 medications, Drug A, Drug B, Drug c, Drug x and y. \n",
    "    <br>\n",
    "    <br>\n",
    "    Part of your job is to build a model to find out which drug might be appropriate for a future patient with the same illness. The features of this dataset are Age, Sex, Blood Pressure, and the Cholesterol of the patients, and the target is the drug that each patient responded to.\n",
    "    <br>\n",
    "    <br>\n",
    "    It is a sample of multiclass classifier, and you can use the training part of the dataset \n",
    "    to build a decision tree, and then use it to predict the class of an unknown patient, or to prescribe a drug to a new patient.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"downloading_data\"> \n",
    "    <h2>Downloading the Data</h2>\n",
    "    To download the data, we will use pandas library to read itdirectly into a dataframe from IBM Object Storage.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Age</th>\n",
       "      <th>Sex</th>\n",
       "      <th>BP</th>\n",
       "      <th>Cholesterol</th>\n",
       "      <th>Na_to_K</th>\n",
       "      <th>Drug</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>23</td>\n",
       "      <td>F</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>25.355</td>\n",
       "      <td>drugY</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>47</td>\n",
       "      <td>M</td>\n",
       "      <td>LOW</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>13.093</td>\n",
       "      <td>drugC</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>47</td>\n",
       "      <td>M</td>\n",
       "      <td>LOW</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>10.114</td>\n",
       "      <td>drugC</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>28</td>\n",
       "      <td>F</td>\n",
       "      <td>NORMAL</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>7.798</td>\n",
       "      <td>drugX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>61</td>\n",
       "      <td>F</td>\n",
       "      <td>LOW</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>18.043</td>\n",
       "      <td>drugY</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Age Sex      BP Cholesterol  Na_to_K   Drug\n",
       "0   23   F    HIGH        HIGH   25.355  drugY\n",
       "1   47   M     LOW        HIGH   13.093  drugC\n",
       "2   47   M     LOW        HIGH   10.114  drugC\n",
       "3   28   F  NORMAL        HIGH    7.798  drugX\n",
       "4   61   F     LOW        HIGH   18.043  drugY"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_data = pd.read_csv('https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/data/drug200.csv', delimiter=\",\")\n",
    "my_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div href=\"pre-processing\">\n",
    "    <h2>Pre-processing</h2>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using <b>my_data</b> as the Drug.csv data read by pandas, declare the following variables: <br>\n",
    "\n",
    "<ul>\n",
    "    <li> <b> X </b> as the <b> Feature Matrix </b> (data of my_data) </li>\n",
    "    <li> <b> y </b> as the <b> response vector </b> (target) </li>\n",
    "</ul>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove the column containing the target name since it doesn't contain numeric values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[23, 'F', 'HIGH', 'HIGH', 25.355],\n",
       "       [47, 'M', 'LOW', 'HIGH', 13.093],\n",
       "       [47, 'M', 'LOW', 'HIGH', 10.114],\n",
       "       [28, 'F', 'NORMAL', 'HIGH', 7.798],\n",
       "       [61, 'F', 'LOW', 'HIGH', 18.043]], dtype=object)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = my_data[['Age', 'Sex', 'BP', 'Cholesterol', 'Na_to_K']].values\n",
    "X[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you may figure out, some features in this dataset are categorical, such as **Sex** or **BP**. Unfortunately, Sklearn Decision Trees does not handle categorical variables. We can still convert these features to numerical values using the **LabelEncoder() method**\n",
    "to convert the categorical variable into dummy/indicator variables.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[23, 0, 0, 0, 25.355],\n",
       "       [47, 1, 1, 0, 13.093],\n",
       "       [47, 1, 1, 0, 10.114],\n",
       "       [28, 0, 2, 0, 7.798],\n",
       "       [61, 0, 1, 0, 18.043]], dtype=object)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import preprocessing\n",
    "le_sex = preprocessing.LabelEncoder() #object creation to convert the categorical variable into dummy/indicator variables\n",
    "le_sex.fit(['F','M']) #model creation\n",
    "X[:,1] = le_sex.transform(X[:,1]) #model transformation\n",
    "\n",
    "\n",
    "le_BP = preprocessing.LabelEncoder()\n",
    "le_BP.fit([ 'LOW', 'NORMAL', 'HIGH'])\n",
    "X[:,2] = le_BP.transform(X[:,2])\n",
    "\n",
    "\n",
    "le_Chol = preprocessing.LabelEncoder()\n",
    "le_Chol.fit([ 'NORMAL', 'HIGH'])\n",
    "X[:,3] = le_Chol.transform(X[:,3]) \n",
    "\n",
    "X[0:5]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can fill the target variable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique values: [0 1]\n",
      "Counts: [ 96 104]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#with numpy array\n",
    "group_names = ['F', 'M']\n",
    "unique_values, counts = np.unique(X[:,1], return_counts=True)\n",
    "plt.bar(group_names, counts)\n",
    "print(\"Unique values:\", unique_values)\n",
    "print(\"Counts:\", counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 3 artists>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_data[\"BP\"].unique()\n",
    "plt.bar(my_data[\"BP\"].unique(), my_data[\"BP\"].value_counts().values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 2 artists>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_data[\"Cholesterol\"].unique()\n",
    "plt.bar(my_data[\"Cholesterol\"].unique(), my_data[\"Cholesterol\"].value_counts().values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    drugY\n",
       "1    drugC\n",
       "2    drugC\n",
       "3    drugX\n",
       "4    drugY\n",
       "Name: Drug, dtype: object"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = my_data[\"Drug\"]\n",
    "y[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 5 artists>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_data[\"Drug\"].unique()\n",
    "plt.bar(my_data[\"Drug\"].unique(), my_data[\"Drug\"].value_counts().values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<div id=\"setting_up_tree\">\n",
    "    <h2>Setting up the Decision Tree</h2>\n",
    "    We will be using <b>train/test split</b> on our <b>decision tree</b>. Let's import <b>train_test_split</b> from <b>sklearn.cross_validation</b>.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now <b> train_test_split </b> will return 4 different parameters. We will name them:<br>\n",
    "X_trainset, X_testset, y_trainset, y_testset <br> <br>\n",
    "The <b> train_test_split </b> will need the parameters: <br>\n",
    "X, y, test_size=0.3, and random_state=3. <br> <br>\n",
    "The <b>X</b> and <b>y</b> are the arrays required before the split, the <b>test_size</b> represents the ratio of the testing dataset, and the <b>random_state</b> ensures that we obtain the same splits.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_trainset, X_testset, y_trainset, y_testset = train_test_split(X, y, test_size=0.3, random_state=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(140, 5)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_trainset.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(140,)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_trainset.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<div id=\"modeling\">\n",
    "    <h2><b>Modeling</b></h2>\n",
    "    We will first create an instance of the <b>DecisionTreeClassifier</b> called <b>drugTree</b>.<br>\n",
    "    Inside of the classifier, specify <i> criterion=\"entropy\" </i> so we can see the information gain of each node.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"DecisionTreeClassifier\">\n",
    "    <h3>DecisionTreeClassifier</h3>\n",
    "    The DecisionTreeClassifier is a class provided by the sklearn.tree module in the scikit-learn library, which is used for classification tasks. It      implements a decision tree classifier, which is a powerful and versatile machine learning model used for both classification and regression tasks.<br>\n",
    "    <b>Key Features of DecisionTreeClassifier:</b>\n",
    "    <ul>\n",
    "        <li>Interpretability: Decision trees are easy to interpret and visualize, which makes them useful for understanding the model's decision-making process.</li>\n",
    "         <li>Non-linearity: They can handle non-linear relationships between features and target variables.</li>\n",
    "         <li>Minimal data preparation: Decision trees don't require scaling of data or extensive preprocessing.</li>\n",
    "         <li>Handling of different data types: They can work with both numerical and categorical data.</li>\n",
    "    </ul>\n",
    "    <b>Important Parameter</b>\n",
    "    <ul>\n",
    "        <li><b>criterion</b>: The function to measure the quality of a split. Supported criteria are \"gini\" for the Gini impurity and \"entropy\" for the information gain.DEFAULT:\"gini\"</li>\n",
    "         <li><b>splitter</b>: The strategy used to choose the split at each node. Supported strategies are \"best\" to choose the best split and \"random\" to choose the best random split.DEFAULT:\"best\"</li>\n",
    "         <li><b>max_depth</b>: The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples.DEFAULT:\"None\"</li>\n",
    "         <li><b>min_samples_split</b>: The minimum number of samples required to split an internal node.DEFAULT:\"2\"</li>\n",
    "         <li><b>min_samples_leaf</b>: The minimum number of samples required to be at a leaf node.DEFAULT:\"1\"</li>\n",
    "         <li><b>random_state</b>: The random_state parameter in scikit-learn is used to control the randomness of certain algorithms and processes to ensure reproducibility of results. When you set random_state to a specific integer, you are essentially fixing the seed of the random number generator, which ensures that the same sequence of random numbers is generated each time the code is run. This makes the results deterministic and reproducible, which is crucial for debugging, comparing results, and sharing code.</li>\n",
    "        <li><b>n_jobs</b>: The n_jobs parameter is a common parameter in many scikit-learn estimators and functions that support parallel processing. It specifies the number of jobs (i.e., CPU cores) to use for computation.This parameter is particularly useful when working with large datasets or performing tasks that can be parallelized, such as fitting a model, cross-validation, or making predictions. </li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>DecisionTreeClassifier(criterion=&#x27;entropy&#x27;, max_depth=4)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">DecisionTreeClassifier</label><div class=\"sk-toggleable__content\"><pre>DecisionTreeClassifier(criterion=&#x27;entropy&#x27;, max_depth=4)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "DecisionTreeClassifier(criterion='entropy', max_depth=4)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "drugTree = DecisionTreeClassifier(criterion=\"entropy\", max_depth = 4)\n",
    "drugTree # it shows the default parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will fit the data with the training feature matrix <b> X_trainset </b> and training  response vector <b> y_trainset </b>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-2 {color: black;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>DecisionTreeClassifier(criterion=&#x27;entropy&#x27;, max_depth=4)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">DecisionTreeClassifier</label><div class=\"sk-toggleable__content\"><pre>DecisionTreeClassifier(criterion=&#x27;entropy&#x27;, max_depth=4)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "DecisionTreeClassifier(criterion='entropy', max_depth=4)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "drugTree.fit(X_trainset,y_trainset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<h3><b>Probabilities</b></h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Mean probabilities give you an idea of the model's confidence in its predictions, feature importance scores provide insight into which features are most influential in making those predictions. These are complementary pieces of information:\n",
    "\n",
    "Mean Probabilities: Help understand the general confidence of the model across different classes.\n",
    "Feature Importance: Indicates which features contribute most to the decision-making process of the model.\n",
    "By combining these insights, you can better understand your model's behavior and the role of different features.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean probabilities for each class: [0.11428571 0.07857143 0.07857143 0.23571429 0.49285714]\n"
     ]
    }
   ],
   "source": [
    "probabilities=drugTree.predict_proba(X_trainset)\n",
    "# Calculate mean probabilities for each class\n",
    "mean_probabilities = np.mean(probabilities, axis=0)\n",
    "print(\"Mean probabilities for each class:\", mean_probabilities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature importances: [0.09749785 0.         0.3295848  0.05454991 0.51836744]\n",
      "Features sorted by importance:\n",
      "Feature 4, Importance: 0.5183674355996556\n",
      "Feature 2, Importance: 0.32958480372190085\n",
      "Feature 0, Importance: 0.09749784755516422\n",
      "Feature 3, Importance: 0.05454991312327922\n",
      "Feature 1, Importance: 0.0\n"
     ]
    }
   ],
   "source": [
    "# Get feature importances\n",
    "feature_importances = drugTree.feature_importances_\n",
    "print(\"Feature importances:\", feature_importances)\n",
    "\n",
    "# Optionally, sort and display feature importances\n",
    "sorted_indices = np.argsort(feature_importances)[::-1]\n",
    "print(\"Features sorted by importance:\")\n",
    "for idx in sorted_indices:\n",
    "    print(f\"Feature {idx}, Importance: {feature_importances[idx]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "<hr>\n",
    "<div id=\"Relationship Between Predictive Probability and Entropy\">\n",
    "     <h2>Relationship Between Predictive Probability and Entropy</h2>\n",
    " When you notice that features with high probability (i.e., those that strongly influence the target variable) also have high entropy, it might indicate the following:\n",
    "<ul>\n",
    "    <li>\n",
    "       Importance and Variability: Features that are important for predicting the target variable may show high variability, thus having higher entropy. This variability can provide more information about the target variable, making the feature more valuable for prediction.\n",
    "    </li>\n",
    "    <li>\n",
    "       Model Sensitivity: The model might be sensitive to features with higher entropy because these features introduce more variation in the data, allowing the model to differentiate between classes more effectively.\n",
    "    </li>\n",
    "</ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<div id=\"prediction\">\n",
    "    <h2>Prediction</h2>\n",
    "    Let's make some <b>predictions</b> on the testing dataset and store it into a variable called <b>predTree</b>.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "predTree = drugTree.predict(X_testset) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can print out <b>predTree</b> and <b>y_testset</b> if you want to visually compare the predictions to the actual values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['drugY' 'drugX' 'drugX' 'drugX' 'drugX']\n",
      "40     drugY\n",
      "51     drugX\n",
      "139    drugX\n",
      "197    drugX\n",
      "170    drugX\n",
      "Name: Drug, dtype: object\n"
     ]
    }
   ],
   "source": [
    "print (predTree [0:5])\n",
    "print (y_testset [0:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<div id=\"evaluation\">\n",
    "    <h2>Evaluation</h2>\n",
    "    Next, let's import <b>metrics</b> from sklearn and check the accuracy of our model.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import confusion_matrix,classification_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['drugY', 'drugX', 'drugC', 'drugA', 'drugB'], dtype=object)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_testset.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7,  0,  0,  0,  0],\n",
       "       [ 0,  5,  0,  0,  0],\n",
       "       [ 0,  0,  5,  0,  0],\n",
       "       [ 0,  0,  0, 20,  1],\n",
       "       [ 0,  0,  0,  0, 22]], dtype=int64)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p =confusion_matrix(y_testset, predTree)\n",
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "       drugA       1.00      1.00      1.00         7\n",
      "       drugB       1.00      1.00      1.00         5\n",
      "       drugC       1.00      1.00      1.00         5\n",
      "       drugX       1.00      0.95      0.98        21\n",
      "       drugY       0.96      1.00      0.98        22\n",
      "\n",
      "    accuracy                           0.98        60\n",
      "   macro avg       0.99      0.99      0.99        60\n",
      "weighted avg       0.98      0.98      0.98        60\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_testset, predTree))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DecisionTrees's Accuracy:  0.9833333333333333\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "import matplotlib.pyplot as plt\n",
    "print(\"DecisionTrees's Accuracy: \", metrics.accuracy_score(y_testset, predTree))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Accuracy classification score** computes subset accuracy: the set of labels predicted for a sample must exactly match the corresponding set of labels in y_true.\n",
    "\n",
    "In multilabel classification, the function returns the subset accuracy. If the entire set of predicted labels for a sample strictly matches with the true set of labels, then the subset accuracy is 1.0; otherwise it is 0.0.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<div id=\"visualization\">\n",
    "    <h2>Visualization</h2>\n",
    "\n",
    "Let's visualize the tree\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Retrieving notices: ...working... done\n",
      "Channels:\n",
      " - conda-forge\n",
      " - defaults\n",
      "Platform: win-64\n",
      "Collecting package metadata (repodata.json): ...working... done\n",
      "Solving environment: ...working... done\n",
      "\n",
      "# All requested packages already installed.\n",
      "\n",
      "Channels:\n",
      " - conda-forge\n",
      " - defaults\n",
      "Platform: win-64\n",
      "Collecting package metadata (repodata.json): ...working... done\n",
      "Solving environment: ...working... done\n",
      "\n",
      "# All requested packages already installed.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Notice: You might need to uncomment and install the pydotplus and graphviz libraries if you have not installed these before\n",
    "#!conda install -c conda-forge pydotplus -y\n",
    "#!conda install -c conda-forge python-graphviz -y\n",
    "\n",
    "#After executing the code below, a file named 'tree.png' would be generated which contains the decision tree image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import export_graphviz\n",
    "export_graphviz(drugTree, out_file='tree.dot', filled=True, feature_names=['Age', 'Sex', 'BP', 'Cholesterol', 'Na_to_K'])\n",
    "!dot -Tpng tree.dot -o tree.png"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}