decision_tree_regressor.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decision Tree Regressor from Scratch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import seed\n",
    "from math import log\n",
    "from statistics import mode\n",
    "from random import randrange\n",
    "from csv import reader\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = [[2.771244718, 1.784783929, 0],\n",
    "           [1.728571309, 1.169761413, 0.1],\n",
    "           [3.678319846, 2.81281357, 0.2],\n",
    "           [3.961043357, 2.61995032, -0.1],\n",
    "           [2.999208922, 2.209014212, 0.3],\n",
    "           [7.497545867, 3.162953546, 1.1],\n",
    "           [9.00220326, 3.339047188, 1.2],\n",
    "           [7.444542326, 0.476683375, 1.9],\n",
    "           [10.12493903, 3.234550982, 0.9],\n",
    "           [6.642287351, 3.319983761, 1.6]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choose best splits using heuristic Funtion: Gini index and Cross-Entropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4714045207910317\n",
      "0.4444444444444444\n"
     ]
    }
   ],
   "source": [
    "def split_criteria(y, criteria = 'std'):\n",
    "    \"\"\"\n",
    "    split_criteria([1,2,3,4,3], 'std') = std([1,2,3,4,3])\n",
    "    \"\"\"\n",
    "    if criteria == 'std':\n",
    "        if len(y) == 0: return 0\n",
    "        return np.std(y)\n",
    "    if criteria == 'mae':\n",
    "        u = np.mean(y)\n",
    "        return np.mean(np.abs(u - y))\n",
    "\n",
    "group_targets = [[1,2,1],[1,1,2]]\n",
    "s1, s2 = group_targets\n",
    "print(split_criteria(s1, 'std'))\n",
    "print(split_criteria(s1, 'mae'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_split(index, value, dataset):\n",
    "    \"\"\"\n",
    "    Split a dataset based on an attribute and an attribute value.\n",
    "    Complexity: O(#rows)\n",
    "    \"\"\"\n",
    "    left, right = list(), list()\n",
    "    for row in dataset:\n",
    "        if row[index] < value:\n",
    "            left.append(row)\n",
    "        else:\n",
    "            right.append(row)\n",
    "    return left, right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'attribute': 0,\n",
       " 'value': 6.642287351,\n",
       " 'groups': ([[2.771244718, 1.784783929, 0],\n",
       "   [1.728571309, 1.169761413, 0.1],\n",
       "   [3.678319846, 2.81281357, 0.2],\n",
       "   [3.961043357, 2.61995032, -0.1],\n",
       "   [2.999208922, 2.209014212, 0.3]],\n",
       "  [[7.497545867, 3.162953546, 1.1],\n",
       "   [9.00220326, 3.339047188, 1.2],\n",
       "   [7.444542326, 0.476683375, 1.9],\n",
       "   [10.12493903, 3.234550982, 0.9],\n",
       "   [6.642287351, 3.319983761, 1.6]])}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_split(dataset, criteria):\n",
    "    \"\"\"\n",
    "    This heuristic algorithm loops all rows (samples) and column (attributes), thus it is painful for computing.\n",
    "    Complexity: O(#rows^2 x #columns) x O(gini_index)\n",
    "    \"\"\"\n",
    "    attributes = len(dataset[0]) - 1\n",
    "    retAttribute, retValue, retGroups, min_loss = None, None, None, 999\n",
    "    for row in dataset:\n",
    "        for attribute in range(attributes):\n",
    "            group_left, group_right = test_split(attribute, row[attribute], dataset)\n",
    "#             group_left, group_right = groups\n",
    "            target_left = [row[-1] for row in group_left]\n",
    "            target_right = [row[-1] for row in group_right]\n",
    "\n",
    "            total = len(target_left) + len(target_right)\n",
    "            pL = len(target_left) / total\n",
    "            \n",
    "            loss =  pL * split_criteria(target_left, criteria) + (1 - pL) * split_criteria(target_right, criteria)\n",
    "            if loss < min_loss:\n",
    "                min_loss = loss\n",
    "                retAttribute, retValue, retGroups = attribute, row[attribute], (group_left, group_right)\n",
    "    return {'attribute': retAttribute, 'value': retValue, 'groups': retGroups}\n",
    "\n",
    "get_split(dataset, 'std')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666666666"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def to_terminal(outcomes):\n",
    "    assert outcomes, 'outcomes should not be empty'\n",
    "    return np.mean(outcomes)  # mean of predictions\n",
    "    \n",
    "outcomes = [0,1,1]\n",
    "to_terminal(outcomes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split(node, max_depth, min_size, depth, criteria, min_std):\n",
    "    left, right = node['groups']\n",
    "    outcomes_left = [row[-1] for row in left]\n",
    "    outcomes_right = [row[-1] for row in right]\n",
    "    \n",
    "    del(node['groups'])\n",
    "    # check for a no split\n",
    "    if not left or not right:  # left or right is empty list\n",
    "        node['left'] = node['right'] = to_terminal(outcomes_left + outcomes_right)\n",
    "        return\n",
    "    # check for max depth\n",
    "    if depth >= max_depth:\n",
    "        node['left'], node['right'] = to_terminal(outcomes_left), to_terminal(outcomes_right)\n",
    "        return\n",
    "    \n",
    "    # process left child\n",
    "\n",
    "    if len(left) <= min_size or np.std(outcomes_left) <= min_std:\n",
    "        node['left'] = to_terminal(outcomes_left)\n",
    "    else:\n",
    "        node['left'] = get_split(left, criteria)\n",
    "        split(node['left'], max_depth, min_size, depth+1, criteria, min_std)\n",
    "        \n",
    "    # process right child\n",
    "    \n",
    "    if len(right) <= min_size or np.std(outcomes_right) <= min_std:\n",
    "        node['right'] = to_terminal(outcomes_right)\n",
    "    else:\n",
    "        node['right'] = get_split(right, criteria)\n",
    "        split(node['right'], max_depth, min_size, depth+1, criteria, min_std)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build a decision tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[X11 < 0.199]\n",
      "--[X45 < 0.163]\n",
      "----[X1 < 0.020]\n",
      "------[1.0]\n",
      "------[0.8148148148148148]\n",
      "----[X15 < 0.334]\n",
      "------[0.7857142857142857]\n",
      "------[0.0]\n",
      "--[X45 < 0.266]\n",
      "----[X36 < 0.584]\n",
      "------[0.2191780821917808]\n",
      "------[1.0]\n",
      "----[0.0]\n"
     ]
    }
   ],
   "source": [
    "# Build a decision tree\n",
    "def build_tree(train_set, max_depth, min_size, criteria, min_std):\n",
    "    root = get_split(train_set, criteria)\n",
    "    split(root, max_depth, min_size, 0, criteria, min_std)\n",
    "    return root\n",
    "\n",
    "# Print a decision tree\n",
    "def print_tree(node, depth=0):\n",
    "    if isinstance(node, dict):\n",
    "        print('%s[X%d < %.3f]' %\n",
    "              ((depth*'-', (node['attribute']+1), node['value'])))\n",
    "        print_tree(node['left'], depth+2)\n",
    "        print_tree(node['right'], depth+2)\n",
    "    else:\n",
    "        print('%s[%s]' % ((depth*'-', node)))  # This is cool!\n",
    "\n",
    "\n",
    "tree = build_tree(dataset, 2, 1, 'std', .02)\n",
    "print_tree(tree)\n",
    "# print(tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(tree, input_row):  # input is row of testset\n",
    "    if input_row[tree['attribute']] < tree['value']:\n",
    "        if isinstance(tree['left'], dict):\n",
    "            return predict(tree['left'], input_row)\n",
    "        else:\n",
    "            return tree['left']\n",
    "    else:\n",
    "        if isinstance(tree['right'], dict):\n",
    "            return predict(tree['right'], input_row)\n",
    "        else:\n",
    "            return tree['right']\n",
    "\n",
    "# Root Mean Square Error\n",
    "def rmse(y, y_hat):\n",
    "    if not isinstance(y, np.ndarray):\n",
    "        y, y_hat = np.array(y), np.array(y_hat)\n",
    "    return np.mean((y - y_hat)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Work with Real Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load a CSV file\n",
    "def load_csv(filename):\n",
    "    file = open(filename, \"rt\")\n",
    "    lines = reader(file)\n",
    "    dataset = list(lines)\n",
    "    return dataset\n",
    "\n",
    "# Convert string column to float\n",
    "def str_column_to_float(dataset, column):\n",
    "    for row in dataset:\n",
    "        row[column] = float(row[column])\n",
    "\n",
    "# Convert string column to integer\n",
    "def str_column_to_int(dataset, column):\n",
    "\tclass_values = [row[column] for row in dataset]\n",
    "\tunique = set(class_values)\n",
    "\tlookup = dict()\n",
    "\tfor i, value in enumerate(unique):\n",
    "\t\tlookup[value] = i\n",
    "\tfor row in dataset:\n",
    "\t\trow[column] = lookup[row[column]]\n",
    "\treturn lookup\n",
    "\n",
    "# Split a dataset into k folds\n",
    "def cross_validation_split(dataset, n_folds):\n",
    "    dataset_split = list()\n",
    "    dataset_copy = list(dataset)\n",
    "    fold_size = int(len(dataset) / n_folds)\n",
    "    for i in range(n_folds):\n",
    "        fold = list()\n",
    "        while len(fold) < fold_size:\n",
    "            index = randrange(len(dataset_copy))\n",
    "            fold.append(dataset_copy.pop(index))\n",
    "        dataset_split.append(fold)\n",
    "    return dataset_split\n",
    "\n",
    "# Calculate accuracy percentage\n",
    "def accuracy_metric(actual, predicted):\n",
    "    correct = 0\n",
    "    for i in range(len(actual)):\n",
    "        if actual[i] == predicted[i]:\n",
    "            correct += 1\n",
    "    return correct / float(len(actual)) * 100.0\n",
    "\n",
    "# Evaluate an algorithm using a cross validation split\n",
    "def evaluate_algorithm(dataset, algorithm, n_folds,  *args, metric=rmse):\n",
    "#     metric = rmse\n",
    "    folds = cross_validation_split(dataset, n_folds)\n",
    "    scores = list()\n",
    "    for fold in folds:\n",
    "        train_set = list(folds)\n",
    "        train_set.remove(fold)\n",
    "        train_set = sum(train_set, [])  # concatenate lists of lists to a list\n",
    "        test_set = list()\n",
    "        for row in fold:\n",
    "            row_copy = list(row)\n",
    "            test_set.append(row_copy)\n",
    "            # test_set use to predict => no need to hold [class] data\n",
    "            row_copy[-1] = None\n",
    "        predicted = algorithm(train_set, test_set, *args)\n",
    "        actual = [row[-1] for row in fold]\n",
    "        accuracy = metric(actual, predicted)\n",
    "        scores.append(accuracy)\n",
    "    return scores\n",
    "\n",
    "def decision_tree_regressor(train_set, test_set, max_depth, min_size, criteria, min_std):\n",
    "    root = build_tree(train_set, max_depth, min_size, criteria, min_std)\n",
    "    prediction = list()\n",
    "    for row in test_set:\n",
    "        prediction.append(predict(root, row))\n",
    "    return prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The last row convert from str to int\n"
     ]
    }
   ],
   "source": [
    "seed(1)\n",
    "# load and prepare data\n",
    "\n",
    "# filename = 'data/sonar.csv' # 0.017\n",
    "filename = 'data/BankNote_Authentication.csv' # 0.232\n",
    "dataset = load_csv(filename)\n",
    "# remove the string attributes\n",
    "dataset.pop(0) \n",
    "\n",
    "# convert string attributes to float\n",
    "for i in range(len(dataset[0]) - 1):\n",
    "    str_column_to_float(dataset, i)\n",
    "\n",
    "# Check if the last row is not INT{0,1}\n",
    "if not isinstance(dataset[0][-1], int):\n",
    "    print(\"The last row convert from str to int\")\n",
    "    str_column_to_int(dataset, len(dataset[0])-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pronton/dev/python/ml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:3440: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/home/pronton/dev/python/ml/lib/python3.8/site-packages/numpy/core/_methods.py:189: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores: [0.05795105300541099, 0.04945780195668917, 0.08135879779259168, 0.09133296020779867, 0.061843035197121116]\n",
      "Root Mean Square Error: 0.068\n"
     ]
    }
   ],
   "source": [
    "# evaluate algorithm\n",
    "n_folds = 5\n",
    "max_depth = 5  # maximum depth of tree\n",
    "min_size = 10  # minimum size of 1 group\n",
    "min_std = 0.3\n",
    "scores = evaluate_algorithm(\n",
    "    dataset, decision_tree_regressor, n_folds, max_depth, min_size, 'mae', min_std)\n",
    "print('Scores: %s' % scores)\n",
    "print('Root Mean Square Error: %.3f' % (sum(scores)/float(len(scores))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores: [0.018783723096928138, 0.025047653239054314, 0.02148120691403082, 0.01442957556096242, 0.024131703565180674]\n",
      "Root Mean Square Error: 0.021\n"
     ]
    }
   ],
   "source": [
    "min_std = 0.02\n",
    "scores = evaluate_algorithm(\n",
    "    dataset, decision_tree_regressor, n_folds, max_depth, min_size, 'mae', min_std)\n",
    "print('Scores: %s' % scores)\n",
    "print('Root Mean Square Error: %.3f' % (sum(scores)/float(len(scores))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The last row convert from str to int\n"
     ]
    }
   ],
   "source": [
    "filename = 'data/sonar.csv' # 0.232\n",
    "# filename = 'data/BankNote_Authentication.csv' # 0.017\n",
    "dataset = load_csv(filename)\n",
    "# remove the string attributes\n",
    "dataset.pop(0) \n",
    "\n",
    "# convert string attributes to float\n",
    "for i in range(len(dataset[0]) - 1):\n",
    "    str_column_to_float(dataset, i)\n",
    "\n",
    "# Check if the last row is not INT{0,1}\n",
    "if not isinstance(dataset[0][-1], int):\n",
    "    print(\"The last row convert from str to int\")\n",
    "    str_column_to_int(dataset, len(dataset[0])-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores: [0.24606015576408996, 0.23903124256939617, 0.2612135169470215, 0.30152501332976844, 0.21100347569683064]\n",
      "Root Mean Square Error: 0.252\n"
     ]
    }
   ],
   "source": [
    "min_std = 0.3\n",
    "scores = evaluate_algorithm(\n",
    "    dataset, decision_tree_regressor, n_folds, max_depth, min_size, 'mae', min_std)\n",
    "print('Scores: %s' % scores)\n",
    "print('Root Mean Square Error: %.3f' % (sum(scores)/float(len(scores))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shuffle_data(X, y):\n",
    "    assert len(X) == len(y)\n",
    "    permute = np.random.permutation(len(y))\n",
    "    return X[permute], y[permute]\n",
    "\n",
    "def train_test_split_manual(X, y, test_size=0.3):\n",
    "    nX, ny = shuffle_data(X,y)\n",
    "    split_index = int(len(X)*test_size)\n",
    "    testX = nX[:split_index]\n",
    "    trainX = nX[split_index:]\n",
    "    testy = ny[:split_index]\n",
    "    trainy = ny[split_index:]\n",
    "    return trainX, testX, trainy, testy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get_data():\n",
    "    x = np.linspace(-10,10,500)\n",
    "    y = np.sin(x)\n",
    "    return x, y\n",
    "\n",
    "X,y = get_data()\n",
    "\n",
    "plt.plot(X,y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pronton/dev/python/ml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:3440: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/home/pronton/dev/python/ml/lib/python3.8/site-packages/numpy/core/_methods.py:189: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores: [0.001937070281358714, 0.002149837699059408, 0.0031898746866328496, 0.002463024915463776, 0.002242041889761075]\n",
      "Root Mean Square Error: 0.002\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_folds = 5\n",
    "max_depth = 20  # maximum depth of tree\n",
    "min_size = 2  # minimum size of 1 group\n",
    "min_std = 0.02 # minimum stand deviation of a group\n",
    "\n",
    "# Draw the predictions on the real data\n",
    "x_train, x_test, y_train, y_test = train_test_split_manual(X,y,test_size=0.3)\n",
    "predictions = decision_tree_regressor(list(zip(x_train, y_train)), \\\n",
    "                                      list(zip(x_test, y_test)), max_depth, min_size, criteria='mae', min_std=min_std)\n",
    "plt.scatter(x_test,predictions,c='r', marker='^')\n",
    "plt.plot(X,y);\n",
    "\n",
    "# evaluate algorithm\n",
    "scores = evaluate_algorithm(\n",
    "    list(zip(X,y)), decision_tree_regressor, n_folds, max_depth, min_size, 'std', min_std)\n",
    "print('Scores: %s' % scores)\n",
    "print('Root Mean Square Error: %.3f' % (sum(scores)/float(len(scores))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pronton/dev/python/ml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:3440: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/home/pronton/dev/python/ml/lib/python3.8/site-packages/numpy/core/_methods.py:189: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores: [0.04225657384596856, 0.03350439829161732, 0.0327603421833757, 0.03036996941020966, 0.03923867907670033]\n",
      "Root Mean Square Error: 0.036\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "max_depth = 5  # maximum depth of tree\n",
    "min_size = 1   # minimum size of 1 group\n",
    "min_std = 0.02  # minimum stand deviation of a group\n",
    "\n",
    "# Draw the predictions on the real data\n",
    "x_train, x_test, y_train, y_test = train_test_split_manual(X,y,test_size=0.3)\n",
    "predictions = decision_tree_regressor(list(zip(x_train, y_train)), \\\n",
    "                                      list(zip(x_test, y_test)), max_depth, min_size, 'mae', min_std)\n",
    "plt.scatter(x_test,predictions,c='r', marker='^')\n",
    "plt.plot(X,y);\n",
    "\n",
    "# evaluate algorithm\n",
    "scores = evaluate_algorithm(\n",
    "    list(zip(X,y)), decision_tree_regressor, n_folds, max_depth, min_size, 'std', min_std)\n",
    "print('Scores: %s' % scores)\n",
    "print('Root Mean Square Error: %.3f' % (sum(scores)/float(len(scores))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "Version 0.1:\n",
    "* RMSE:\n",
    "    - 0.017 data/BankNote_Authentication.csv (**std**)\n",
    "    - 0.018 data/BankNote_Authentication.csv (**mae**)\n",
    "    - 0.232 data/sonar.csv (**std**)\n",
    "    - 0.275 data/sonar.csv (**mae**)\n",
    "    - 0.002 sine data (**max_depth** = 20, **std**)\n",
    "    - 0.031 sine data (**max_depth** = 5, **std**)\n",
    "\n",
    "`Note`: The idea of decision tree regressor is similar to that of decision tree classifier. The small change in code is that instead of use **entropy/gini_index** to find the best split in classifier version, this one use **std/mae**.\n",
    "\n",
    "Version 0.2: 11/10/2021\n",
    "* Add THRESHOLD **min_std** on each node in split policy to reduce overfitting (`prepruning` method) \n",
    "* When setting **min_std** be positive, the RMSE always give a little worse than the version 0.1 (no prepruning). It may be becasue the **min_std** is hard to tune and highly based on the experience. So, the best way and most boring way is to use `k-fold cross validation` to all possible **min_std**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Refs\n",
    "https://machinelearningmastery.com/implement-decision-tree-algorithm-scratch-python/\n",
    "\n",
    "ZWMiller /machine_learning_from_scratch has a large library about \"ML from scratch\". This is one of his notebook about decision tree regressor:\n",
    "\n",
    "https://github.com/ZWMiller/machine_learning_from_scratch/blob/master/notebooks/regressors/decision_tree_regressor.ipynb"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "28f96ec01d3331ab2b5d4a1bb32d02e762004829634cea2cd2eeaefdb8bb653c"
  },
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}