FAI_Assignment 3 Decision Trees.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5ab96390",
   "metadata": {},
   "source": [
    "# Assignment 3 - Decision Trees\n",
    "## CART Implementation - Building a Decision Tree Classifier:\n",
    "\n",
    "I build a `class` for `decision tree classifier`. This class take the following attributes:\n",
    "\n",
    "1. **Maximum purity per internal node** : This value is a limit to stop further splitting of a node that has reached the specified purity value when the initial decision tree is being built. \n",
    "2. **Maximum tree depth**: is a limit to stop further splitting of nodes when the specified tree depth has been reached during the building of the initial decision tree.\n",
    "3. **Minimum number of records per internal node**: This prevents further splitting of a node that has reached the specified minimal size when the initial decision tree is being built.\n",
    "4. **Max categories** : is a limit for the number of unique values that a categorical attribute can have. When exceed, decision tree won't be built and error message will be printed.\n",
    "\n",
    "The three first attributes are common ***pre-pruning procedures***. Pruning should reduce the size of a learning tree without reducing predictive accuracy as measured by a cross-validation set. \n",
    "\n",
    "After making an instance of decision tree classifier class, I use cross validation method to initiate training the classifier for *k times*, testing them and log accuracy. Cross validation is used to pick the best class attributes that could give the best accuracy on train and test datasets. \n",
    "\n",
    "This class can take a dataset that contain both *numeric and categorical attributes* and build suitable decision trees for *categorical labels*. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "42dff103",
   "metadata": {},
   "outputs": [],
   "source": [
    "# required libraries\n",
    "from collections import defaultdict\n",
    "import pandas as pd \n",
    "import numpy as np\n",
    "from typing import NamedTuple, Any"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3b1255c7",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "class Classification_And_Regression_Tree ():\n",
    "    def __init__(self,  Maximum_purity_per_internal_node, Maximum_tree_depth,\n",
    "                 Minimum_number_of_records_per_internal_node, max_categories, verbose = True):\n",
    "        self.tree = defaultdict(list)\n",
    "        self.max_purity = Maximum_purity_per_internal_node\n",
    "        self.max_depth = Maximum_tree_depth\n",
    "        self.min_records_num = Minimum_number_of_records_per_internal_node\n",
    "        self.max_categories = max_categories\n",
    "        self.verbose = verbose\n",
    "        \n",
    "    def Gini_Index(self, feature_count, unique_labels):\n",
    "        ''' \n",
    "        calculating gini index for a particular feature\n",
    "        '''\n",
    "        i = 0\n",
    "        if (feature_count['Total'] == 0).any():\n",
    "            # to avoid error \n",
    "            feature_count.loc[ feature_count['Total'] == 0, 'Total'] = 1\n",
    "\n",
    "        # calculate gini index for each unique label\n",
    "        for unique_outcome in unique_labels:\n",
    "            if i == 0:\n",
    "                feature_count['GI_feature'] = feature_count.apply(lambda x: 1- pow(x[unique_outcome] / x['Total'],2), axis=1)\n",
    "                i += 1\n",
    "            else:\n",
    "                feature_count['GI_feature'] = feature_count.apply(lambda x: x['GI_feature']- pow(x[unique_outcome] / x['Total'],2), axis=1)\n",
    "\n",
    "        feature_count['GI_sub_final'] = feature_count.apply(lambda x: x['GI_feature'] * x['Total'], axis=1)\n",
    "        feature_count_final = sum(feature_count['GI_sub_final'])/sum(feature_count['Total'])\n",
    "        return feature_count, feature_count_final\n",
    "    \n",
    "    def features_collector(self, data, features):\n",
    "        ''' \n",
    "        detect numeric columns and transfer them to features \n",
    "        '''\n",
    "        feature_copy = features.copy()\n",
    "        for feature in feature_copy:\n",
    "            if feature in data.select_dtypes(\"number\").columns:\n",
    "                features.remove(feature)\n",
    "                if data[feature].diff().dropna().eq(1).all():\n",
    "                      continue\n",
    "                threshold_options = list(set(data.sort_values(by = feature)[feature]))\n",
    "                threshold_options = [[feature, (threshold_options[i]+threshold_options[i+1])/2] for i in range(len(threshold_options)-1) ]\n",
    "\n",
    "                features += threshold_options\n",
    "        return features\n",
    "                \n",
    "    def best_split(self, data, features, label):\n",
    "        '''\n",
    "        collect gini index for all features, sort them and select the feature with the lowest index\n",
    "        '''\n",
    "        Gini_Index_feature = {}\n",
    "        unique_labels = data[label].unique().tolist()\n",
    "        for feature in features:\n",
    "            if not isinstance(feature, str):\n",
    "                '''numeric feature '''\n",
    "                threshold = feature[1]\n",
    "                feature = feature[0]\n",
    "                larger_than_threshold = data[data[feature] > threshold][label].value_counts().to_frame().reset_index()\n",
    "                lower_than_threshold = data[data[feature] <= threshold][label].value_counts().to_frame().reset_index()\n",
    "                larger_than_threshold.rename(columns = {label:f'larger_than_{threshold}'}, inplace = True)\n",
    "                lower_than_threshold.rename(columns = {label:f'lower_or_equal_to_{threshold}'}, inplace = True)\n",
    "                lower_than_threshold = lower_than_threshold.pivot_table(columns= ['index'])\n",
    "                larger_than_threshold = larger_than_threshold.pivot_table(columns= ['index'])\n",
    "                feature_count = pd.concat([lower_than_threshold, larger_than_threshold]).fillna(0)\n",
    "                feature_count['Total'] = feature_count[unique_labels].sum(axis = 1)\n",
    "                feature_count, GI_index_final = self.Gini_Index(feature_count, unique_labels)\n",
    "                Gini_Index_feature[(feature, threshold)] = [GI_index_final, feature_count]\n",
    "            else: \n",
    "                '''category feature '''\n",
    "                feature_count = data[[feature, label]].value_counts().to_frame().reset_index()\n",
    "                feature_count = feature_count.pivot_table(index=[feature],\n",
    "                                                          columns=[label],\n",
    "                                                          values= 0).fillna(0)\n",
    "                feature_count['Total'] = feature_count[unique_labels].sum(axis = 1, skipna = True)\n",
    "                if (feature_count['Total']<2).all():\n",
    "                    continue\n",
    "                feature_count, GI_index_final = self.Gini_Index(feature_count, unique_labels)\n",
    "                Gini_Index_feature[feature] = [GI_index_final, feature_count]\n",
    "            \n",
    "        node_lowest_gini_index = sorted(Gini_Index_feature, key=lambda k: Gini_Index_feature[k][0])[0]\n",
    "        feature_count_lowest_gini_index = Gini_Index_feature[node_lowest_gini_index][1]\n",
    "        lowest_gini_index = Gini_Index_feature[node_lowest_gini_index][0]\n",
    "        return lowest_gini_index, node_lowest_gini_index, feature_count_lowest_gini_index\n",
    "        \n",
    "    def split_data(self, data, splitting_node, isnumeric_true):\n",
    "        '''use splitting node to split data'''\n",
    "        datasets = {}\n",
    "        if isnumeric_true: \n",
    "            datasets[f'larger_than_{splitting_node[1]}'] = data[data[splitting_node[0]] > splitting_node[1]]\n",
    "            datasets[f'lower_or_equal_to_{splitting_node[1]}'] = data[data[splitting_node[0]] <= splitting_node[1]]\n",
    "        else:\n",
    "            for feature in data[splitting_node].unique().tolist():                                                    \n",
    "                datasets[feature] = data[data[splitting_node] == feature]\n",
    "        return datasets\n",
    "    \n",
    "    def train(self, data, features, labels_column_title, depth_counter = 0, attribute_value =None, feature_count_gini = 100, previous_attribtue =None):\n",
    "        ''' \n",
    "        use data to build and train a decision tree\n",
    "        '''\n",
    "        unique_labels = data[labels_column_title].unique().tolist()\n",
    "        most_common_label = data[labels_column_title].value_counts().index[0], data[labels_column_title].value_counts()[0]\n",
    "        if len(unique_labels) <= 1: \n",
    "            '''If the data all have the same label'''\n",
    "            return Leaf(*most_common_label)\n",
    "        \n",
    " \n",
    "        if len(features) == 0:\n",
    "            '''In case list of attributes is empty, create a leaf node that predicts the most \n",
    "            common label then stop.'''\n",
    "            return Leaf(*most_common_label)  \n",
    "        \n",
    "        if self.max_depth <= depth_counter:\n",
    "\n",
    "            '''In case depth of tree has exceed the acceptable threshold, create a leaf node that predicts \n",
    "            the most common label then stop.'''\n",
    "            return Leaf(*most_common_label)\n",
    "        \n",
    "        if not isinstance(feature_count_gini, int):\n",
    "            attribute_value_X = attribute_value\n",
    "            if not isinstance(attribute_value_X, str):\n",
    "                attribute_value_X = attribute_value[0]\n",
    "            actual_gini_index = feature_count_gini.loc[attribute_value_X, 'GI_feature']\n",
    "            if  actual_gini_index < self.max_purity:\n",
    "                '''  in case splitting will not improve purity (minimum 0.03) and the purity has\n",
    "                   reached an acceptable threshold, do not split further and create a leaf node '''  \n",
    "                return Leaf(*most_common_label)\n",
    "\n",
    "        if depth_counter == 0:\n",
    "            '''\n",
    "            in case number for a column's unique values exceed an acceptable threshold, send a error message\n",
    "            '''\n",
    "            types = data.dtypes\n",
    "            if len([True for feature in features if isinstance(feature, list)]) ==0:\n",
    "                features = self.features_collector(data, features)\n",
    "                check_columns = types[types == \"object\"].index\n",
    "                for column in check_columns:\n",
    "                    var_length = len(data[column].value_counts())\n",
    "                    if var_length > self.max_categories:\n",
    "                        raise ValueError('The ' + column + ' attribute has '+ str(var_length)\n",
    "                                         + ' unique values, which is more than the accepted threshold: ' \n",
    "                                         +  str(self.max_categories))\n",
    "            depth_counter += 1\n",
    "        else:\n",
    "            if not previous_attribtue == attribute_value:\n",
    "                depth_counter += 1\n",
    "        \n",
    "        if len(data) < self.min_records_num:\n",
    "            '''In case the number of records went below an acceptable minimum number of records per internal node, \n",
    "            create a leaf node that predicts the most common label then stop.'''\n",
    "            return Leaf(*most_common_label)\n",
    "\n",
    "        previous_attribtue = attribute_value\n",
    "        gini_index, next_spliting_node, feature_count_gini = self.best_split(data, features, labels_column_title)\n",
    "\n",
    "\n",
    "        #split data and returned new splitted dataset \n",
    "        if not isinstance(next_spliting_node, str):\n",
    "            features = [feature for feature in features if not next_spliting_node[0] in feature]\n",
    "            splitted_dic = self.split_data(data, list(next_spliting_node), True)\n",
    "        else:\n",
    "            features.remove(next_spliting_node)\n",
    "            splitted_dic = self.split_data(data, next_spliting_node, False)\n",
    "    \n",
    "        \n",
    "        # create a subtrees with recursion\n",
    "        subtrees = {attribute_value : self.train(subset, features,\n",
    "                                                labels_column_title, depth_counter,\n",
    "                                                 attribute_value, feature_count_gini, previous_attribtue)\n",
    "                    for attribute_value, subset in splitted_dic.items()}\n",
    "        \n",
    "        return Internal_Split_Node(next_spliting_node, subtrees, \n",
    "                                   samples = len(data),\n",
    "                                   label_distribution = data[labels_column_title].value_counts().to_dict(),\n",
    "                                   default_value = most_common_label)\n",
    "\n",
    "        \n",
    "    def classify(self, tree, data_row):\n",
    "        \"\"\"classify data row using given decision tree\"\"\"\n",
    "        if isinstance(tree, Leaf):\n",
    "            # check whether tree consists of only a leaf node, then return leaf's value\n",
    "            return tree.label\n",
    "\n",
    "\n",
    "        if not isinstance(tree.attribute, str):\n",
    "            # numeric splitting attribute\n",
    "            if data_row[tree.attribute[0]] > tree.attribute[1]:\n",
    "                subtree_key = f'larger_than_{tree.attribute[1]}'\n",
    "            else:\n",
    "                subtree_key =  f'lower_or_equal_to_{tree.attribute[1]}'\n",
    "\n",
    "        else:\n",
    "            subtree_key = data_row[tree.attribute]\n",
    "            \n",
    "\n",
    "        if subtree_key not in tree.subtrees.keys():   # If no subtree for key,\n",
    "            return tree.default_value[0]          # return the default value.\n",
    "        subtree = tree.subtrees[subtree_key]   # Choose the appropriate subtree\n",
    "        return self.classify(subtree, data_row)\n",
    "    \n",
    "    def predict(self, tree, data_slice):\n",
    "        # make a prediction for a dataset by calling classify method for each row\n",
    "        return data_slice.apply(lambda x: self.classify(tree, x), axis=1)\n",
    "    \n",
    "    def cross_validation(self, data, features_input, labels_column_title, cv = 5):\n",
    "        '''split the data into cv number, make training/test data, use them to train and test a decision tree\n",
    "        and record the accuracy for each fold. Afterwords, train a decision tree on the whole dataset and\n",
    "        return a trained decision tree, a list of all folds accuracy, an average accuracy'''\n",
    "        \n",
    "        starting_index = 0\n",
    "        ending_index = round(data.shape[0]/cv)\n",
    "        counter = 0  #to initiate the counter used to calculate tree depth \n",
    "        cv_accuracy = []\n",
    "        \n",
    "        for i in range(cv):\n",
    "            # slice the train data and train a decision tree\n",
    "            features = features_input.copy()\n",
    "            train_data = pd.concat([data[:starting_index],data[ending_index:]])\n",
    "            DecisionTree = self.train(train_data, features, labels_column_title, counter)\n",
    "            # slice the test data, split into x and y, use x for prediction then calculate accuracy \n",
    "            test_data = data[starting_index:ending_index]\n",
    "            X_test_data = test_data.drop([labels_column_title], axis=1)\n",
    "            y_test_data = test_data[labels_column_title]\n",
    "            predicted_labels = self. predict(DecisionTree, X_test_data)\n",
    "            accuracy = self.accuracy(predicted_labels, y_test_data)\n",
    "            confusion_matrix = self.confusion_matrix(predicted_labels, y_test_data)\n",
    "            if self.verbose:\n",
    "                print(f'Confusion matrix for fold number {i+1} is as follow:\\n {confusion_matrix}')\n",
    "                print()\n",
    "            cv_accuracy.append(accuracy)\n",
    "            starting_index += round(data.shape[0]/cv)\n",
    "            ending_index += round(data.shape[0]/cv)\n",
    "\n",
    "        avg_accuracy = sum(cv_accuracy) / len(cv_accuracy) \n",
    "        # train on full data\n",
    "        DecisionTree = self.train(data, features_input, labels_column_title, counter)    \n",
    "        return DecisionTree, avg_accuracy, cv_accuracy\n",
    "    \n",
    "    def accuracy(self, predicted_labels, y_test_data):\n",
    "        '''calculate accuracy by comparing between actual and predicted labels'''\n",
    "        comparison_column = np.where(predicted_labels == y_test_data, True, False)\n",
    "        return np.count_nonzero(comparison_column == True)/len (comparison_column)\n",
    "    \n",
    "    def confusion_matrix (self, predicted_labels, y_test_data):\n",
    "        '''calculate a confusion matrix for multilabel classification'''\n",
    "        df = pd.DataFrame({'predicted': predicted_labels, 'actual': y_test_data}, columns=['predicted', 'actual'])\n",
    "        return (df.groupby(['predicted', 'actual']).size().unstack(fill_value=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2db2af80",
   "metadata": {},
   "source": [
    "I build also a seperate class for `Leaf` node and `Internal_Split` node in order to use them when constructing decision tree nodes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "38140142",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Leaf(NamedTuple):\n",
    "    ''' \n",
    "    an information container for each leaf.\n",
    "    '''\n",
    "    label: Any\n",
    "    Samples : int \n",
    "    \n",
    "\n",
    "class Internal_Split_Node(NamedTuple):\n",
    "    ''' \n",
    "    an information container for each internal node.\n",
    "    '''\n",
    "    attribute: str\n",
    "    subtrees: dict\n",
    "    samples : int\n",
    "    label_distribution : list\n",
    "    default_value: Any = None\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e5eb28d",
   "metadata": {},
   "source": [
    "## Weather Dataset\n",
    "### Dataset ingestion and Data Wrangling::\n",
    "Using read_csv method of pandas package, I imported weather data's csv file. This method trasnfer the data into tabuluar dataframe. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8dda36ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# required libraries for data handling \n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9c1be899",
   "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>Outlook</th>\n",
       "      <th>Temperature</th>\n",
       "      <th>Humidity</th>\n",
       "      <th>Wind</th>\n",
       "      <th>Decision</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Day</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Hot</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Hot</td>\n",
       "      <td>High</td>\n",
       "      <td>Strong</td>\n",
       "      <td>No</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Overcast</td>\n",
       "      <td>Hot</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Rainfall</td>\n",
       "      <td>Mild</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Rainfall</td>\n",
       "      <td>Cool</td>\n",
       "      <td>Normal</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Outlook Temperature Humidity    Wind Decision\n",
       "Day                                                \n",
       "1       Sunny         Hot     High    Weak       No\n",
       "2       Sunny         Hot     High  Strong       No\n",
       "3    Overcast         Hot     High    Weak      Yes\n",
       "4    Rainfall        Mild     High    Weak      Yes\n",
       "5    Rainfall        Cool   Normal    Weak      Yes"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#using the day column as index for the dataframe. \n",
    "weather_data = pd.read_csv('weather-data.csv', index_col= 0) \n",
    "weather_data.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac409067",
   "metadata": {},
   "source": [
    "Dataset contains only 14 lines and all columns include categorical attributes. Each columns has 2-3 unique values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fbba69c5",
   "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>Outlook</th>\n",
       "      <th>Temperature</th>\n",
       "      <th>Humidity</th>\n",
       "      <th>Wind</th>\n",
       "      <th>Decision</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>14</td>\n",
       "      <td>14</td>\n",
       "      <td>14</td>\n",
       "      <td>14</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>unique</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>top</th>\n",
       "      <td>Sunny</td>\n",
       "      <td>Mild</td>\n",
       "      <td>High</td>\n",
       "      <td>Weak</td>\n",
       "      <td>Yes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>freq</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Outlook Temperature Humidity  Wind Decision\n",
       "count       14          14       14    14       14\n",
       "unique       3           3        2     2        2\n",
       "top      Sunny        Mild     High  Weak      Yes\n",
       "freq         5           6        7     8        9"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weather_data.describe(include = 'object')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dc34394",
   "metadata": {},
   "source": [
    "We note that there is an imbalance in data as 9 out of 14 data entry has 'yes' as a decision which will have an effect on the classifier performance on real data and introduce biase. Wind and humidity have 2 unique values whereas outlook and temperature have 3 unique values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9a18bf51",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(2, 2, figsize=(16,12))\n",
    "for attribute, loc in zip(weather_data.columns, [(0,0), (1,0),(0,1),(1,1)]):\n",
    "    if attribute != 'Decision':\n",
    "        stacked_attribute= weather_data[[attribute,'Decision']].value_counts().to_frame().reset_index().pivot_table(index= attribute, columns= ['Decision'], values= 0)\n",
    "        stacked_attribute.plot(kind='bar', xlabel= attribute, ylabel='Decision', title= f'Count of yes/no decisions per {attribute}', stacked=True, rot=0, ax = axes[loc[0]][loc[1]])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ace4f9e",
   "metadata": {},
   "source": [
    "In above figure, I make the following observations:\n",
    " - Decision is always 'yes' when outlook is overcast.\n",
    " - Normal humdity associate mostly with 'yes' decision \n",
    " - Decision was equally distrbute between 'yes/no' in case of strong wind.\n",
    " \n",
    "Even after making all this observation, it is tricky when receiving a set of attributes to call for 'yes/no' decision, therefore I will build a decision tree classifier to help me to make this prediction.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8318679b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix for fold number 1 is as follow:\n",
      " actual     No  Yes\n",
      "predicted         \n",
      "No          2    0\n",
      "Yes         0    1\n",
      "\n",
      "Confusion matrix for fold number 2 is as follow:\n",
      " actual     No  Yes\n",
      "predicted         \n",
      "No          0    1\n",
      "Yes         1    1\n",
      "\n",
      "Confusion matrix for fold number 3 is as follow:\n",
      " actual     No  Yes\n",
      "predicted         \n",
      "No          0    1\n",
      "Yes         1    1\n",
      "\n",
      "Confusion matrix for fold number 4 is as follow:\n",
      " actual     Yes\n",
      "predicted     \n",
      "No           1\n",
      "Yes          2\n",
      "\n",
      "Confusion matrix for fold number 5 is as follow:\n",
      " actual     No  Yes\n",
      "predicted         \n",
      "No          1    0\n",
      "Yes         0    1\n",
      "\n",
      "\n",
      "Decision Tree for weather dataset is as follows:\n",
      " Internal_Split_Node(attribute='Outlook', subtrees={'Sunny': Internal_Split_Node(attribute='Humidity', subtrees={'High': Leaf(label='No', Samples=3), 'Normal': Leaf(label='Yes', Samples=2)}, samples=5, label_distribution={'No': 3, 'Yes': 2}, default_value=('No', 3)), 'Overcast': Leaf(label='Yes', Samples=4), 'Rainfall': Internal_Split_Node(attribute='Wind', subtrees={'Weak': Leaf(label='Yes', Samples=3), 'Strong': Leaf(label='No', Samples=2)}, samples=5, label_distribution={'Yes': 3, 'No': 2}, default_value=('Yes', 3))}, samples=14, label_distribution={'Yes': 9, 'No': 5}, default_value=('Yes', 9))\n",
      "This tree got an average accuarcy of 0.6666666666666666 when running cross validation on 5 folds\n",
      "accuracy this tree has on each fold is: [1.0, 0.3333333333333333, 0.3333333333333333, 0.6666666666666666, 1.0]\n"
     ]
    }
   ],
   "source": [
    "CART =  Classification_And_Regression_Tree(Maximum_purity_per_internal_node = 0.1,\n",
    "                                           Maximum_tree_depth = 4,\n",
    "                                           Minimum_number_of_records_per_internal_node = 3,\n",
    "                                           max_categories = 10)\n",
    "\n",
    "DecisionTree, avg_accuracy, cv_accuracy = CART.cross_validation(data = weather_data, \n",
    "                                                                features_input = ['Temperature', 'Humidity', 'Wind', 'Outlook'],\n",
    "                                                                labels_column_title = 'Decision',\n",
    "                                                                cv = 5)\n",
    "print()\n",
    "print('Decision Tree for weather dataset is as follows:\\n', DecisionTree)\n",
    "print(f'This tree got an average accuarcy of {avg_accuracy} when running cross validation on 5 folds')\n",
    "print(f'accuracy this tree has on each fold is: {cv_accuracy}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9539eb1",
   "metadata": {},
   "source": [
    "I note that the tree accuracy is fluctuating between each fold during cross validation because of overfitting problem. To reach a better accuracy, a bigger dataset is required (only 14 enteries are available here). "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0ffab3d8",
   "metadata": {},
   "source": [
    "## Drug Dataset\n",
    "### Dataset ingestion and Data Wrangling:\n",
    "\n",
    "[Drugs A, B, C, X, Y for Decision Trees](https://www.kaggle.com/datasets/pablomgomez21/drugs-a-b-c-x-y-for-decision-trees) is imported from kaggle.com. The dataset belongs to lists of patients who received a treatment for the same disease. The differents drugs can be A B C X or Y. The attributes collected for each patients is: \n",
    "- Age\n",
    "- Sex \n",
    "- Blood Pressure (refer to as BP)\n",
    "- Cholesterol level\n",
    "- Sodium - Potassium (refer to as Na_to_K)\n",
    "- Drug that worked with that patient\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bb3fb1e3",
   "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": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "drug_data = pd.read_csv('drug200.csv')\n",
    "drug_data.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3214be72",
   "metadata": {},
   "source": [
    "The dataset has 200 non-null entries in 6 columns. `Age` and `Na_to_K` columns contain numeric values whereas the other columns have categorical values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "57f4d196",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 200 entries, 0 to 199\n",
      "Data columns (total 6 columns):\n",
      " #   Column       Non-Null Count  Dtype  \n",
      "---  ------       --------------  -----  \n",
      " 0   Age          200 non-null    int64  \n",
      " 1   Sex          200 non-null    object \n",
      " 2   BP           200 non-null    object \n",
      " 3   Cholesterol  200 non-null    object \n",
      " 4   Na_to_K      200 non-null    float64\n",
      " 5   Drug         200 non-null    object \n",
      "dtypes: float64(1), int64(1), object(4)\n",
      "memory usage: 9.5+ KB\n"
     ]
    }
   ],
   "source": [
    "drug_data.info()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "373d2724",
   "metadata": {},
   "source": [
    "There is not much data cleaning needed to be done beforehand.  On average, patients are 44 years old  and have 16 Sodium - Potassium level."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a5233f67",
   "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>Na_to_K</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>200.000000</td>\n",
       "      <td>200.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>44.315000</td>\n",
       "      <td>16.084485</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>16.544315</td>\n",
       "      <td>7.223956</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>15.000000</td>\n",
       "      <td>6.269000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>31.000000</td>\n",
       "      <td>10.445500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>45.000000</td>\n",
       "      <td>13.936500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>58.000000</td>\n",
       "      <td>19.380000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>74.000000</td>\n",
       "      <td>38.247000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              Age     Na_to_K\n",
       "count  200.000000  200.000000\n",
       "mean    44.315000   16.084485\n",
       "std     16.544315    7.223956\n",
       "min     15.000000    6.269000\n",
       "25%     31.000000   10.445500\n",
       "50%     45.000000   13.936500\n",
       "75%     58.000000   19.380000\n",
       "max     74.000000   38.247000"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "drug_data.describe()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f0f049fd",
   "metadata": {},
   "source": [
    "More observations about the dataset: \n",
    "- Almost equal number of male and female patients\n",
    "- 91 out of 200 patients were cured using `drug y`. \n",
    "- Almost equal number of patients has either high or low cholesterol level."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9d4cd49e",
   "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>Sex</th>\n",
       "      <th>BP</th>\n",
       "      <th>Cholesterol</th>\n",
       "      <th>Drug</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>200</td>\n",
       "      <td>200</td>\n",
       "      <td>200</td>\n",
       "      <td>200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>unique</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>top</th>\n",
       "      <td>M</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>HIGH</td>\n",
       "      <td>drugY</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>freq</th>\n",
       "      <td>104</td>\n",
       "      <td>77</td>\n",
       "      <td>103</td>\n",
       "      <td>91</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Sex    BP Cholesterol   Drug\n",
       "count   200   200         200    200\n",
       "unique    2     3           2      5\n",
       "top       M  HIGH        HIGH  drugY\n",
       "freq    104    77         103     91"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "drug_data.describe(include = 'object')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4d005f37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(2, 3, figsize=(16,12))\n",
    "axes[1][2].set_visible(False)\n",
    "for attribute, loc in zip(drug_data.columns, [(0,0), (1,0), (0,1), (0,2), (1,1)]):\n",
    "    if drug_data[attribute].dtype == 'O' :\n",
    "        if attribute != 'Drug':\n",
    "            stacked_attribute = drug_data[[attribute,'Drug']].value_counts().to_frame().reset_index().pivot_table(index= attribute, columns= ['Drug'],\n",
    "                                                                                                                 values= 0)\n",
    "            stacked_attribute.plot(kind='bar', xlabel= attribute, ylabel='Drug', \n",
    "                                   title= f'Count of Drugs per {attribute}', stacked=True, \n",
    "                                   rot=0, ax = axes[loc[0]][loc[1]])\n",
    "    else:\n",
    "        if attribute == 'Age':\n",
    "            rot = 0\n",
    "        else:\n",
    "            rot = 90\n",
    "        stacked_attribute = drug_data[[attribute,'Drug']].value_counts().to_frame().reset_index().pivot_table(index= attribute, columns= ['Drug'], values= 0)\n",
    "        step = round((stacked_attribute.index.max()-stacked_attribute.index.min())/5)\n",
    "        stacked_attribute = stacked_attribute.groupby(pd.cut(stacked_attribute.index, \n",
    "                                                             np.arange(stacked_attribute.index.min(),\n",
    "                                                                       stacked_attribute.index.max() + step,\n",
    "                                                                       step))).sum()\n",
    "        stacked_attribute.plot(kind='bar', xlabel= attribute, ylabel='Drug', \n",
    "                               title= f'Count of Drugs per {attribute}', \n",
    "                               stacked=True, rot = rot, ax = axes[loc[0]][loc[1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "371b235b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Count of Drugs per BP when Na_to_K <= 14.5175'}, xlabel='BP', ylabel='Drug'>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = drug_data[drug_data['Na_to_K'] <= 14.5175]\n",
    "stacked_attribute = x[['BP','Drug']].value_counts().to_frame().reset_index().pivot_table(index= 'BP', columns= ['Drug'],\n",
    "                                                                                                     values= 0)\n",
    "stacked_attribute.plot(kind='bar', xlabel= 'BP', ylabel='Drug', \n",
    "                       title= f'Count of Drugs per BP when Na_to_K <= 14.5175', stacked=True, \n",
    "                       rot=0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a5282bff",
   "metadata": {},
   "source": [
    "I have the following observations:\n",
    "\n",
    "- `Drug A` has been the cure for patients who are less than 51 years old whereas `drug B` was the cure for patients who are 51 years old and older. \n",
    "- Patients with normal blood pressure were cured using either `drug X` or `drug Y`.\n",
    "- `Drug Y` has been the cure for all patients who have `na_to_k > 18.269`. This makes na_to_k a key variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d122b940",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix for fold number 1 is as follow:\n",
      " actual     drugA  drugB  drugC  drugX  drugY\n",
      "predicted                                   \n",
      "drugA          2      0      0      0      0\n",
      "drugB          0      1      0      0      0\n",
      "drugC          0      0      5      0      0\n",
      "drugX          0      0      0     12      0\n",
      "drugY          0      0      0      0     20\n",
      "\n",
      "Confusion matrix for fold number 2 is as follow:\n",
      " actual     drugA  drugB  drugC  drugX  drugY\n",
      "predicted                                   \n",
      "drugA          5      0      0      0      0\n",
      "drugB          0      5      0      0      0\n",
      "drugC          0      0      2      0      0\n",
      "drugX          0      0      0      9      0\n",
      "drugY          0      0      0      0     19\n",
      "\n",
      "Confusion matrix for fold number 3 is as follow:\n",
      " actual     drugA  drugB  drugC  drugX  drugY\n",
      "predicted                                   \n",
      "drugA          4      0      0      0      0\n",
      "drugB          1      3      0      0      0\n",
      "drugC          0      0      3      0      0\n",
      "drugX          0      0      0     12      0\n",
      "drugY          0      0      0      0     17\n",
      "\n",
      "Confusion matrix for fold number 4 is as follow:\n",
      " actual     drugA  drugB  drugC  drugX  drugY\n",
      "predicted                                   \n",
      "drugA          6      0      0      0      0\n",
      "drugB          0      5      0      0      0\n",
      "drugC          0      0      3      0      0\n",
      "drugX          0      0      0     10      0\n",
      "drugY          0      0      0      1     15\n",
      "\n",
      "Confusion matrix for fold number 5 is as follow:\n",
      " actual     drugA  drugB  drugC  drugX  drugY\n",
      "predicted                                   \n",
      "drugA          5      0      0      0      0\n",
      "drugB          0      2      0      0      0\n",
      "drugC          0      0      3      0      0\n",
      "drugX          0      0      0     10      0\n",
      "drugY          0      0      0      0     20\n",
      "\n",
      "Decision Tree for drug dataset is as follows:\n",
      " Internal_Split_Node(attribute=('Na_to_K', 14.5175), subtrees={'larger_than_14.5175': Leaf(label='drugY', Samples=91), 'lower_or_equal_to_14.5175': Internal_Split_Node(attribute='BP', subtrees={'LOW': Internal_Split_Node(attribute='Cholesterol', subtrees={'HIGH': Leaf(label='drugC', Samples=16), 'NORMAL': Leaf(label='drugX', Samples=17)}, samples=33, label_distribution={'drugX': 17, 'drugC': 16}, default_value=('drugX', 17)), 'NORMAL': Leaf(label='drugX', Samples=36), 'HIGH': Internal_Split_Node(attribute=('Age', 50.5), subtrees={'larger_than_50.5': Leaf(label='drugB', Samples=16), 'lower_or_equal_to_50.5': Leaf(label='drugA', Samples=23)}, samples=39, label_distribution={'drugA': 23, 'drugB': 16}, default_value=('drugA', 23))}, samples=108, label_distribution={'drugX': 53, 'drugA': 23, 'drugC': 16, 'drugB': 16}, default_value=('drugX', 53))}, samples=200, label_distribution={'drugY': 91, 'drugX': 54, 'drugA': 23, 'drugC': 16, 'drugB': 16}, default_value=('drugY', 91))\n",
      "This tree got an average accuarcy of 0.99 when running cross validation on 5 folds.\n",
      "Accuracy this tree has on each fold is: [1.0, 1.0, 0.975, 0.975, 1.0]\n"
     ]
    }
   ],
   "source": [
    "CART =  Classification_And_Regression_Tree(Maximum_purity_per_internal_node = 0.03,\n",
    "                                           Maximum_tree_depth = 5,\n",
    "                                           Minimum_number_of_records_per_internal_node = 10,\n",
    "                                           max_categories = 8)\n",
    "\n",
    "DecisionTree, avg_accuracy, cv_accuracy = CART.cross_validation(drug_data, \n",
    "                                                                ['Age', 'Sex', 'BP', 'Cholesterol', 'Na_to_K'],\n",
    "                                                                'Drug', cv = 5)\n",
    "print('Decision Tree for drug dataset is as follows:\\n', DecisionTree)\n",
    "print(f'This tree got an average accuarcy of {avg_accuracy} when running cross validation on 5 folds.')\n",
    "print(f'Accuracy this tree has on each fold is: {cv_accuracy}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08450da3",
   "metadata": {},
   "source": [
    "### Optimization:\n",
    "I use `cross validation` to select the best maximum tree depth for the model in order to maximize the accuracy metric. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4c56b75f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy mean when maximum tree depth = 0 is 0.45499999999999996\n",
      "Accuracy mean when maximum tree depth = 1 is 0.72\n",
      "Accuracy mean when maximum tree depth = 2 is 0.825\n",
      "Accuracy mean when maximum tree depth = 3 is 0.99\n",
      "Accuracy mean when maximum tree depth = 4 is 0.99\n",
      "Accuracy mean when maximum tree depth = 5 is 0.99\n",
      "Accuracy mean when maximum tree depth = 6 is 0.99\n"
     ]
    }
   ],
   "source": [
    "Maximum_tree_depth = np.arange(0,7,1)\n",
    "\n",
    "results = {}\n",
    "cv_scores_std = []\n",
    "accuracy_scores =[]\n",
    "\n",
    "for depth in Maximum_tree_depth:\n",
    "    CART =  Classification_And_Regression_Tree(0.03, depth, 10, 8, False)            \n",
    "    DecisionTree, avg_accuracy, cv_accuracy = CART.cross_validation(drug_data,\n",
    "                                                                    ['Age', 'Sex', 'BP', 'Cholesterol', 'Na_to_K'],\n",
    "                                                                     'Drug')\n",
    "    results[depth] = [DecisionTree, avg_accuracy, cv_accuracy]\n",
    "    accuracy_scores.append(avg_accuracy)\n",
    "    cv_scores_std.append(np.array(cv_accuracy).std())\n",
    "    print(f'Accuracy mean when maximum tree depth = {depth} is {np.array(cv_accuracy).mean()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48d055f0",
   "metadata": {},
   "source": [
    "I note that decision tree accuracy is not dependent on these parameters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f1cc1756",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def tree_depth_vs_accuracy(depths, cv_scores_std, accuracy_scores, title):\n",
    "    fig, ax = plt.subplots(1,1, figsize=(15,5))\n",
    "    ax.plot(depths, accuracy_scores, '-o', label='range of cross-validation accuracy', alpha=0.9)\n",
    "    ax.fill_between(depths, np.array(accuracy_scores)-2*np.array(cv_scores_std), \n",
    "                    np.array(accuracy_scores)+2*np.array(cv_scores_std), alpha=0.2)\n",
    "    ylim = plt.ylim()\n",
    "    ax.plot(depths, accuracy_scores, '-*', label=' accuracy', alpha=0.9)\n",
    "    ax.set_title(title, fontsize=16)\n",
    "    ax.set_xlabel('Tree depth', fontsize=14)\n",
    "    ax.set_ylabel('Accuracy', fontsize=14)\n",
    "    ax.set_ylim(ylim)\n",
    "    ax.set_xticks(depths)\n",
    "    ax.legend()\n",
    "\n",
    "    \n",
    "tree_depth_vs_accuracy(Maximum_tree_depth, cv_scores_std, accuracy_scores, \n",
    "                               'Accuracy per depth of decision tree') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9faf8326",
   "metadata": {},
   "source": [
    "With tree depth of 0, a leaf node will suggest a drug Y and we get a 0.45 accuracy. The accuracy increases with tree depth and hit a plateau (0.99) when tree depth is 3."
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}