Decision Tree Regression .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decision Tree Regressor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In following [notebook](https://github.com/jyotipmahes/Implementation-of-ML-algos-in-Python/blob/master/Decision%20Tree%20Classifier.ipynb), we saw how to implement **DecisionTree Clasifier**. \n",
    "\n",
    "In this notebook we will implement **Decision Tree for regression**. The logic of tree building will remain same with slight modification in implementation. We will try a slight different approach to explore different ways in which we can implement the same logic. Note that previous implementation structure can also be used by changing the splitting criterion and prediction function. We calculate **variance** here as splitting criterion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Decision Tree initialization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time we will not use a fit method as used in previous classification notebook. Hence, we will do most of the heavy lifting during initialization step only. Here are the things we initialize in this step:\n",
    "1. `x` : Feature values of the data(ndarray)\n",
    "2. `y` : Target Value(a vector)\n",
    "3. `idx` : Refers to the data index's related to given node\n",
    "4. `min_leaf`: Minimum data points required on leaf node. Another way to **avoid over fitting** instead of using `max_depth`\n",
    "5. `n`: Number of data points corresponding to the node\n",
    "6. `c`: Number of features\n",
    "7. `val`: It is the mean of the target value associated to the node\n",
    "8. `score`: Variance score for node. \n",
    "9. `find_varsplit` : It finds the best split for the tree and starts splitting if possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecisionTreeReg():\n",
    "    def __init__(self, x, y, idxs, min_leaf=5):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.idxs = idxs\n",
    "        self.min_leaf = min_leaf\n",
    "        self.n = len(idxs)\n",
    "        self.c = x.shape[1]\n",
    "        self.val = np.mean(y[idxs])\n",
    "        self.score = float('inf')\n",
    "        self.find_varsplit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Splitting criterion\n",
    "For **regression** we use variance(Mean Square Error) as the splitting criterion which determines split.\n",
    "\n",
    "Reduction in variance is an algorithm used for continuous target variables (regression problems). This algorithm uses the standard formula of variance to choose the best split. **The split with lower variance is selected as the criteria to split the population:**\n",
    "\n",
    "$$ var = \\sum\\frac{(X-\\bar(X))^2}{n}$$\n",
    "\n",
    "which is also equal to:\n",
    "\n",
    "$$ var = {\\frac{\\sum{x^2}}{n} - \\bar(x)^2}$$\n",
    "\n",
    "\n",
    "Steps to calculate Variance:\n",
    "\n",
    "1. Calculate variance for each node.\n",
    "2. Calculate variance for each split as weighted average of each node variance.\n",
    "3. Compare with parent node and find the best split possible with lowest variance.\n",
    "\n",
    "The function given below calculate the variance using second formula. `cnt` is n, `s1` is $\\sum(x)$ and `s2` is $\\sum(x^2)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def std_agg(cnt, s1, s2): \n",
    "    return (s2/cnt) - (s1/cnt)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Finding best split point for a column/feature"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The objective here is to find the best split and we can take similar approach as last time. But will try a different way this time which is much more efficient. Here are the steps we will take to find best split:\n",
    "1. Store the x and y values for given column and given node by selecting column and row indexes.\n",
    "2. Sort the x value based on which we will split the data. Use the same order for y as well.\n",
    "3. We start by assigning all the data points to the right side of the child node and store the count, sum of x and sum of x^2 which are required for variance calculation.\n",
    "4. We assign no data point to left side and hence we get 0 as count, sum and sum of x^2.\n",
    "5. Now we run a for loop ranging from 0 to number of items on node - min_leaf-1. This is to ensure that we have min_leaf data points after split.\n",
    "6. As we loop through in the given range, we start assigning one data point at a time to left side by removing it from right side split. So, we update the count, sum and sum of x^2 accordingly. We also ensure that min_leaf data points are initialized first to left side before we compare the splits.\n",
    "7. Now we calculate the weighted sum of the variance of the new split and compare it with the parent node to find the best split point.\n",
    "8. Once we find the best split, we update the column index `var_idx`, `score` and `split` referring to best split value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_better_split(self, var_idx):\n",
    "    x = self.x.values[self.idxs,var_idx]\n",
    "    y = self.y[self.idxs]\n",
    "    sort_idx = np.argsort(x)\n",
    "    sort_y = y[sort_idx]\n",
    "    sort_x = x[sort_idx]\n",
    "    rhs_cnt = self.n \n",
    "    rhs_sum = sort_y.sum()\n",
    "    rhs_sum2 = (sort_y**2).sum()\n",
    "    lhs_cnt = 0\n",
    "    lhs_sum = 0.\n",
    "    lhs_sum2 = 0.\n",
    "\n",
    "    for i in range(0,self.n-self.min_leaf-1):\n",
    "        xi = sort_x[i]\n",
    "        yi = sort_y[i]\n",
    "        lhs_cnt += 1\n",
    "        rhs_cnt -= 1\n",
    "        lhs_sum += yi\n",
    "        rhs_sum -= yi\n",
    "        lhs_sum2 += yi**2\n",
    "        rhs_sum2 -= yi**2\n",
    "        if i<self.min_leaf or xi==sort_x[i+1]:\n",
    "            continue\n",
    "\n",
    "        lhs_std = std_agg(lhs_cnt, lhs_sum, lhs_sum2)\n",
    "        rhs_std = std_agg(rhs_cnt, rhs_sum, rhs_sum2)\n",
    "        curr_score = lhs_std*lhs_cnt/len(y) + rhs_std*rhs_cnt/len(y)\n",
    "        if curr_score<self.score: \n",
    "            self.var_idx = var_idx\n",
    "            self.score = curr_score\n",
    "            self.split = xi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Finding best split point and column\n",
    "We will now write a wrapper function, which check all the columns in the data to find the best column and best split as shown below. Once we find the best split column and split value, we create two child nodes as `left` and `right` and assign corresponding data points to each. Note `self.split_col` is a class property which gets the column value for best split column. For more understanding on `class property` refer to previous [notebook](https://github.com/jyotipmahes/Implementation-of-ML-algos-in-Python/blob/master/Decision%20Tree%20Classifier.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "@property\n",
    "def split_col(self): return self.x.values[self.idxs,self.var_idx]\n",
    "    \n",
    "def find_varsplit(self):\n",
    "    for i in range(self.c): \n",
    "        self.find_better_split(i)\n",
    "        \n",
    "    if self.score == float('inf'): return\n",
    "    x = self.split_col\n",
    "    lhs = np.nonzero(x<=self.split)[0]\n",
    "    rhs = np.nonzero(x>self.split)[0]\n",
    "    self.lhs = DecisionTree(self.x, self.y, self.idxs[lhs])\n",
    "    self.rhs = DecisionTree(self.x, self.y, self.idxs[rhs])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Few more property which can come handy\n",
    "**split_name**: It gets the name of column on which given node is split<br>\n",
    "**is_leaf**: Checks if given node is leaf or not<br>\n",
    "**__repr__**: Assigning string representation to the object. Helpful while printing and displaying"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "@property\n",
    "def split_name(self): return self.x.columns[self.var_idx]\n",
    "\n",
    "@property\n",
    "def is_leaf(self): return self.score == float('inf')\n",
    "\n",
    "def __repr__(self):\n",
    "    s = f'n: {self.n}; val:{self.val}'\n",
    "    if not self.is_leaf:\n",
    "        s += f'; score:{self.score}; split:{self.split}; var:{self.split_name}'\n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Making prediction on test data:\n",
    "`predict_row` function transverse the tree by comparing the test data to splitting criterion till it reaches leaf. At leaf, it return the `self.val` which the mean of the training data points corresponding to the leaf.\n",
    "\n",
    "`predict` runs above function on all the test points and returns an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_row(self, xi):\n",
    "    if self.is_leaf: return self.val\n",
    "    t = self.lhs if xi[self.var_idx]<=self.split else self.rhs\n",
    "    return t.predict_row(xi) \n",
    "\n",
    "def predict(self, x):\n",
    "    return np.array([self.predict_row(xi) for xi in x])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting Everything together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def std_agg(cnt, s1, s2): \n",
    "    return (s2/cnt) - (s1/cnt)**2\n",
    "\n",
    "class DecisionTreeReg():\n",
    "    \n",
    "    def __init__(self, x, y, idxs, min_leaf=5):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.idxs = idxs\n",
    "        self.min_leaf = min_leaf\n",
    "        self.n = len(idxs)\n",
    "        self.c = x.shape[1]\n",
    "        self.val = np.mean(y[idxs])\n",
    "        self.score = float('inf')\n",
    "        self.find_varsplit()\n",
    "    \n",
    "    def find_better_split(self, var_idx):\n",
    "        x = self.x.values[self.idxs,var_idx]\n",
    "        y = self.y[self.idxs]\n",
    "        sort_idx = np.argsort(x)\n",
    "        sort_y = y[sort_idx]\n",
    "        sort_x = x[sort_idx]\n",
    "        rhs_cnt = self.n \n",
    "        rhs_sum = sort_y.sum()\n",
    "        rhs_sum2 = (sort_y**2).sum()\n",
    "        lhs_cnt = 0\n",
    "        lhs_sum = 0.\n",
    "        lhs_sum2 = 0.\n",
    "\n",
    "        for i in range(0,self.n-self.min_leaf-1):\n",
    "            xi = sort_x[i]\n",
    "            yi = sort_y[i]\n",
    "            lhs_cnt += 1\n",
    "            rhs_cnt -= 1\n",
    "            lhs_sum += yi\n",
    "            rhs_sum -= yi\n",
    "            lhs_sum2 += yi**2\n",
    "            rhs_sum2 -= yi**2\n",
    "            if i<self.min_leaf or xi==sort_x[i+1]:\n",
    "                continue\n",
    "\n",
    "            lhs_std = std_agg(lhs_cnt, lhs_sum, lhs_sum2)\n",
    "            rhs_std = std_agg(rhs_cnt, rhs_sum, rhs_sum2)\n",
    "            curr_score = lhs_std*lhs_cnt/self.n + rhs_std*rhs_cnt/self.n\n",
    "            if curr_score<self.score: \n",
    "                self.var_idx = var_idx\n",
    "                self.score = curr_score\n",
    "                self.split = xi  \n",
    "    \n",
    "    @property\n",
    "    def split_col(self): return self.x.values[self.idxs,self.var_idx]\n",
    "\n",
    "    def find_varsplit(self):\n",
    "        for i in range(self.c): \n",
    "            self.find_better_split(i)\n",
    "\n",
    "        if self.score == float('inf'): return\n",
    "        x = self.split_col\n",
    "        lhs = np.nonzero(x<=self.split)[0]\n",
    "        rhs = np.nonzero(x>self.split)[0]\n",
    "        self.lhs = DecisionTreeReg(self.x, self.y, self.idxs[lhs])\n",
    "        self.rhs = DecisionTreeReg(self.x, self.y, self.idxs[rhs])\n",
    "\n",
    "        \n",
    "    @property\n",
    "    def split_name(self): return self.x.columns[self.var_idx]\n",
    "\n",
    "    @property\n",
    "    def is_leaf(self): return self.score == float('inf')\n",
    "\n",
    "    def __repr__(self):\n",
    "        s = f'n: {self.n}; val:{self.val}'\n",
    "        if not self.is_leaf:\n",
    "            s += f'; score:{self.score}; split:{self.split}; var:{self.split_name}'\n",
    "        return s\n",
    "\n",
    "    def predict_row(self, xi):\n",
    "        if self.is_leaf: return self.val\n",
    "        t = self.lhs if xi[self.var_idx]<=self.split else self.rhs\n",
    "        return t.predict_row(xi) \n",
    "\n",
    "    def predict(self, x):\n",
    "        return np.array([self.predict_row(xi) for xi in x])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checking Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_boston\n",
    "import pandas as pd\n",
    "bos = load_boston()\n",
    "x = bos.data\n",
    "y = bos.target\n",
    "x_df = pd.DataFrame(x, columns=bos.feature_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg = DecisionTreeReg(x_df, y, np.array(range(0, len(y))))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = reg.predict(np.array(x_df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.879892243296889"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum((y-pred)**2)/(len(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using sklearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeRegressor\n",
    "skreg = DecisionTreeRegressor(min_samples_leaf=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeRegressor(criterion='mse', max_depth=None, max_features=None,\n",
       "           max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "           min_impurity_split=None, min_samples_leaf=6,\n",
       "           min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
       "           presort=False, random_state=None, splitter='best')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "skreg.fit(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = skreg.predict(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.879892243296889"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum((y-pred)**2)/(len(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can see that our prediction matches with skelearn's prediction**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Decision Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import datasets\n",
    "from IPython.display import Image  \n",
    "from sklearn import tree\n",
    "import pydotplus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeRegressor\n",
    "skreg = DecisionTreeRegressor(min_samples_leaf=30)\n",
    "skreg.fit(x,y)\n",
    "\n",
    "# Create DOT data\n",
    "dot_data = tree.export_graphviz(skreg, out_file=None, \n",
    "                                feature_names=bos.feature_names,  \n",
    "                                class_names=bos.target)\n",
    "\n",
    "# Draw graph\n",
    "graph = pydotplus.graph_from_dot_data(dot_data)  \n",
    "\n",
    "# Show graph\n",
    "Image(graph.create_png())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}