ML_Algorithms_Decision_Tree.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Followb1ind1y/Machine_Learning_Algorithms_from_Scratch/blob/main/ML_Algorithms_Decision_Tree.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6NwsInh6N_Wb"
      },
      "source": [
        "# **Machine Learning Algorithms: Decision Tree**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z5FYgIx0Of2O"
      },
      "source": [
        "## **Decision Tree Basics**\n",
        "\n",
        "A **Decision Tree** is a non-parametric **supervised learning** algorithm. A tree has many analogies in real life, and turns out that it has influenced a wide area of machine learning, covering both **classification and regression**. Decision tree learning employs a **divide and conquer strategy** by conducting a **greedy search** to identify the optimal split points within a tree. This process of splitting is then repeated in a top-down, recursive manner until all, or the majority of records have been classified under specific class labels.\n",
        "\n",
        "**Decision Tree consists of:**\n",
        "\n",
        "* **Nodes :** Test for the value of a certain attribute.\n",
        "* **Edges/ Branch :** Correspond to the outcome of a test and connect to the next node or leaf.\n",
        "* **Leaf nodes :** Terminal nodes that predict the outcome (represent class labels or class distribution)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BjRA2XPGh7FF"
      },
      "source": [
        "## **Splitting Criteria**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hNnAP5bohXJo"
      },
      "source": [
        "### **Reduction in Variance**\n",
        "\n",
        "**Reduction in Variance** is a method for splitting the node used when the target variable is **continuous**, i.e., **regression problems**. It is so-called because it uses variance as a measure for deciding the feature on which node is split into child nodes.\n",
        "\n",
        "$$\\mathrm{Variance} = \\frac{\\sum(X-\\mu)^{2}}{N}$$\n",
        "\n",
        "Variance is used for calculating the homogeneity of a node. If a node is entirely homogeneous, then the variance is zero."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ucfe5kYBdXtF"
      },
      "source": [
        "### **Sum of Squared Error (SSE)**\n",
        "\n",
        "The **Sum of Squared Error** is the most widely used splitting metric for **regression**. Suppose you want to divide the data set $S$ into two groups of $S_{1}$ and $S_{2}$, where the selection of $S_{1}$ and $S_{2}$ needs to minimize the sum of squared errors:\n",
        "\n",
        "$$\\mathrm{SSE} = \\sum_{i \\in S_{1}}(y_{i}-ȳ_{1})^{2}+\\sum_{i \\in S_{2}}(y_{i}-ȳ_{2})^{2}$$\n",
        "\n",
        "The way regression tree grows is to automatically decide on the splitting variables and split points that can **maximize SSE reduction**. Since this process is essentially a recursive segmentation, this approach is also called **recursive partitioning**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YDshRQDgaCRk"
      },
      "source": [
        "### **Information Gain (IG)**\n",
        "\n",
        "**Information Gain** is used for splitting the nodes when the target variable is categorical. It works on the concept of the entropy and is given by:\n",
        "\n",
        "$$\\mathrm{Information \\ Gain} = 1 - \\mathrm{Entroy}$$\n",
        "\n",
        "where $\\mathrm{Entropy}$ is a measure of the degree of disorder which is defined as:\n",
        "\n",
        "$$\\mathrm{Entroy} = -\\sum_{i}^{n}p_{i}\\log_{2}p_{i}$$\n",
        "\n",
        "$p_{i}$ is the probability of class $i$ and the interval of entropy is $[0,1]$. For a two-class problem:\n",
        "\n",
        "$$\\mathrm{Entroy} = -p\\log_{2}p-(1-p)\\log_{2}(1-p)$$\n",
        "\n",
        "**Lower the value of entropy, higher is the purity of the node**. The entropy of a homogeneous node is zero. Since we subtract entropy from 1, the **Information Gain is higher for the purer nodes** with a maximum value of 1."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R61bs8WLQFQs"
      },
      "source": [
        "### **Gini Impurity**\n",
        "\n",
        "**Gini Impurity** is a measure of non-homogeneity. It is widely used in classification tree. **Gini** is the probability of correctly labeling a randomly chosen element if it was randomly labeled according to the distribution of labels in the node. The formula for Gini is:\n",
        "\n",
        "$$\\mathrm{Gini} = \\sum_{i}p_{i}^{2}$$\n",
        "\n",
        "\n",
        "And **Gini Impurity** is defined as:\n",
        "\n",
        "$$\\mathrm{Gini \\ Impurity}(D) = 1 - \\mathrm{Gini} = 1 - \\sum_{i}p_{i}^{2} = \\sum_{i}p_{i}(1-p_{i})$$\n",
        "\n",
        "where $p_{i}$ is the probability of class $i$ and the interval of Gini is $[0,0.5]$. For a two-class problem, the Gini impurity for a given node is:\n",
        "\n",
        "$$p_{1}(1-p_{1}) + p_{2}(1-p_{2})$$\n",
        "\n",
        "It is easy to see that when the sample set is **pure**, one of the probability is 0 and the Gini score is the **smallest**. Conversely, when $p_{1} = p_{2} = 0.5$ the Gini score is the **largest**, in which case the purity of the node is the smallest."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gwToOqrFvKVt"
      },
      "source": [
        "## **Steps in Decision Tree Algorithm**\n",
        "\n",
        "1. Begins with the original set $S$ as the root node.\n",
        "2. On each iteration of the algorithm, it iterates through the attributes of the set $S$ and calculates **Gini Impurity** of all the attributes.\n",
        "3. Choose the split that generates the smallest Gini Impurity among all the attributes as a split. \n",
        "4. The set $S$ is then split by the selected attribute to produce a subset of the data.\n",
        "5. The algorithm continues recurring on each subset, repeat the process until at least one of the conditions set by hyperparameters of the algorithm is not fulfilled or the subset is pure."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OHpBB2bvftR5"
      },
      "source": [
        "## **Tree Pruning**\n",
        "\n",
        "**Pruning** is the process that reduces the size of decision trees. It **reduces the risk of overfitting** by limiting the size of the tree or removing sections of the tree that provide little power.\n",
        "\n",
        "### **Limit the Size**\n",
        "We can limit the tree size by setting some parameters.\n",
        "\n",
        "* **Minimum sample size at each node**: Defining the minimum sample size at the node helps to prevent the leaf nodes having only one sample.\n",
        "* **Maximum depth of the tree**: If the tree grows too deep, the model tends to over-fit.\n",
        "* **Maximum number of terminal nodes**: Limit on the terminal nodes works the same as the limit on the depth of the tree.\n",
        "* **The number of variables considered for each split**: the algorithm randomly selects variables used in finding the optimal split point at each level. In general, the square root of the number of all variables works best, which is also the default setting for many functions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V3YSXv8xgjhD"
      },
      "source": [
        "### **Remove Branches**\n",
        "\n",
        "Another way is to first let the tree grow **as much as possible** and then go back to remove insignificant branches. The process reduces the depth of the tree. The idea is to overfit the training set and then correct using cross-validation.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4JYZOiz3nV2T"
      },
      "source": [
        "**Cost/Complexity Penalty**\n",
        "\n",
        "In regression case, the idea is that the pruning minimizes the penalized error $\\mathrm{SSE}_{\\alpha}$ with a certain value of tuning parameter $\\alpha$.\n",
        "\n",
        "$$\\mathrm{SSE}_{\\alpha} = \\mathrm{SSE} + \\alpha \\cdot \\mathrm{complexity}$$\n",
        "\n",
        "Here complexity is a function of the number of leaves. For every given $\\alpha$, we want to find the tree that minimizes this penalized error."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sx6ydBMaaOj7"
      },
      "source": [
        "## **Dataset Initialization**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "S7sLHWUbOC83"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn import metrics\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "p5RO6IqdaR0u"
      },
      "outputs": [],
      "source": [
        "np.random.seed(0)\n",
        "\n",
        "# radius of the circle\n",
        "circle_r = 1\n",
        "\n",
        "# center of the circle (x, y)\n",
        "circle_x_1, circle_y_1 = 2, 3\n",
        "circle_x_2, circle_y_2 = 3, 1.5\n",
        "circle_x_3, circle_y_3 = 5, 2\n",
        "\n",
        "# random angle\n",
        "alpha_1 = 2 * np.math.pi * np.random.rand(50, 1) \n",
        "alpha_2 = 2 * np.math.pi * np.random.rand(50, 1) \n",
        "alpha_3 = 2 * np.math.pi * np.random.rand(50, 1) \n",
        "\n",
        "# random radius\n",
        "r_1 = circle_r * np.sqrt(np.random.rand(50, 1))\n",
        "r_2 = circle_r * np.sqrt(np.random.rand(50, 1))\n",
        "r_3 = circle_r * np.sqrt(np.random.rand(50, 1))\n",
        "\n",
        "# calculating coordinates\n",
        "x_1, y_1 = r_1 * np.cos(alpha_1) + circle_x_1, r_1 * np.sin(alpha_1) + circle_y_1\n",
        "x_2, y_2 = r_2 * np.cos(alpha_2) + circle_x_2, r_2 * np.sin(alpha_2) + circle_y_2\n",
        "x_3, y_3 = r_3 * np.cos(alpha_3) + circle_x_3, r_3 * np.sin(alpha_3) + circle_y_3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "FFcE_GVxaWPH"
      },
      "outputs": [],
      "source": [
        "class_1, class_2, class_3 = np.concatenate((x_1, y_1), axis=1), np.concatenate((x_2, y_2), axis=1), np.concatenate((x_3, y_3), axis=1)\n",
        "zeros, ones, twos = np.zeros((50,1)), np.ones((50,1)), np.ones((50,1))*2\n",
        "x = np.concatenate((class_1, class_2, class_3), axis=0)\n",
        "y = np.concatenate((zeros, ones, twos), axis=0).ravel()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 313
        },
        "id": "ONy-_avgaXvi",
        "outputId": "68a33445-66c0-4a30-ba25-0328b464d15b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Y')"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "fig, ax = plt.subplots() \n",
        "ax.scatter(x[:,0][y==0], x[:,1][y==0], c='r')\n",
        "ax.scatter(x[:,0][y==1], x[:,1][y==1], c='b')\n",
        "ax.scatter(x[:,0][y==2], x[:,1][y==2], c='g')\n",
        "ax.set_title('Random Data for Decision Tree')\n",
        "ax.set_xlabel('X') \n",
        "ax.set_ylabel('Y')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "IwY6anxvbbY3"
      },
      "outputs": [],
      "source": [
        "x_train, x_test, y_train, y_test = train_test_split(x, y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ApTmOSuNjRso"
      },
      "source": [
        "## **Implementing Decision Tree from scratch**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "d7zpIl65o1A5"
      },
      "outputs": [],
      "source": [
        "class Node:\n",
        "    def __init__(self, gini_index, samples, samples_in_classes, predicted_class):\n",
        "        self.gini_index = gini_index\n",
        "        self.samples = samples\n",
        "        self.samples_in_classes = samples_in_classes\n",
        "        self.predicted_class = predicted_class\n",
        "        self.feature_index = 0\n",
        "        self.threshold = 0\n",
        "        self.left = None\n",
        "        self.right = None"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "EYHgG979jXJ_"
      },
      "outputs": [],
      "source": [
        "class DecisionTree:\n",
        "    def __init__(self, max_depth=5):\n",
        "        self.max_depth = max_depth\n",
        "    \n",
        "    def fit(self, x, y):\n",
        "        self.classes = len(set(y))\n",
        "        self.features = x.shape[1]\n",
        "        self.tree = self.grow_tree(x, y)\n",
        "    \n",
        "    def gini_function(self, y):\n",
        "        m = y.shape[0]\n",
        "        return 1 - sum((np.sum(y == c) / m)**2 for c in range(self.classes))\n",
        "    \n",
        "    def grow_tree(self, x, y, curr_depth=0):\n",
        "        samples_in_classes = [np.sum(y == i) for i in range(self.classes)]\n",
        "        predicted_class = np.argmax(samples_in_classes)\n",
        "        node = Node(\n",
        "            gini_index=self.gini_function(y),\n",
        "            samples=y.shape[0],\n",
        "            samples_in_classes=samples_in_classes,\n",
        "            predicted_class=predicted_class\n",
        "            )\n",
        "        \n",
        "        if curr_depth < self.max_depth:\n",
        "            idx, thr = self.best_split(x, y)\n",
        "            if idx is not None:\n",
        "                indices_left = x[:, idx] < thr\n",
        "                x_left, y_left = x[indices_left], y[indices_left]\n",
        "                x_right, y_right = x[~indices_left], y[~indices_left]\n",
        "                node.feature_index = idx\n",
        "                node.threshold = thr\n",
        "                node.left = self.grow_tree(x_left, y_left, curr_depth + 1)\n",
        "                node.right = self.grow_tree(x_right, y_right, curr_depth + 1)\n",
        "\n",
        "        return node\n",
        "    \n",
        "    def best_split(self, x, y):\n",
        "        m = y.shape[0]\n",
        "        if m <= 1:\n",
        "            return None, None\n",
        "\n",
        "        best_gini = self.gini_function(y)\n",
        "        best_idx, best_thr = None, None\n",
        "\n",
        "        for idx in range(self.features):\n",
        "            thresholds, classes = zip(*sorted(zip(x[:, idx], y)))\n",
        "            num_left = [0] * self.classes\n",
        "            num_right = [np.sum(y == c) for c in range(self.classes)]\n",
        "\n",
        "            for i in range(1, m): \n",
        "                c = int(classes[i - 1])\n",
        "                num_left[c] += 1\n",
        "                num_right[c] -= 1\n",
        "                gini_left = 1 - sum((num_left[x] / i) ** 2 for x in range(self.classes))\n",
        "                gini_right = 1 - sum((num_right[x] / (m - i)) ** 2 for x in range(self.classes))\n",
        "                gini = (i * gini_left + (m - i) * gini_right) / m\n",
        "\n",
        "                if gini < best_gini:\n",
        "                    best_gini = gini\n",
        "                    best_idx = idx\n",
        "                    best_thr = (thresholds[i] + thresholds[i - 1]) / 2  \n",
        "        \n",
        "        return best_idx, best_thr\n",
        "\n",
        "    def predict(self, x):\n",
        "        return np.array([self.predict_input(inputs) for inputs in x])\n",
        "\n",
        "    def predict_input(self, x):\n",
        "        node = self.tree\n",
        "        while(node.left):\n",
        "            if x[node.feature_index] < node.threshold:\n",
        "                node = node.left\n",
        "            else:\n",
        "                node = node.right\n",
        "        return node.predicted_class"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "ayFLVhoL0DBg"
      },
      "outputs": [],
      "source": [
        "decision_tree = DecisionTree(max_depth=5)\n",
        "decision_tree.fit(x_train, y_train)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K-Pl0kn4070j",
        "outputId": "7e336909-de7e-44b8-c2a9-42ea6168f911"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y_pred = decision_tree.predict(x_test)\n",
        "accuracy = metrics.accuracy_score(y_test, y_pred)\n",
        "accuracy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "Eu9RjhBL9Ad7"
      },
      "outputs": [],
      "source": [
        "def print_tree(tree, index):\n",
        "    if(tree):\n",
        "        print(\"Depth:\", index, \"Samples:\", tree.samples, \"Gini:\", tree.gini_index, \n",
        "              \"Feature:\", tree.feature_index,\"Threshold:\", tree.threshold, \"Values:\", tree.samples_in_classes)\n",
        "        print_tree(tree.left, index+1)\n",
        "        print_tree(tree.right, index+1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "asoDkKX5-tdI",
        "outputId": "7146ca13-3372-4103-8465-f9eaf3e6a191"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Depth: 1 Samples: 112 Gini: 0.6662946428571428 Feature: 0 Threshold: 4.005242242727981 Values: [37, 39, 36]\n",
            "Depth: 2 Samples: 76 Gini: 0.4996537396121883 Feature: 1 Threshold: 2.459253885679738 Values: [37, 39, 0]\n",
            "Depth: 3 Samples: 44 Gini: 0.20144628099173545 Feature: 0 Threshold: 2.221649034534265 Values: [5, 39, 0]\n",
            "Depth: 4 Samples: 6 Gini: 0.2777777777777777 Feature: 1 Threshold: 1.9208774194151845 Values: [5, 1, 0]\n",
            "Depth: 5 Samples: 1 Gini: 0.0 Feature: 0 Threshold: 0 Values: [0, 1, 0]\n",
            "Depth: 5 Samples: 5 Gini: 0.0 Feature: 0 Threshold: 0 Values: [5, 0, 0]\n",
            "Depth: 4 Samples: 38 Gini: 0.0 Feature: 0 Threshold: 0 Values: [0, 38, 0]\n",
            "Depth: 3 Samples: 32 Gini: 0.0 Feature: 0 Threshold: 0 Values: [32, 0, 0]\n",
            "Depth: 2 Samples: 36 Gini: 0.0 Feature: 0 Threshold: 0 Values: [0, 0, 36]\n"
          ]
        }
      ],
      "source": [
        "print_tree(decision_tree.tree, 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "oyZbEr9kXHJS"
      },
      "outputs": [],
      "source": [
        "def visualize_classifier(model, X, y, ax=None, cmap='rainbow'):\n",
        "    ax = ax or plt.gca()\n",
        "\n",
        "    ax.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=cmap,\n",
        "               clim=(y.min(), y.max()), zorder=3)\n",
        "    ax.axis('tight')\n",
        "    ax.axis('off')\n",
        "    xlim = ax.get_xlim()\n",
        "    ylim = ax.get_ylim()\n",
        "\n",
        "    model.fit(X, y)\n",
        "    xx, yy = np.meshgrid(np.linspace(*xlim, num=200),\n",
        "                         np.linspace(*ylim, num=200))\n",
        "    Z = model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
        "\n",
        "    n_classes = len(np.unique(y))\n",
        "    contours = ax.contourf(xx, yy, Z, alpha=0.3,levels=np.arange(n_classes + 1) - 0.5,\n",
        "                           cmap=cmap, zorder=1)\n",
        "\n",
        "    ax.set(xlim=xlim, ylim=ylim)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "id": "hqyGPU0yWhMO",
        "outputId": "6f057fbd-8db7-4372-f54a-769ea5ca5912"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "visualize_classifier(DecisionTree(max_depth=5), x, y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NJ49Cv_Va_qI"
      },
      "source": [
        "## **Implementing Decision Tree from sklearn**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PRjckpn0do5T"
      },
      "source": [
        "### **Classification Case**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "PUB_axHTabWy"
      },
      "outputs": [],
      "source": [
        "from sklearn import tree"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XQp6NnoTblo0",
        "outputId": "42cfbaf8-c2c9-48a3-bc1e-a4f93a3878a5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "execution_count": 31,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "clf = tree.DecisionTreeClassifier()\n",
        "clf = clf.fit(x_train, y_train)\n",
        "y_pred = clf.predict(x_test)\n",
        "accuracy = metrics.accuracy_score(y_test, y_pred)\n",
        "accuracy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 409
        },
        "id": "WvW20MSub_hD",
        "outputId": "9805d49b-cdb6-440e-bb22-d438caa3a086"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[Text(0.7142857142857143, 0.9, 'X[0] <= 4.005\\ngini = 0.666\\nsamples = 112\\nvalue = [37, 39, 36]'),\n",
              " Text(0.5714285714285714, 0.7, 'X[1] <= 2.459\\ngini = 0.5\\nsamples = 76\\nvalue = [37, 39, 0]'),\n",
              " Text(0.42857142857142855, 0.5, 'X[0] <= 2.222\\ngini = 0.201\\nsamples = 44\\nvalue = [5, 39, 0]'),\n",
              " Text(0.2857142857142857, 0.3, 'X[1] <= 1.921\\ngini = 0.278\\nsamples = 6\\nvalue = [5, 1, 0]'),\n",
              " Text(0.14285714285714285, 0.1, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1, 0]'),\n",
              " Text(0.42857142857142855, 0.1, 'gini = 0.0\\nsamples = 5\\nvalue = [5, 0, 0]'),\n",
              " Text(0.5714285714285714, 0.3, 'gini = 0.0\\nsamples = 38\\nvalue = [0, 38, 0]'),\n",
              " Text(0.7142857142857143, 0.5, 'gini = 0.0\\nsamples = 32\\nvalue = [32, 0, 0]'),\n",
              " Text(0.8571428571428571, 0.7, 'gini = 0.0\\nsamples = 36\\nvalue = [0, 0, 36]')]"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "tree.plot_tree(clf)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "id": "7YUGZV9qWt7_",
        "outputId": "b6fe52d6-80bd-4d18-8703-efbc24271f9f"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "visualize_classifier(tree.DecisionTreeClassifier(), x, y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a6faRKTQdyn1"
      },
      "source": [
        "### **Regression Case**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "Ve8Pw_jTcP2h"
      },
      "outputs": [],
      "source": [
        "from sklearn.tree import DecisionTreeRegressor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "Flg8E3tvd8kE"
      },
      "outputs": [],
      "source": [
        "# Create a random dataset\n",
        "rng = np.random.RandomState(1)\n",
        "X = np.sort(5 * rng.rand(80, 1), axis=0)\n",
        "y = np.sin(X).ravel()\n",
        "y[::5] += 3 * (0.5 - rng.rand(16))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "EN5BWtSteYoe"
      },
      "outputs": [],
      "source": [
        "# Fit regression model\n",
        "regr_1 = DecisionTreeRegressor(max_depth=2)\n",
        "regr_2 = DecisionTreeRegressor(max_depth=5)\n",
        "regr_1.fit(X, y)\n",
        "regr_2.fit(X, y)\n",
        "\n",
        "# Predict\n",
        "X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]\n",
        "y_1 = regr_1.predict(X_test)\n",
        "y_2 = regr_2.predict(X_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "mkD6uJQae_Fg",
        "outputId": "96f00642-cfa7-4532-8267-f989012cee56"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot the results\n",
        "plt.figure()\n",
        "plt.scatter(X, y, s=20, edgecolor=\"black\", c=\"darkorange\", label=\"data\")\n",
        "plt.plot(X_test, y_1, color=\"cornflowerblue\", label=\"max_depth=2\", linewidth=2)\n",
        "plt.plot(X_test, y_2, color=\"yellowgreen\", label=\"max_depth=5\", linewidth=2)\n",
        "plt.xlabel(\"data\")\n",
        "plt.ylabel(\"target\")\n",
        "plt.title(\"Decision Tree Regression\")\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## **Reference**\n",
        "\n",
        "*  Jauregui, A. F. (2022, August 19). How to code decision tree in python from scratch. Ander Fernández. Retrieved January 23, 2023, from `https://anderfernandez.com/en/blog/code-decision-tree-python-from-scratch/` \n",
        "\n",
        "* Joachimvalente. (n.d.). Joachimvalente/decision-tree-CART: Simple implementation of CART algorithm to train decision trees. GitHub. Retrieved January 23, 2023, from `https://github.com/joachimvalente/decision-tree-cart` "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5JzQ9NWDfC8L",
        "outputId": "e87b32db-68de-476b-e8ac-a683603d789f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[NbConvertApp] Converting notebook ML_Algorithms_Decision_Tree.ipynb to html\n",
            "[NbConvertApp] Writing 461354 bytes to ML_Algorithms_Decision_Tree.html\n"
          ]
        },
        {
          "data": {
            "text/plain": []
          },
          "execution_count": 38,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "%%shell\n",
        "jupyter nbconvert --to html ML_Algorithms_Decision_Tree.ipynb"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "authorship_tag": "ABX9TyPFhMpU/d+2Tnf6VWFPdmjS",
      "include_colab_link": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.8.2 (default, Dec 21 2020, 15:06:04) \n[Clang 12.0.0 (clang-1200.0.32.29)]"
    },
    "vscode": {
      "interpreter": {
        "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}