tree.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import copy\n",
    "import treelib\n",
    "import itertools\n",
    "import scipy.optimize as opt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self,branches=None,attribute=None,threshold=None,value=None):\n",
    "        if branches is None and value is None:\n",
    "            print(\"ERROR\")\n",
    "        \n",
    "        self.branches = branches\n",
    "        self.threshold = threshold\n",
    "        self.attribute = attribute\n",
    "        self.is_leaf = True if self.branches is None else False\n",
    "        self.value = value\n",
    "        self.pinfo = {}\n",
    "        \n",
    "    def get_child(self,df):\n",
    "        if isinstance(df[self.attribute],(int,float,np.number)):\n",
    "            return self.branches[0] if df[self.attribute] < self.threshold else self.branches[1]\n",
    "        else:\n",
    "            return self.branches[0] if df[self.attribute] in self.threshold else self.branches[1]\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tree:\n",
    "    def __init__(self,root):\n",
    "        self.root = root\n",
    "        \n",
    "    def predict(self,x):\n",
    "        item = self.root\n",
    "        while not item.is_leaf:\n",
    "            item = item.get_child(x)\n",
    "        return item\n",
    "    \n",
    "    def leaf_count(self):\n",
    "        return self._leaf_count(self.root)\n",
    "    \n",
    "    def _leaf_count(self,node):\n",
    "        if node.is_leaf:\n",
    "            return 1\n",
    "        else:\n",
    "            return np.sum([self._leaf_count(b) for b in node.branches])\n",
    "    \n",
    "    def nodes(self):\n",
    "        return self._nodes(self.root)\n",
    "    \n",
    "    def _nodes(self,node):\n",
    "        if node.is_leaf:\n",
    "            return [node]\n",
    "        \n",
    "        nl = [node]\n",
    "        for b in node.branches:\n",
    "            nl += self._nodes(b)\n",
    "        return nl\n",
    "    \n",
    "    def classes(self):\n",
    "        nodes = self.nodes()\n",
    "        c = []\n",
    "        for n in nodes:\n",
    "            c.append(n.value)\n",
    "        return np.unique(c).tolist()\n",
    "    \n",
    "    def show(self):\n",
    "        tree_view = treelib.Tree()\n",
    "        self._show(self.root,tree_view)\n",
    "        tree_view.show()\n",
    "        \n",
    "    def _show(self,node,tree_view,parent=None,prefix=\"\"):\n",
    "        name = str(hash(node))\n",
    "        if node.is_leaf:\n",
    "            text = f\"{prefix}{node.value}\"\n",
    "        else:\n",
    "            if isinstance(node.threshold,(int,float,np.number)):\n",
    "                text = f\"{prefix}{node.attribute}<{node.threshold:.2f}\"\n",
    "            else:\n",
    "                text = f\"{prefix}{node.attribute} in {node.threshold}\"\n",
    "        tree_view.create_node(text,name,parent=parent)\n",
    "        \n",
    "        if not node.is_leaf:\n",
    "            for i, b in enumerate(node.branches):\n",
    "                p = \"True: \" if i == 0 else \"False:\"\n",
    "                self._show(b,tree_view,parent=name,prefix=p)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Node and Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "young\n"
     ]
    }
   ],
   "source": [
    "l0= Node(value=\"young\")\n",
    "l1=Node(value=\"old\")\n",
    "r=Node([l0,l1],\"age\",18)\n",
    "t=Tree(r)\n",
    "print(t.predict({\"age\":2}).value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "old\n"
     ]
    }
   ],
   "source": [
    "print(t.predict({\"age\":20}).value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.leaf_count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<__main__.Node at 0x7f1c74288950>,\n",
       " <__main__.Node at 0x7f1c74288750>,\n",
       " <__main__.Node at 0x7f1c74288790>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.nodes()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classification And Regression Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class CART:\n",
    "    def __init__(self,df,y_name,X_names=None,min_leaf_samples=1,min_split_samples=1,max_depth=32767):\n",
    "        self.y_name = y_name\n",
    "        if X_names is None:\n",
    "            X_names = list(df.columns)\n",
    "            X_names.remove(self.y_name)\n",
    "        self.X_names = X_names\n",
    "        self.df = self._handle_missings(df)\n",
    "        self.tree = None\n",
    "        self.splittyness = 1.\n",
    "        self.leaf_loss_threshold = 1e-12\n",
    "        \n",
    "        self.classes = np.unique(df[self.y_name]).tolist()\n",
    "        \n",
    "        self.min_leaf_samples = min_leaf_samples\n",
    "        self.min_split_samples = min_split_samples\n",
    "        self.max_depth = max_depth\n",
    "        \n",
    "        self.depth = 0\n",
    "        \n",
    "    def train(self,k=5, plot=True, slack=1.):\n",
    "        \"\"\"\n",
    "        train desicion tree by k-fold cross-validation\n",
    "        \"\"\"\n",
    "        #shuffle dataframe\n",
    "        df = self.df.sample(frac=1.)\n",
    "        \n",
    "        # train tree with full dataset\n",
    "        self.create_tree()\n",
    "        pres = self.prune()\n",
    "        beta = self._beta(pres[\"alpha\"])\n",
    "        qual_cv = np.zeros((len(beta),k))\n",
    "        #split df for k-fold cross-validation\n",
    "        training_sets, test_sets = self._k_fold_split(df,k)\n",
    "        for i in range(len(training_sets)):\n",
    "            c = CART(training_sets[i],\n",
    "                     self.y_name,\n",
    "                     X_names = self.X_names, \n",
    "                     min_leaf_samples=self.min_leaf_samples,\n",
    "                     min_split_samples=self.min_split_samples,\n",
    "                     max_depth=self.max_depth)\n",
    "            c.create_tree()          \n",
    "            pres = c.prune(test_set=test_sets[i])\n",
    "            qual = self._qualities(beta,pres)\n",
    "            qual_cv[:,i] = np.array(qual)\n",
    "        qual_mean = np.mean(qual_cv, axis=1)\n",
    "        qual_sd = np.std(qual_cv, axis = 1)\n",
    "        qual_sd_mean = np.mean(qual_sd)\n",
    "        import matplotlib.pyplot as plt\n",
    "        plt.errorbar(beta,qual_mean,yerr=qual_sd)\n",
    "        \n",
    "        qual_max = np.nanmax(qual_mean)\n",
    "        ind_max = np.argmax(qual_mean)\n",
    "        qual_max_sd = qual_sd[ind_max]\n",
    "        qual_upper = qual_mean + qual_sd * slack\n",
    "        ind_best = ind_max\n",
    "        for i in range(ind_max, len(qual_upper)):\n",
    "            if qual_mean[i] > qual_max - qual_max_sd * slack:\n",
    "                ind_best = i\n",
    "        beta_best = beta[ind_best]\n",
    "        print(f\"beta_best: {beta_best}\")\n",
    "        self.create_tree()\n",
    "        self.prune(alpha_max=beta_best)\n",
    "    \n",
    "    def _beta(self,alpha):\n",
    "        beta = []\n",
    "        for i in range(len(alpha)-1):\n",
    "            if alpha[i] <= 0:\n",
    "                continue\n",
    "            b = np.sqrt(alpha[i]*alpha[i+1])\n",
    "            beta.append(b)\n",
    "        return beta\n",
    "            \n",
    "    def _quality_at(self,b,data):\n",
    "        for i, a in enumerate(data[\"alpha\"]):\n",
    "            if a > b:\n",
    "                return data[\"A_cv\"][i-1]\n",
    "        return 0.\n",
    "    \n",
    "    def _qualities(self,beta,data):\n",
    "        return [self._quality_at(b,data) for b in beta]\n",
    "    \n",
    "    @staticmethod\n",
    "    def _k_fold_split(df,k):\n",
    "        N = len(df.index)\n",
    "        n = int(np.ceil(N/k))\n",
    "        training_sets = []\n",
    "        test_sets = []\n",
    "        for i in range(k):\n",
    "            test = df.iloc[i*n:min(N,(i+1)*n),:]\n",
    "            training = df.loc[df.index.difference(test.index),:]\n",
    "            test_sets.append(test)\n",
    "            training_sets.append(training)\n",
    "        return training_sets, test_sets\n",
    "    \n",
    "    def _handle_missings(self,df_in):\n",
    "        df_out = df_in.dropna(subset=[self.y_name])\n",
    "        # use nan as category\n",
    "        # use mean if numerical\n",
    "        for name in self.X_names:\n",
    "            if np.issubdtype(df_out[name].values.dtype, np.number):\n",
    "                df_out[name] = df_out[name].fillna(np.nanmean(df_out[name].values))\n",
    "            else:\n",
    "                df_out[name] = df_out[name].fillna(\"missing\")\n",
    "        return df_out\n",
    "        \n",
    "    def create_tree(self, leaf_loss_threshold=1e-12):\n",
    "        self.leaf_loss_threshold = leaf_loss_threshold\n",
    "        root = self._node_or_leaf(self.df)\n",
    "        self.tree = Tree(root)\n",
    "        n_leafs = self.tree.leaf_count()\n",
    "        print(f\"A tree with {n_leafs} leafs was created\")\n",
    "        return self.tree\n",
    "    \n",
    "    def _gini_impurity(self, df):\n",
    "        unique, counts = np.unique(df[self.y_name].values, return_counts=True)\n",
    "        N = df[self.y_name].values.ravel().size\n",
    "        p = counts/N\n",
    "        #print(unique)\n",
    "        #print(p)\n",
    "        return 1. - np.sum(p**2)\n",
    "    \n",
    "    def _shannon_entropy(self,df):\n",
    "        unique, counts = np.unique(df[self.y_name].values, return_counts=True)\n",
    "        N = df[self.y_name].values.size\n",
    "        p = counts/N\n",
    "        return -np.sum(p * np.log2(p))\n",
    "    \n",
    "    def _misclassification_cost(self,df):\n",
    "        y = df[self.y_name].values\n",
    "        unique, counts = np.unique(y, return_counts=True)\n",
    "        N = y.size\n",
    "        p = np.max(counts)/N\n",
    "        return 1. - p\n",
    "        \n",
    "    def _opt_fun(self,df,split_name):\n",
    "        def fun(x):\n",
    "            split_df = [df[df[split_name]<x],\n",
    "                        df[df[split_name]>=x]]\n",
    "            N = len(df.index)\n",
    "            n = [len(df_.index) for df_ in split_df]\n",
    "            return n[0]/N * self._loss(split_df[0]) + n[1]/N * self._loss(split_df[1])\n",
    "        return fun\n",
    "        \n",
    "    def _node_or_leaf(self,df):\n",
    "        loss_parent = self._loss(df)\n",
    "        if (loss_parent < self.leaf_loss_threshold\n",
    "            or len(df.index) < self.min_leaf_samples\n",
    "            or self.depth > self.max_depth):\n",
    "            return self._leaf(df)\n",
    "        \n",
    "        loss_best, split_df, split_threshold, split_name = self._loss_best(df)\n",
    "        #print(f\"Computed split:\\nloss: {loss_best:.2f} (parent: {loss_parent:.2f})\\nattribute: {split_name}\\nthreshold: {split_threshold}\\ncount: {[len(df_.index) for df_ in split_df]}\")\n",
    "        if loss_best < loss_parent:\n",
    "            #print(f\"=> Node({split_name}, {split_threshold})\")\n",
    "            branches = []\n",
    "            self.depth += 1\n",
    "            for i in range(2):\n",
    "                branches.append(self._node_or_leaf(split_df[i]))  \n",
    "            self.depth -= 1\n",
    "            unique, counts = np.unique(df[self.y_name], return_counts=True)\n",
    "            value = unique[np.argmax(counts)]\n",
    "            item = Node(branches=branches,attribute=split_name,threshold=split_threshold,value=value)\n",
    "            item.pinfo[\"N\"] = len(df.index)\n",
    "            item.pinfo[\"r\"] = self._misclassification_cost(df)\n",
    "            item.pinfo[\"R\"] = item.pinfo[\"N\"]/len(self.df.index) * item.pinfo[\"r\"]\n",
    "        else:\n",
    "            item = self._leaf(df)\n",
    "            \n",
    "        return item\n",
    "    \n",
    "    def _leaf(self,df):\n",
    "        unique, counts = np.unique(df[self.y_name].values,return_counts=True)\n",
    "        #print([(unique[i], counts[i]) for i in range(len(counts))])\n",
    "        sort_ind = np.argsort(-counts)\n",
    "        value = unique[sort_ind[0]]\n",
    "        leaf = Node(value=value)\n",
    "        \n",
    "        leaf.pinfo[\"N\"] = len(df.index)\n",
    "        leaf.pinfo[\"r\"] = self._misclassification_cost(df)\n",
    "        leaf.pinfo[\"R\"] = leaf.pinfo[\"N\"]/len(self.df.index) * leaf.pinfo[\"r\"]\n",
    "        #print(f\"=> Leaf({value}, N={len(df.index)})\")\n",
    "        return leaf\n",
    "    \n",
    "    def _loss_best(self,df):\n",
    "        loss = np.Inf\n",
    "        split_df = None\n",
    "        split_threshold = None\n",
    "        split_name = None\n",
    "        for name in self.X_names:\n",
    "            loss_ = np.Inf\n",
    "            if np.issubdtype(df[name].values.dtype, np.number):\n",
    "                loss_, split_df_, split_threshold_ = self._split_by_number(df,name)\n",
    "            else:\n",
    "                loss_, split_df_, split_threshold_ = self._split_by_class(df,name)\n",
    "            if (loss_ < loss\n",
    "                and np.min([len(df_.index) for df_ in split_df_]) >= self.min_split_samples):\n",
    "                loss = loss_\n",
    "                split_threshold = split_threshold_\n",
    "                split_df = split_df_\n",
    "                split_name = name\n",
    "\n",
    "        return loss, split_df, split_threshold, split_name\n",
    "    \n",
    "    def _split_by_number(self,df,name):\n",
    "        res = opt.minimize_scalar(self._opt_fun(df,name),bounds=(df[name].min(),df[name].max()),method=\"bounded\")\n",
    "        split_threshold = res.x\n",
    "        split_df = [df[df[name]<split_threshold],\n",
    "                    df[df[name]>=split_threshold]]\n",
    "        loss = res.fun\n",
    "        return loss, split_df, split_threshold\n",
    "    \n",
    "    def _split_by_class(self,df,name):\n",
    "        unique = np.unique(df[name])\n",
    "        comb = []\n",
    "        if len(unique) > 5:\n",
    "            comb = [(u,) for u in unique]\n",
    "        else:\n",
    "            for i in range(1,len(unique)):\n",
    "                comb += list(itertools.combinations(unique,i))\n",
    "            \n",
    "        if len(comb) < 1:\n",
    "            return np.Inf, None, None\n",
    "        \n",
    "        loss_ = np.Inf\n",
    "        loss = np.Inf\n",
    "        for c in comb:\n",
    "            split_threshold_ = c\n",
    "            split_df_ =[df[df[name].isin(split_threshold_)],\n",
    "                        df[~df[name].isin(split_threshold_)]]\n",
    "            N = len(df.index)\n",
    "            n = [len(df_.index) for df_ in split_df_]\n",
    "            loss_ = n[0]/N * self._loss(split_df_[0]) + n[1]/N * self._loss(split_df_[1])\n",
    "            if loss_ < loss:\n",
    "                loss = loss_\n",
    "                split_threshold = split_threshold_\n",
    "                split_df = split_df_\n",
    "        return loss, split_df, split_threshold\n",
    "    \n",
    "    def _loss(self,df):\n",
    "        #return self._gini_impurity(df)\n",
    "        return self._shannon_entropy(df)\n",
    "    \n",
    "    def metrics(self,df=None):\n",
    "        confmat = self.confusion_matrix(df=df)\n",
    "        P = self._precision(confmat)\n",
    "        #print(f\"precision: {P}\")\n",
    "        R = self._recall(confmat)\n",
    "        #print(f\"recall: {R}\")\n",
    "        F = np.mean(self._F1(P,R))\n",
    "        #print(f\"F-score: {F}\")\n",
    "        A = self._accuracy(confmat)\n",
    "        return {\"precision\":P,\n",
    "                \"recall\":R,\n",
    "                \"F-score\":F,\n",
    "                \"accuracy\":A}\n",
    "    \n",
    "    def prune(self,alpha_max=None, test_set=None):\n",
    "        #if not alpha_max:\n",
    "        #    tree = copy.deepcopy(self.tree)\n",
    "        #else:\n",
    "        tree = self.tree\n",
    "                \n",
    "        d={}\n",
    "        d[\"alpha\"]=[]\n",
    "        d[\"R\"]=[]\n",
    "        d[\"n_leafs\"]=[]\n",
    "        if test_set is not None:\n",
    "            d[\"A_cv\"] = []\n",
    "            d[\"R_cv\"] = []\n",
    "            d[\"P_cv\"] = []\n",
    "            d[\"F_cv\"] = []\n",
    "        n_iter = 0\n",
    "        g_min = 0\n",
    "        alpha = 0\n",
    "        #print(\"n_leafs\\tR\\talpha\")\n",
    "        n_leafs, R = self._g2(tree.root)\n",
    "        #print(f\"{n_leafs}\\t{R:.4f}\\t{g_min:.2e}\")\n",
    "        while tree.leaf_count() > 1 and n_iter < 100:\n",
    "            n_iter += 1\n",
    "            \n",
    "            alpha = g_min\n",
    "            if alpha_max is not None and alpha > alpha_max:\n",
    "                break\n",
    "            # compute g\n",
    "            nodes = tree.nodes()\n",
    "            g = []\n",
    "            pnodes = []\n",
    "            for n in nodes:\n",
    "                if not n.is_leaf:\n",
    "                    g.append(self._g(n))\n",
    "                    pnodes.append(n)\n",
    "                    \n",
    "            g_min = max(0,np.min(g))\n",
    "            for i, n in enumerate(pnodes):\n",
    "                if g[i] <= g_min:\n",
    "                    n.is_leaf = True\n",
    "            N, R = self._g2(tree.root)\n",
    "            #print(f\"{N}\\t{R:.4f}\\t{alpha:.2e}\")\n",
    "            if test_set is not None:\n",
    "                metrics = self.metrics(df=test_set)\n",
    "                d[\"A_cv\"].append(metrics[\"accuracy\"])\n",
    "                d[\"R_cv\"].append(metrics[\"recall\"])\n",
    "                d[\"P_cv\"].append(metrics[\"precision\"])\n",
    "                d[\"F_cv\"].append(metrics[\"F-score\"])\n",
    "            d[\"alpha\"].append(alpha)\n",
    "            d[\"n_leafs\"].append(N)\n",
    "            d[\"R\"].append(R)\n",
    "        return d\n",
    "            \n",
    "    \n",
    "    def _g(self,node):\n",
    "        n_leafs, R_desc = self._g2(node)\n",
    "        R = node.pinfo[\"R\"]\n",
    "        #print(n_leafs, R, R_desc)\n",
    "        return (R - R_desc)/(n_leafs - 1)\n",
    "                              \n",
    "    def _g2(self,node):\n",
    "        n_leafs = 0\n",
    "        R_desc = 0\n",
    "        if node.is_leaf:\n",
    "            return 1, node.pinfo[\"R\"]\n",
    "        \n",
    "        for b in node.branches:\n",
    "            nl, R = self._g2(b)\n",
    "            n_leafs += nl\n",
    "            R_desc += R\n",
    "        return n_leafs, R_desc\n",
    "    \n",
    "    def confusion_matrix(self,df=None):\n",
    "        if df is None:\n",
    "            df = self.df\n",
    "        unique = np.unique(self.df[self.y_name].values)\n",
    "        classes = unique.tolist()#self.tree.classes()\n",
    "        n_classes = len(classes)\n",
    "        confmat = np.zeros((n_classes,n_classes))\n",
    "        \n",
    "        for i in range(len(df.index)):\n",
    "            val_pred = self.tree.predict(df.iloc[i]).value\n",
    "            val_true = df[self.y_name].iloc[i]\n",
    "            i_pred = classes.index(val_pred)\n",
    "            i_true = classes.index(val_true)\n",
    "            confmat[i_true,i_pred] += 1\n",
    "        return confmat\n",
    "           \n",
    "    @staticmethod\n",
    "    def _precision(m):\n",
    "        return np.diag(m) / np.sum(m, axis=1)\n",
    "        \n",
    "    @staticmethod\n",
    "    def _recall(m):\n",
    "        return np.diag(m) / np.sum(m, axis=0)\n",
    "    \n",
    "    @staticmethod\n",
    "    def _F1(P,R):\n",
    "        #F = np.zeros_like(P)\n",
    "        #for i in range(len(\n",
    "        return 2 * P * R / (P + R)\n",
    "    \n",
    "    @staticmethod\n",
    "    def _accuracy(m):\n",
    "        return np.sum(np.diag(m))/np.sum(np.sum(m))\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iris dataset\n",
    "=="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_iris=pd.read_csv(\"iris.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>5.0</td>\n",
       "      <td>1.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>5.4</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>5.1</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     petal_length  petal_width\n",
       "0             1.4          0.2\n",
       "1             1.4          0.2\n",
       "2             1.3          0.2\n",
       "3             1.5          0.2\n",
       "4             1.4          0.2\n",
       "..            ...          ...\n",
       "145           5.2          2.3\n",
       "146           5.0          1.9\n",
       "147           5.2          2.0\n",
       "148           5.4          2.3\n",
       "149           5.1          1.8\n",
       "\n",
       "[150 rows x 2 columns]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_iris.columns\n",
    "X_names=[\"petal_length\",\"petal_width\"]\n",
    "df_iris[X_names]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 11 leafs was created\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Tree at 0x7f1c387fde10>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_iris = CART(df_iris,\"species\")#_names)\n",
    "c_iris.create_tree()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'setosa'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_iris.tree.predict(df_iris.iloc[0]).value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'N': 50, 'r': 0.0, 'R': 0.0}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_iris.tree.root.branches[0].pinfo\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'alpha': [0,\n",
       "  0.0033333333333333305,\n",
       "  0.006666666666666663,\n",
       "  0.29333333333333333],\n",
       " 'R': [0.013333333333333322,\n",
       "  0.03999999999999997,\n",
       "  0.3333333333333333,\n",
       "  0.6666666666666667],\n",
       " 'n_leafs': [7, 3, 2, 1]}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_iris.prune()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 11 leafs was created\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'alpha': [0], 'R': [0.013333333333333322], 'n_leafs': [7]}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_iris.create_tree()\n",
    "c_iris.prune(alpha_max = 2e-3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[50.,  0.,  0.],\n",
       "       [ 0., 48.,  2.],\n",
       "       [ 0.,  0., 50.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "c_iris.confusion_matrix()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f1c36a40550>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "colors = {\"setosa\":\"red\", \"versicolor\":\"blue\", \"virginica\":\"green\"}\n",
    "plt.scatter(df_iris[\"petal_length\"],df_iris[\"petal_width\"],c=df_iris[\"species\"].map(colors))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "x, y = np.meshgrid(np.linspace(1,7,11),np.linspace(0,2.5,11))\n",
    "col = []\n",
    "for i in range(len(x.ravel())):\n",
    "    d = df_iris.iloc[120].copy()\n",
    "    d[\"petal_length\"] = x.ravel()[i]\n",
    "    d[\"petal_width\"] = y.ravel()[i]\n",
    "    col.append(c_iris.tree.predict(d).value)\n",
    "for i in range(len(col)):\n",
    "    if col[i] == \"setosa\":\n",
    "        col[i] = 0\n",
    "    if col[i] == \"versicolor\":\n",
    "        col[i] = 1\n",
    "    if col[i] == \"virginica\":\n",
    "        col[i] = 2\n",
    "z = np.array(col).reshape(x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f1c34582290>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.pcolormesh(x,y,z)\n",
    "ax.scatter(df_iris[\"petal_length\"],df_iris[\"petal_width\"],c=df_iris[\"species\"].map(colors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'precision': array([1.  , 0.96, 1.  ]),\n",
       " 'recall': array([1.        , 1.        , 0.96153846]),\n",
       " 'F-score': 0.9866613311991462,\n",
       " 'accuracy': 0.9866666666666667}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_iris.metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 11 leafs was created\n",
      "A tree with 10 leafs was created\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/ipykernel_launcher.py:352: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 9 leafs was created\n",
      "A tree with 10 leafs was created\n",
      "A tree with 9 leafs was created\n",
      "A tree with 5 leafs was created\n",
      "beta_best: 0.004714045207910313\n",
      "A tree with 11 leafs was created\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c_iris.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "petal_length<2.30\n",
      "├── False:petal_width<1.65\n",
      "│   ├── False:virginica\n",
      "│   └── True: versicolor\n",
      "└── True: setosa\n",
      "\n"
     ]
    }
   ],
   "source": [
    "c_iris.tree.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'precision': array([1.  , 0.96, 0.92]),\n",
       " 'recall': array([1.        , 0.92307692, 0.95833333]),\n",
       " 'F-score': 0.9599839935974389,\n",
       " 'accuracy': 0.96}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_iris.metrics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Titanic dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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>Survived</th>\n",
       "      <th>Pclass</th>\n",
       "      <th>Name</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Age</th>\n",
       "      <th>Siblings/Spouses Aboard</th>\n",
       "      <th>Parents/Children Aboard</th>\n",
       "      <th>Fare</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>Mr. Owen Harris Braund</td>\n",
       "      <td>male</td>\n",
       "      <td>22.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>7.2500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Mrs. John Bradley (Florence Briggs Thayer) Cum...</td>\n",
       "      <td>female</td>\n",
       "      <td>38.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>71.2833</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>Miss. Laina Heikkinen</td>\n",
       "      <td>female</td>\n",
       "      <td>26.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>7.9250</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Mrs. Jacques Heath (Lily May Peel) Futrelle</td>\n",
       "      <td>female</td>\n",
       "      <td>35.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>53.1000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>Mr. William Henry Allen</td>\n",
       "      <td>male</td>\n",
       "      <td>35.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8.0500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>882</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>Rev. Juozas Montvila</td>\n",
       "      <td>male</td>\n",
       "      <td>27.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>13.0000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>883</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Miss. Margaret Edith Graham</td>\n",
       "      <td>female</td>\n",
       "      <td>19.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>30.0000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>884</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>Miss. Catherine Helen Johnston</td>\n",
       "      <td>female</td>\n",
       "      <td>7.0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>23.4500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>885</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>Mr. Karl Howell Behr</td>\n",
       "      <td>male</td>\n",
       "      <td>26.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>30.0000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>886</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>Mr. Patrick Dooley</td>\n",
       "      <td>male</td>\n",
       "      <td>32.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>7.7500</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>887 rows × 8 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Survived  Pclass                                               Name  \\\n",
       "0           0       3                             Mr. Owen Harris Braund   \n",
       "1           1       1  Mrs. John Bradley (Florence Briggs Thayer) Cum...   \n",
       "2           1       3                              Miss. Laina Heikkinen   \n",
       "3           1       1        Mrs. Jacques Heath (Lily May Peel) Futrelle   \n",
       "4           0       3                            Mr. William Henry Allen   \n",
       "..        ...     ...                                                ...   \n",
       "882         0       2                               Rev. Juozas Montvila   \n",
       "883         1       1                        Miss. Margaret Edith Graham   \n",
       "884         0       3                     Miss. Catherine Helen Johnston   \n",
       "885         1       1                               Mr. Karl Howell Behr   \n",
       "886         0       3                                 Mr. Patrick Dooley   \n",
       "\n",
       "        Sex   Age  Siblings/Spouses Aboard  Parents/Children Aboard     Fare  \n",
       "0      male  22.0                        1                        0   7.2500  \n",
       "1    female  38.0                        1                        0  71.2833  \n",
       "2    female  26.0                        0                        0   7.9250  \n",
       "3    female  35.0                        1                        0  53.1000  \n",
       "4      male  35.0                        0                        0   8.0500  \n",
       "..      ...   ...                      ...                      ...      ...  \n",
       "882    male  27.0                        0                        0  13.0000  \n",
       "883  female  19.0                        0                        0  30.0000  \n",
       "884  female   7.0                        1                        2  23.4500  \n",
       "885    male  26.0                        0                        0  30.0000  \n",
       "886    male  32.0                        0                        0   7.7500  \n",
       "\n",
       "[887 rows x 8 columns]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_titanic = pd.read_csv(\"titanic.csv\")\n",
    "df_titanic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Survived', 'Pclass', 'Name', 'Sex', 'Age', 'Siblings/Spouses Aboard',\n",
       "       'Parents/Children Aboard', 'Fare'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_titanic.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 96 leafs was created\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Tree at 0x7f1c3452ef10>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "c_titanic = CART(df_titanic,\"Survived\",[\"Pclass\",\"Age\",\"Fare\",\"Siblings/Spouses Aboard\",\"Sex\",\"Parents/Children Aboard\"], min_leaf_samples=5, min_split_samples=4)\n",
    "c_titanic.create_tree()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'precision': array([0.95412844, 0.76315789]),\n",
       " 'recall': array([0.86522463, 0.91258741]),\n",
       " 'F-score': 0.869357277042274,\n",
       " 'accuracy': 0.8804960541149943}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "c_titanic.metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'alpha': [0,\n",
       "  0,\n",
       "  4.336808689942018e-19,\n",
       "  6.505213034913027e-19,\n",
       "  8.673617379884035e-19,\n",
       "  1.0842021724855044e-18,\n",
       "  1.3877787807814458e-18,\n",
       "  4.336808689942018e-18,\n",
       "  6.938893903907228e-18,\n",
       "  0.0005636978579481406,\n",
       "  0.0006764374295377678,\n",
       "  0.0011273957158962787,\n",
       "  0.0011273957158962791,\n",
       "  0.00112739571589628,\n",
       "  0.0016910935738444245,\n",
       "  0.002254791431792559,\n",
       "  0.0024426907177752706,\n",
       "  0.002442690717775272,\n",
       "  0.00479143179255918,\n",
       "  0.007891770011273967,\n",
       "  0.01071025930101465],\n",
       " 'R': [0.11950394588500562,\n",
       "  0.11950394588500562,\n",
       "  0.11950394588500562,\n",
       "  0.11950394588500562,\n",
       "  0.11950394588500564,\n",
       "  0.11950394588500564,\n",
       "  0.11950394588500564,\n",
       "  0.11950394588500565,\n",
       "  0.12063134160090193,\n",
       "  0.12401352874859076,\n",
       "  0.1262683201803833,\n",
       "  0.1273957158962796,\n",
       "  0.1285231116121759,\n",
       "  0.13190529875986473,\n",
       "  0.13641488162344984,\n",
       "  0.15107102593010147,\n",
       "  0.1657271702367531,\n",
       "  0.18489289740698983,\n",
       "  0.1927846674182638,\n",
       "  0.2142051860202931,\n",
       "  0.38556933483652767],\n",
       " 'n_leafs': [51,\n",
       "  50,\n",
       "  47,\n",
       "  44,\n",
       "  43,\n",
       "  38,\n",
       "  37,\n",
       "  36,\n",
       "  34,\n",
       "  29,\n",
       "  27,\n",
       "  26,\n",
       "  25,\n",
       "  23,\n",
       "  21,\n",
       "  15,\n",
       "  9,\n",
       "  5,\n",
       "  4,\n",
       "  2,\n",
       "  1]}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_titanic.prune()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 96 leafs was created\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'alpha': [0,\n",
       "  0,\n",
       "  4.336808689942018e-19,\n",
       "  6.505213034913027e-19,\n",
       "  8.673617379884035e-19,\n",
       "  1.0842021724855044e-18,\n",
       "  1.3877787807814458e-18,\n",
       "  4.336808689942018e-18,\n",
       "  6.938893903907228e-18,\n",
       "  0.0005636978579481406,\n",
       "  0.0006764374295377678,\n",
       "  0.0011273957158962787,\n",
       "  0.0011273957158962791,\n",
       "  0.00112739571589628,\n",
       "  0.0016910935738444245],\n",
       " 'R': [0.11950394588500562,\n",
       "  0.11950394588500562,\n",
       "  0.11950394588500562,\n",
       "  0.11950394588500562,\n",
       "  0.11950394588500564,\n",
       "  0.11950394588500564,\n",
       "  0.11950394588500564,\n",
       "  0.11950394588500565,\n",
       "  0.12063134160090193,\n",
       "  0.12401352874859076,\n",
       "  0.1262683201803833,\n",
       "  0.1273957158962796,\n",
       "  0.1285231116121759,\n",
       "  0.13190529875986473,\n",
       "  0.13641488162344984],\n",
       " 'n_leafs': [51, 50, 47, 44, 43, 38, 37, 36, 34, 29, 27, 26, 25, 23, 21]}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_titanic.create_tree()\n",
    "c_titanic.prune(alpha_max=1.7e-3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sex in ('female',)\n",
      "├── False:Pclass<1.47\n",
      "│   ├── False:Age<45.02\n",
      "│   │   ├── False:0\n",
      "│   │   └── True: Age<10.37\n",
      "│   │       ├── False:0\n",
      "│   │       └── True: Siblings/Spouses Aboard<1.17\n",
      "│   │           ├── False:0\n",
      "│   │           └── True: 1\n",
      "│   └── True: Age<52.46\n",
      "│       ├── False:0\n",
      "│       └── True: Parents/Children Aboard<1.24\n",
      "│           ├── False:1\n",
      "│           └── True: Age<36.25\n",
      "│               ├── False:0\n",
      "│               └── True: Age<22.25\n",
      "│                   ├── False:Age<27.24\n",
      "│                   │   ├── False:Age<31.06\n",
      "│                   │   │   ├── False:1\n",
      "│                   │   │   └── True: 0\n",
      "│                   │   └── True: 1\n",
      "│                   └── True: 0\n",
      "└── True: Pclass<2.24\n",
      "    ├── False:Fare<24.67\n",
      "    │   ├── False:0\n",
      "    │   └── True: Age<37.99\n",
      "    │       ├── False:0\n",
      "    │       └── True: Parents/Children Aboard<1.53\n",
      "    │           ├── False:1\n",
      "    │           └── True: Age<6.04\n",
      "    │               ├── False:Age<32.32\n",
      "    │               │   ├── False:1\n",
      "    │               │   └── True: Fare<13.40\n",
      "    │               │       ├── False:0\n",
      "    │               │       └── True: Fare<7.99\n",
      "    │               │           ├── False:Age<18.25\n",
      "    │               │           │   ├── False:0\n",
      "    │               │           │   └── True: 1\n",
      "    │               │           └── True: 1\n",
      "    │               └── True: 1\n",
      "    └── True: 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "c_titanic.tree.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'precision': array([0.93577982, 0.74853801]),\n",
       " 'recall': array([0.8557047 , 0.87972509]),\n",
       " 'F-score': 0.851399717273587,\n",
       " 'accuracy': 0.8635851183765502}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_titanic.metrics()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 96 leafs was created\n",
      "A tree with 80 leafs was created\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/ipykernel_launcher.py:352: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 89 leafs was created\n",
      "A tree with 76 leafs was created\n",
      "A tree with 76 leafs was created\n",
      "A tree with 86 leafs was created\n",
      "beta_best: 0.0013807721210728197\n",
      "A tree with 96 leafs was created\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c_titanic.train(slack=0.1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sex in ('female',)\n",
      "├── False:Pclass<1.47\n",
      "│   ├── False:Age<45.02\n",
      "│   │   ├── False:0\n",
      "│   │   └── True: Age<10.37\n",
      "│   │       ├── False:0\n",
      "│   │       └── True: Siblings/Spouses Aboard<1.17\n",
      "│   │           ├── False:0\n",
      "│   │           └── True: 1\n",
      "│   └── True: Age<52.46\n",
      "│       ├── False:0\n",
      "│       └── True: Parents/Children Aboard<1.24\n",
      "│           ├── False:1\n",
      "│           └── True: Age<36.25\n",
      "│               ├── False:Age<47.55\n",
      "│               │   ├── False:Fare<90.24\n",
      "│               │   │   ├── False:0\n",
      "│               │   │   └── True: 1\n",
      "│               │   └── True: 0\n",
      "│               └── True: Age<22.25\n",
      "│                   ├── False:Age<27.24\n",
      "│                   │   ├── False:Age<31.06\n",
      "│                   │   │   ├── False:1\n",
      "│                   │   │   └── True: 0\n",
      "│                   │   └── True: 1\n",
      "│                   └── True: 0\n",
      "└── True: Pclass<2.24\n",
      "    ├── False:Fare<24.67\n",
      "    │   ├── False:0\n",
      "    │   └── True: Age<37.99\n",
      "    │       ├── False:0\n",
      "    │       └── True: Parents/Children Aboard<1.53\n",
      "    │           ├── False:1\n",
      "    │           └── True: Age<6.04\n",
      "    │               ├── False:Age<32.32\n",
      "    │               │   ├── False:1\n",
      "    │               │   └── True: Fare<13.40\n",
      "    │               │       ├── False:0\n",
      "    │               │       └── True: Fare<7.99\n",
      "    │               │           ├── False:Age<18.25\n",
      "    │               │           │   ├── False:0\n",
      "    │               │           │   └── True: 1\n",
      "    │               │           └── True: 1\n",
      "    │               └── True: 1\n",
      "    └── True: 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "c_titanic.tree.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'precision': array([0.93027523, 0.76900585]),\n",
       " 'recall': array([0.86518771, 0.87375415]),\n",
       " 'F-score': 0.8572960797983589,\n",
       " 'accuracy': 0.8680947012401353}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_titanic.metrics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Penguins dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['rowid', 'species', 'island', 'bill_length_mm', 'bill_depth_mm',\n",
       "       'flipper_length_mm', 'body_mass_g', 'sex', 'year'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "df_penguins = pd.read_csv(\"penguins.txt\")\n",
    "df_penguins.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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>rowid</th>\n",
       "      <th>species</th>\n",
       "      <th>island</th>\n",
       "      <th>bill_length_mm</th>\n",
       "      <th>bill_depth_mm</th>\n",
       "      <th>flipper_length_mm</th>\n",
       "      <th>body_mass_g</th>\n",
       "      <th>sex</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Adelie</td>\n",
       "      <td>Torgersen</td>\n",
       "      <td>39.1</td>\n",
       "      <td>18.7</td>\n",
       "      <td>181.0</td>\n",
       "      <td>3750.0</td>\n",
       "      <td>male</td>\n",
       "      <td>2007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Adelie</td>\n",
       "      <td>Torgersen</td>\n",
       "      <td>39.5</td>\n",
       "      <td>17.4</td>\n",
       "      <td>186.0</td>\n",
       "      <td>3800.0</td>\n",
       "      <td>female</td>\n",
       "      <td>2007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Adelie</td>\n",
       "      <td>Torgersen</td>\n",
       "      <td>40.3</td>\n",
       "      <td>18.0</td>\n",
       "      <td>195.0</td>\n",
       "      <td>3250.0</td>\n",
       "      <td>female</td>\n",
       "      <td>2007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Adelie</td>\n",
       "      <td>Torgersen</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Adelie</td>\n",
       "      <td>Torgersen</td>\n",
       "      <td>36.7</td>\n",
       "      <td>19.3</td>\n",
       "      <td>193.0</td>\n",
       "      <td>3450.0</td>\n",
       "      <td>female</td>\n",
       "      <td>2007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>339</th>\n",
       "      <td>340</td>\n",
       "      <td>Chinstrap</td>\n",
       "      <td>Dream</td>\n",
       "      <td>55.8</td>\n",
       "      <td>19.8</td>\n",
       "      <td>207.0</td>\n",
       "      <td>4000.0</td>\n",
       "      <td>male</td>\n",
       "      <td>2009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>340</th>\n",
       "      <td>341</td>\n",
       "      <td>Chinstrap</td>\n",
       "      <td>Dream</td>\n",
       "      <td>43.5</td>\n",
       "      <td>18.1</td>\n",
       "      <td>202.0</td>\n",
       "      <td>3400.0</td>\n",
       "      <td>female</td>\n",
       "      <td>2009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>341</th>\n",
       "      <td>342</td>\n",
       "      <td>Chinstrap</td>\n",
       "      <td>Dream</td>\n",
       "      <td>49.6</td>\n",
       "      <td>18.2</td>\n",
       "      <td>193.0</td>\n",
       "      <td>3775.0</td>\n",
       "      <td>male</td>\n",
       "      <td>2009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>342</th>\n",
       "      <td>343</td>\n",
       "      <td>Chinstrap</td>\n",
       "      <td>Dream</td>\n",
       "      <td>50.8</td>\n",
       "      <td>19.0</td>\n",
       "      <td>210.0</td>\n",
       "      <td>4100.0</td>\n",
       "      <td>male</td>\n",
       "      <td>2009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>343</th>\n",
       "      <td>344</td>\n",
       "      <td>Chinstrap</td>\n",
       "      <td>Dream</td>\n",
       "      <td>50.2</td>\n",
       "      <td>18.7</td>\n",
       "      <td>198.0</td>\n",
       "      <td>3775.0</td>\n",
       "      <td>female</td>\n",
       "      <td>2009</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>344 rows × 9 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     rowid    species     island  bill_length_mm  bill_depth_mm  \\\n",
       "0        1     Adelie  Torgersen            39.1           18.7   \n",
       "1        2     Adelie  Torgersen            39.5           17.4   \n",
       "2        3     Adelie  Torgersen            40.3           18.0   \n",
       "3        4     Adelie  Torgersen             NaN            NaN   \n",
       "4        5     Adelie  Torgersen            36.7           19.3   \n",
       "..     ...        ...        ...             ...            ...   \n",
       "339    340  Chinstrap      Dream            55.8           19.8   \n",
       "340    341  Chinstrap      Dream            43.5           18.1   \n",
       "341    342  Chinstrap      Dream            49.6           18.2   \n",
       "342    343  Chinstrap      Dream            50.8           19.0   \n",
       "343    344  Chinstrap      Dream            50.2           18.7   \n",
       "\n",
       "     flipper_length_mm  body_mass_g     sex  year  \n",
       "0                181.0       3750.0    male  2007  \n",
       "1                186.0       3800.0  female  2007  \n",
       "2                195.0       3250.0  female  2007  \n",
       "3                  NaN          NaN     NaN  2007  \n",
       "4                193.0       3450.0  female  2007  \n",
       "..                 ...          ...     ...   ...  \n",
       "339              207.0       4000.0    male  2009  \n",
       "340              202.0       3400.0  female  2009  \n",
       "341              193.0       3775.0    male  2009  \n",
       "342              210.0       4100.0    male  2009  \n",
       "343              198.0       3775.0  female  2009  \n",
       "\n",
       "[344 rows x 9 columns]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_penguins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "c_penguins = CART(df_penguins,\"species\",[\"island\",\"bill_length_mm\",\"bill_depth_mm\",\"flipper_length_mm\",\"body_mass_g\",\"sex\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 13 leafs was created\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Tree at 0x7f1c3420e4d0>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_penguins.create_tree()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'precision': array([1., 1., 1.]),\n",
       " 'recall': array([1., 1., 1.]),\n",
       " 'F-score': 1.0,\n",
       " 'accuracy': 1.0}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_penguins.metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'alpha': [0,\n",
       "  0.002906976744186047,\n",
       "  0.0029069767441860478,\n",
       "  0.004844961240310083,\n",
       "  0.00872093023255814,\n",
       "  0.01162790697674419,\n",
       "  0.023255813953488393,\n",
       "  0.14244186046511625],\n",
       " 'R': [0.005813953488372094,\n",
       "  0.01162790697674419,\n",
       "  0.026162790697674437,\n",
       "  0.03488372093023258,\n",
       "  0.04651162790697677,\n",
       "  0.06976744186046516,\n",
       "  0.21220930232558144,\n",
       "  0.5581395348837209],\n",
       " 'n_leafs': [11, 9, 6, 5, 4, 3, 2, 1]}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_penguins.prune()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 13 leafs was created\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'alpha': [0,\n",
       "  0.002906976744186047,\n",
       "  0.0029069767441860478,\n",
       "  0.004844961240310083],\n",
       " 'R': [0.005813953488372094,\n",
       "  0.01162790697674419,\n",
       "  0.026162790697674437,\n",
       "  0.03488372093023258],\n",
       " 'n_leafs': [11, 9, 6, 5]}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_penguins.create_tree()\n",
    "c_penguins.prune(alpha_max=5e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 13 leafs was created\n",
      "A tree with 14 leafs was created\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/ipykernel_launcher.py:352: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 11 leafs was created\n",
      "A tree with 12 leafs was created\n",
      "A tree with 12 leafs was created\n",
      "A tree with 12 leafs was created\n",
      "beta_best: 0.00650019760901102\n",
      "A tree with 13 leafs was created\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c_penguins.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "flipper_length_mm<204.36\n",
      "├── False:island in ('Biscoe',)\n",
      "│   ├── False:Chinstrap\n",
      "│   └── True: Gentoo\n",
      "└── True: bill_length_mm<43.68\n",
      "    ├── False:island in ('Dream',)\n",
      "    │   ├── False:Adelie\n",
      "    │   └── True: Chinstrap\n",
      "    └── True: Adelie\n",
      "\n"
     ]
    }
   ],
   "source": [
    "c_penguins.tree.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'precision': array([0.97368421, 0.91176471, 0.98387097]),\n",
       " 'recall': array([0.94871795, 0.93939394, 1.        ]),\n",
       " 'F-score': 0.9594273380221687,\n",
       " 'accuracy': 0.9651162790697675}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_penguins.metrics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adult"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "      <th>11</th>\n",
       "      <th>12</th>\n",
       "      <th>13</th>\n",
       "      <th>14</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>39</td>\n",
       "      <td>State-gov</td>\n",
       "      <td>77516</td>\n",
       "      <td>Bachelors</td>\n",
       "      <td>13</td>\n",
       "      <td>Never-married</td>\n",
       "      <td>Adm-clerical</td>\n",
       "      <td>Not-in-family</td>\n",
       "      <td>White</td>\n",
       "      <td>Male</td>\n",
       "      <td>2174</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>United-States</td>\n",
       "      <td>&lt;=50K</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50</td>\n",
       "      <td>Self-emp-not-inc</td>\n",
       "      <td>83311</td>\n",
       "      <td>Bachelors</td>\n",
       "      <td>13</td>\n",
       "      <td>Married-civ-spouse</td>\n",
       "      <td>Exec-managerial</td>\n",
       "      <td>Husband</td>\n",
       "      <td>White</td>\n",
       "      <td>Male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>13</td>\n",
       "      <td>United-States</td>\n",
       "      <td>&lt;=50K</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>38</td>\n",
       "      <td>Private</td>\n",
       "      <td>215646</td>\n",
       "      <td>HS-grad</td>\n",
       "      <td>9</td>\n",
       "      <td>Divorced</td>\n",
       "      <td>Handlers-cleaners</td>\n",
       "      <td>Not-in-family</td>\n",
       "      <td>White</td>\n",
       "      <td>Male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>United-States</td>\n",
       "      <td>&lt;=50K</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>53</td>\n",
       "      <td>Private</td>\n",
       "      <td>234721</td>\n",
       "      <td>11th</td>\n",
       "      <td>7</td>\n",
       "      <td>Married-civ-spouse</td>\n",
       "      <td>Handlers-cleaners</td>\n",
       "      <td>Husband</td>\n",
       "      <td>Black</td>\n",
       "      <td>Male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>United-States</td>\n",
       "      <td>&lt;=50K</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>28</td>\n",
       "      <td>Private</td>\n",
       "      <td>338409</td>\n",
       "      <td>Bachelors</td>\n",
       "      <td>13</td>\n",
       "      <td>Married-civ-spouse</td>\n",
       "      <td>Prof-specialty</td>\n",
       "      <td>Wife</td>\n",
       "      <td>Black</td>\n",
       "      <td>Female</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>Cuba</td>\n",
       "      <td>&lt;=50K</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32556</th>\n",
       "      <td>27</td>\n",
       "      <td>Private</td>\n",
       "      <td>257302</td>\n",
       "      <td>Assoc-acdm</td>\n",
       "      <td>12</td>\n",
       "      <td>Married-civ-spouse</td>\n",
       "      <td>Tech-support</td>\n",
       "      <td>Wife</td>\n",
       "      <td>White</td>\n",
       "      <td>Female</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>38</td>\n",
       "      <td>United-States</td>\n",
       "      <td>&lt;=50K</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32557</th>\n",
       "      <td>40</td>\n",
       "      <td>Private</td>\n",
       "      <td>154374</td>\n",
       "      <td>HS-grad</td>\n",
       "      <td>9</td>\n",
       "      <td>Married-civ-spouse</td>\n",
       "      <td>Machine-op-inspct</td>\n",
       "      <td>Husband</td>\n",
       "      <td>White</td>\n",
       "      <td>Male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>United-States</td>\n",
       "      <td>&gt;50K</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32558</th>\n",
       "      <td>58</td>\n",
       "      <td>Private</td>\n",
       "      <td>151910</td>\n",
       "      <td>HS-grad</td>\n",
       "      <td>9</td>\n",
       "      <td>Widowed</td>\n",
       "      <td>Adm-clerical</td>\n",
       "      <td>Unmarried</td>\n",
       "      <td>White</td>\n",
       "      <td>Female</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>United-States</td>\n",
       "      <td>&lt;=50K</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32559</th>\n",
       "      <td>22</td>\n",
       "      <td>Private</td>\n",
       "      <td>201490</td>\n",
       "      <td>HS-grad</td>\n",
       "      <td>9</td>\n",
       "      <td>Never-married</td>\n",
       "      <td>Adm-clerical</td>\n",
       "      <td>Own-child</td>\n",
       "      <td>White</td>\n",
       "      <td>Male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>20</td>\n",
       "      <td>United-States</td>\n",
       "      <td>&lt;=50K</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32560</th>\n",
       "      <td>52</td>\n",
       "      <td>Self-emp-inc</td>\n",
       "      <td>287927</td>\n",
       "      <td>HS-grad</td>\n",
       "      <td>9</td>\n",
       "      <td>Married-civ-spouse</td>\n",
       "      <td>Exec-managerial</td>\n",
       "      <td>Wife</td>\n",
       "      <td>White</td>\n",
       "      <td>Female</td>\n",
       "      <td>15024</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>United-States</td>\n",
       "      <td>&gt;50K</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>32561 rows × 15 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       0                  1       2            3   4                    5   \\\n",
       "0      39          State-gov   77516    Bachelors  13        Never-married   \n",
       "1      50   Self-emp-not-inc   83311    Bachelors  13   Married-civ-spouse   \n",
       "2      38            Private  215646      HS-grad   9             Divorced   \n",
       "3      53            Private  234721         11th   7   Married-civ-spouse   \n",
       "4      28            Private  338409    Bachelors  13   Married-civ-spouse   \n",
       "...    ..                ...     ...          ...  ..                  ...   \n",
       "32556  27            Private  257302   Assoc-acdm  12   Married-civ-spouse   \n",
       "32557  40            Private  154374      HS-grad   9   Married-civ-spouse   \n",
       "32558  58            Private  151910      HS-grad   9              Widowed   \n",
       "32559  22            Private  201490      HS-grad   9        Never-married   \n",
       "32560  52       Self-emp-inc  287927      HS-grad   9   Married-civ-spouse   \n",
       "\n",
       "                       6               7       8        9      10  11  12  \\\n",
       "0            Adm-clerical   Not-in-family   White     Male   2174   0  40   \n",
       "1         Exec-managerial         Husband   White     Male      0   0  13   \n",
       "2       Handlers-cleaners   Not-in-family   White     Male      0   0  40   \n",
       "3       Handlers-cleaners         Husband   Black     Male      0   0  40   \n",
       "4          Prof-specialty            Wife   Black   Female      0   0  40   \n",
       "...                   ...             ...     ...      ...    ...  ..  ..   \n",
       "32556        Tech-support            Wife   White   Female      0   0  38   \n",
       "32557   Machine-op-inspct         Husband   White     Male      0   0  40   \n",
       "32558        Adm-clerical       Unmarried   White   Female      0   0  40   \n",
       "32559        Adm-clerical       Own-child   White     Male      0   0  20   \n",
       "32560     Exec-managerial            Wife   White   Female  15024   0  40   \n",
       "\n",
       "                   13      14  \n",
       "0       United-States   <=50K  \n",
       "1       United-States   <=50K  \n",
       "2       United-States   <=50K  \n",
       "3       United-States   <=50K  \n",
       "4                Cuba   <=50K  \n",
       "...               ...     ...  \n",
       "32556   United-States   <=50K  \n",
       "32557   United-States    >50K  \n",
       "32558   United-States   <=50K  \n",
       "32559   United-States   <=50K  \n",
       "32560   United-States    >50K  \n",
       "\n",
       "[32561 rows x 15 columns]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "df_adult= pd.read_csv(\"adult.data\",header=None)\n",
    "df_adult"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], dtype='int64')"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_adult.columns\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0         <=50K\n",
       "1         <=50K\n",
       "2         <=50K\n",
       "3         <=50K\n",
       "4         <=50K\n",
       "          ...  \n",
       "32556     <=50K\n",
       "32557      >50K\n",
       "32558     <=50K\n",
       "32559     <=50K\n",
       "32560      >50K\n",
       "Name: 14, Length: 32561, dtype: object"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_adult[14]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "c_adult=CART(df_adult,14,min_leaf_samples=32, min_split_samples=16, max_depth=9)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 262 leafs was created\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Tree at 0x7f1c742d4850>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "c_adult.create_tree()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 262 leafs was created\n",
      "A tree with 243 leafs was created\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/ipykernel_launcher.py:352: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tree with 240 leafs was created\n",
      "A tree with 251 leafs was created\n",
      "A tree with 245 leafs was created\n",
      "A tree with 243 leafs was created\n",
      "beta_best: 0.0003583201341966793\n",
      "A tree with 262 leafs was created\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c_adult.train()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'precision': array([0.91343042, 0.58602219]),\n",
       " 'recall': array([0.87431271, 0.68225687]),\n",
       " 'F-score': 0.7619660350682946,\n",
       " 'accuracy': 0.83458738982218}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_adult.metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 in (' Married-civ-spouse',)\n",
      "├── False: <=50K\n",
      "└── True: 4<12.05\n",
      "    ├── False:11<1793.49\n",
      "    │   ├── False: >50K\n",
      "    │   └── True: 12<30.31\n",
      "    │       ├── False:0<28.13\n",
      "    │       │   ├── False: >50K\n",
      "    │       │   └── True:  <=50K\n",
      "    │       └── True: 7 in (' Wife',)\n",
      "    │           ├── False: <=50K\n",
      "    │           └── True:  >50K\n",
      "    └── True: 4<7.56\n",
      "        ├── False:0<33.56\n",
      "        │   ├── False:12<32.33\n",
      "        │   │   ├── False:11<1753.80\n",
      "        │   │   │   ├── False:11<1992.78\n",
      "        │   │   │   │   ├── False: <=50K\n",
      "        │   │   │   │   └── True:  >50K\n",
      "        │   │   │   └── True: 3 in (' 12th', ' HS-grad')\n",
      "        │   │   │       ├── False:1 in (' Self-emp-not-inc',)\n",
      "        │   │   │       │   ├── False: >50K\n",
      "        │   │   │       │   └── True:  <=50K\n",
      "        │   │   │       └── True: 6 in (' Exec-managerial',)\n",
      "        │   │   │           ├── False: <=50K\n",
      "        │   │   │           └── True: 1 in (' Self-emp-not-inc',)\n",
      "        │   │   │               ├── False: >50K\n",
      "        │   │   │               └── True:  <=50K\n",
      "        │   │   └── True:  <=50K\n",
      "        │   └── True:  <=50K\n",
      "        └── True:  <=50K\n",
      "\n"
     ]
    }
   ],
   "source": [
    "c_adult.tree.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}