ppcic_ml_dtree.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ppcic_ml_dtree.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyOPxRNoEL4BamDHtjPSV3xU",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MLRG-CEFET-RJ/ml-class/blob/master/ppcic_ml_dtree.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P7wxsdSSCDKg",
        "colab_type": "text"
      },
      "source": [
        "# Introduction\n",
        "\n",
        "A decision tree is a predictive model that takes an example $\\mathbf{x}$ as described by a set of predictive features and their respective values, and returns a predicted value for the target feature.\n",
        "\n",
        "A decision tree can be built in the context of classification and regression tasks, as we shall see bellow."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Gd5SmUxiLdU",
        "colab_type": "text"
      },
      "source": [
        "# Decision trees for classification\n",
        "\n",
        "The following example ([source](https://en.wikipedia.org/wiki/Decision_tree_learning)) presents a decision tree that models the possibility of passengers surviving on the [Titanic disaster](https://www.kaggle.com/c/titanic). The feature \"sipsb\" corresponds to the number of spouses or brothers on board. The other predictive features are self-explanatory. The numbers under the leafs show the probability of survival and the percentage of examples on the corresponding leaf.\n",
        "\n",
        "![alt text](https://upload.wikimedia.org/wikipedia/commons/f/f3/CART_tree_titanic_survivors.png)\n",
        "\n",
        "A decision tree has several *nodes*, both internal and external. The latter type is also called a leaf. Each internal node is associated to a predicate involving one of the predictive features. Each leaf is associated to a single value of the target feature. In the tree given as example above, there are three internal nodes (for features `sex`, `age` and `sibsp`) and four external nodes. \n",
        "\n",
        "A decision tree is a classification model that determines the class for an new example by executing a test sequence.\n",
        "\n",
        "* Each internal node in the tree corresponds to a test on the value of one of the attributes.\n",
        "\n",
        "* Branches from each internal node are identified (labeled) with the possible values ​​of the test.\n",
        "\n",
        "* Each leaf node specifies the value to be returned if that leaf is reached.\n",
        "\n",
        "Decision trees are known for their ease of interpretation. In the example above, we can interpret that the chances of survival were greater for (i) a woman or (ii) a man under 9.5 years old and less than 2.5 siblings (or spouses)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eHHOoObuIShv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 475
        },
        "outputId": "aca45e85-10df-4bcb-ba3c-df8924497e6e"
      },
      "source": [
        "import pandas as pd\n",
        "df_titanic = pd.read_csv('https://raw.githubusercontent.com/MLRG-CEFET-RJ/ml-class/master/datasets/titanic_train.csv')\n",
        "df_titanic.head()"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "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>PassengerId</th>\n",
              "      <th>Survived</th>\n",
              "      <th>Pclass</th>\n",
              "      <th>Name</th>\n",
              "      <th>Sex</th>\n",
              "      <th>Age</th>\n",
              "      <th>SibSp</th>\n",
              "      <th>Parch</th>\n",
              "      <th>Ticket</th>\n",
              "      <th>Fare</th>\n",
              "      <th>Cabin</th>\n",
              "      <th>Embarked</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>Braund, Mr. Owen Harris</td>\n",
              "      <td>male</td>\n",
              "      <td>22.0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>A/5 21171</td>\n",
              "      <td>7.2500</td>\n",
              "      <td>NaN</td>\n",
              "      <td>S</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>2</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>Cumings, Mrs. John Bradley (Florence Briggs Th...</td>\n",
              "      <td>female</td>\n",
              "      <td>38.0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>PC 17599</td>\n",
              "      <td>71.2833</td>\n",
              "      <td>C85</td>\n",
              "      <td>C</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>3</td>\n",
              "      <td>1</td>\n",
              "      <td>3</td>\n",
              "      <td>Heikkinen, Miss. Laina</td>\n",
              "      <td>female</td>\n",
              "      <td>26.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>STON/O2. 3101282</td>\n",
              "      <td>7.9250</td>\n",
              "      <td>NaN</td>\n",
              "      <td>S</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>Futrelle, Mrs. Jacques Heath (Lily May Peel)</td>\n",
              "      <td>female</td>\n",
              "      <td>35.0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>113803</td>\n",
              "      <td>53.1000</td>\n",
              "      <td>C123</td>\n",
              "      <td>S</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>5</td>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>Allen, Mr. William Henry</td>\n",
              "      <td>male</td>\n",
              "      <td>35.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>373450</td>\n",
              "      <td>8.0500</td>\n",
              "      <td>NaN</td>\n",
              "      <td>S</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked\n",
              "0            1         0       3  ...   7.2500   NaN         S\n",
              "1            2         1       1  ...  71.2833   C85         C\n",
              "2            3         1       3  ...   7.9250   NaN         S\n",
              "3            4         1       1  ...  53.1000  C123         S\n",
              "4            5         0       3  ...   8.0500   NaN         S\n",
              "\n",
              "[5 rows x 12 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lU5RfcusO83V",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "df_titanic = df_titanic[['Sex', 'Age', 'SibSp', 'Survived', 'Pclass']]"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D7S6s8iHPVVd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 225
        },
        "outputId": "82f3080e-12db-435e-be32-ba676a5bca31"
      },
      "source": [
        "df_titanic.info()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 891 entries, 0 to 890\n",
            "Data columns (total 5 columns):\n",
            " #   Column    Non-Null Count  Dtype  \n",
            "---  ------    --------------  -----  \n",
            " 0   Sex       891 non-null    object \n",
            " 1   Age       714 non-null    float64\n",
            " 2   SibSp     891 non-null    int64  \n",
            " 3   Survived  891 non-null    int64  \n",
            " 4   Pclass    891 non-null    int64  \n",
            "dtypes: float64(1), int64(3), object(1)\n",
            "memory usage: 34.9+ KB\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BBgFASI2PrfD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 225
        },
        "outputId": "591ab122-4d53-4229-bbfa-b582d397cec4"
      },
      "source": [
        "df_titanic.replace({'Sex': {'male': 0, 'female': 1}}, inplace=True)\n",
        "df_titanic.fillna(df_titanic.mean(), inplace=True)\n",
        "df_titanic.info()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 891 entries, 0 to 890\n",
            "Data columns (total 5 columns):\n",
            " #   Column    Non-Null Count  Dtype  \n",
            "---  ------    --------------  -----  \n",
            " 0   Sex       891 non-null    int64  \n",
            " 1   Age       891 non-null    float64\n",
            " 2   SibSp     891 non-null    int64  \n",
            " 3   Survived  891 non-null    int64  \n",
            " 4   Pclass    891 non-null    int64  \n",
            "dtypes: float64(1), int64(4)\n",
            "memory usage: 34.9 KB\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CKOveNxjXrwY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 348
        },
        "outputId": "ee399d8b-e864-4bd1-cef3-1c7a16b76bca"
      },
      "source": [
        "df_titanic.head(10)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Sex</th>\n",
              "      <th>Age</th>\n",
              "      <th>SibSp</th>\n",
              "      <th>Survived</th>\n",
              "      <th>Pclass</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>22.000000</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>38.000000</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>26.000000</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "      <td>35.000000</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>35.000000</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>0</td>\n",
              "      <td>29.699118</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>0</td>\n",
              "      <td>54.000000</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>0</td>\n",
              "      <td>2.000000</td>\n",
              "      <td>3</td>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>1</td>\n",
              "      <td>27.000000</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>1</td>\n",
              "      <td>14.000000</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   Sex        Age  SibSp  Survived  Pclass\n",
              "0    0  22.000000      1         0       3\n",
              "1    1  38.000000      1         1       1\n",
              "2    1  26.000000      0         1       3\n",
              "3    1  35.000000      1         1       1\n",
              "4    0  35.000000      0         0       3\n",
              "5    0  29.699118      0         0       3\n",
              "6    0  54.000000      0         0       1\n",
              "7    0   2.000000      3         0       3\n",
              "8    1  27.000000      0         1       3\n",
              "9    1  14.000000      1         1       2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SjuNrHZpXy4k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X = df_titanic.drop(columns=['Survived'])\n",
        "y = df_titanic['Survived']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S2R5bnhLir91",
        "colab_type": "text"
      },
      "source": [
        "## Steps of the algorithm\n",
        "\n",
        "The goal of a *decision tree learning algorithm* is to build a decision tree. The basic decision tree learning algorithm consists of the following steps:\n",
        "\n",
        "1. Start at the root node as the parent node;\n",
        "2. Split the parent node using the attribute that minimizes the sum of impurities in the child nodes (or maximizes the *information gain*);\n",
        "3. Assign training samples to new child nodes;\n",
        "4. Stop if the resulting nodes are pure or if any stopping criteria are met; repeat steps 1 and 2 for each new child node.\n",
        "\n",
        "The following animation ([source](https://annalyzin.wordpress.com/2016/07/27/decision-trees-tutorial/)) illustrates the recursive procedure performed by the decision tree learning algorithm. Here, consider a dataset with fourteen examples, 6 positive and nine negative. Also consider that each example has two features (represented in the animation as X and Y) with range of values betweent 0 and 1. The animation shows that the building process starts with a tree with just one node (its root node) which is associated to the feature X. Notice that the predicate $X>0.5$ splits the original examples in two disjoint sets. Also notice that the examples associated to the the value Yes for the predicate are all negative. These examples are associated to a leaf node. On the other hand, the second set has 6 positive and 3 negative examples. As exists impurity in this set, the corresponding node has to be split. This process of node spliting continues until some *stopping criteria* is met. At the end of this process, a decision tree is built.\n",
        "\n",
        "![alt text](https://annalyzin.files.wordpress.com/2016/07/decision-tree-tutorial-animated3.gif?w=620)\n",
        "\n",
        "\n",
        "There are several possible stopping criteria:\n",
        "* Leaf nodes are pure\n",
        "* Maximum node depth is reached\n",
        "* Dividing a node does not lead to an *information gain*.\n",
        "\n",
        "From the above example, it should be clear that there should exist a way for the decision tree algorithm to select the best attribute to use when a node split is necessary. We call this the *attribute selection criteria*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ztHPmsoi_B5",
        "colab_type": "text"
      },
      "source": [
        "## Attribute selection criteria\n",
        "\n",
        "The decision tree learning algorithm is recursive. During the construction of the model (i.e., the decision tree), the choice of features should be made in such a way as to minimize the depth of the decision tree. At each step, the algorithm chooses the feature that goes as far as possible in the exact classification of the examples.\n",
        "\n",
        "A perfect feature would divide the examples into subsets of the same class (i.e., all positive or all negative). To choose a suitable feature for a new internal node in the tree, the solution is to measure each feature according to the expected amount of information provided by it.\n",
        "\n",
        "There are two most commonly used criteria for feature selection when learning a decision tree:\n",
        "\n",
        "* information gain\n",
        "* gini index"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6AloWTjQjV4E",
        "colab_type": "text"
      },
      "source": [
        "### Information Gain\n",
        "\n",
        "The information gain is based on a measure from [Information Theory](en.wikipedia.org/wiki/Information_theory) called *entropy*.\n",
        "\n",
        "Given a probability distribution for a discrete random variable $V$ with $n$ values, if each possible value $v_i$ of $V$ has probability $p_i$, then the entropy $H$ of that random variable is given by:\n",
        "\n",
        "$$\n",
        "H(V) = -\\sum_{v_i \\in V} p_i \\log_2 p_i\n",
        "$$\n",
        "\n",
        "The following code cell plot the graph of the entropy function for a random variable that can assume only two values, with corresponding probabilities equal to $p_1 = p$ and $p_2 = 1-p$. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cMXwK50yZS8g",
        "colab_type": "text"
      },
      "source": [
        "$$\n",
        "H(\\text{Sex}) = -(0.5 \\log_2 05 + 0.5 \\log_2 0.5)\n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JmVdQSPyaLu2",
        "colab_type": "text"
      },
      "source": [
        "$$\n",
        "H(\\text{Sex}) = -(0.9 \\log_2 0.9 + 0.1 \\log_2 0.1)\n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tmfnYmZQa1Bq",
        "colab_type": "text"
      },
      "source": [
        "$$\n",
        "H(\\text{Sex}) = -(1/6 \\log_2 1/6 + 1/6 \\log_2 1/6 + 1/6 \\log_2 1/6 + 1/6 \\log_2 1/6 + 1/6 \\log_2 1/6 + 1/6 \\log_2 1/6 + )\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CsKIXI7Ctrjk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 309
        },
        "outputId": "03edf6e8-5299-40b2-cfdf-d6f94e5cb844"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "def entropy(p):\n",
        "    return - p * np.log2(p) - (1 - p) * np.log2((1 - p))\n",
        "\n",
        "x = np.arange(0.0, 1.0, 0.01)\n",
        "\n",
        "ent = [entropy(p) if p != 0 else None for p in x]\n",
        "\n",
        "fig = plt.figure()\n",
        "ax = plt.subplot(111)\n",
        "for i, lab, ls, c, in zip([ent], \n",
        "                          ['Entropy'],\n",
        "                          ['-', '-', '--', '-.'],\n",
        "                          ['red', 'blue', 'black', 'green', 'cyan']):\n",
        "    line = ax.plot(x, i, label=lab, linestyle=ls, lw=2, color=c)\n",
        "\n",
        "ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.15),\n",
        "          ncol=5, fancybox=True, shadow=False)\n",
        "\n",
        "ax.axhline(y=0.5, linewidth=1, color='k', linestyle='--')\n",
        "ax.axhline(y=1.0, linewidth=1, color='k', linestyle='--')\n",
        "plt.ylim([0, 1.1])\n",
        "plt.xlabel('$p_1$')\n",
        "plt.ylabel('$H$')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f2QYpbCi13pa",
        "colab_type": "text"
      },
      "source": [
        "In the plot shown above, note that $H$ is maximum when the two values ​​are equally likely to occur (i.e., $p_1 = p_2 = 0.5$).\n",
        "\n",
        "To get some intuition about the concept of entropy, consider the following code cell, that shows other values generated by the $H$ in the case of a binary random variable. You are also encouraged to watch this nice and instructive [video](https://youtu.be/9r7FIXEAGvs) about the concept of entropy.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P2Gs61j2B8Zp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 86
        },
        "outputId": "1de75bfb-800b-48a1-ff2c-5661fc86eca5"
      },
      "source": [
        "print('H(0.5, 0.5): %.2f' % entropy(1/2))\n",
        "print('H(0.1, 0.9): %.2f' % entropy(0.1))\n",
        "print('H(0.01, 0.99): %.2f' % entropy(0.01))\n",
        "print('H(0.001, 0.999): %.2f' % entropy(0.001))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "H(0.5, 0.5): 1.00\n",
            "H(0.1, 0.9): 0.47\n",
            "H(0.01, 0.99): 0.08\n",
            "H(0.001, 0.999): 0.01\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f5s8bfZis4Tt",
        "colab_type": "text"
      },
      "source": [
        "Entropy can be used to measure the homogeneity of a dataset with respect to the values of the target attribute $T$ in a set of examples. If $T$ has the same value for all examples in the dataset, then its entropy is minimal. On the other hand, if the values ​​of $T$ occur uniformly, then its entropy is maximal.\n",
        "\n",
        "Consider a predictive attribute $A$ with $n$ values. Also, consider all the $n$ subsets $S_i$ generated by splitting an original set of examples $S$ according to the values of $A$. The entropy only computes the homogeneity of a single (sub-)set of examples. This raises the question of how we could compute the homogeneity of the entire split (i.e., considering all the values of $A$). The solution is to compute a weighted average of the entropies for each value. This way, if $T$ is the target attribute and $A$ is some predictive attribute, the weighted average entropy of $T$ considering the split generated by $A$ is computed using the expression bellow.\n",
        "\n",
        "$$\n",
        "H(T \\mid A) = \\sum_{v_i \\in A} \\frac{|S_i|}{|S|} H(T \\mid S_i) \n",
        "$$\n",
        "\n",
        "In the above expression:\n",
        "\n",
        "* $S_i$ is the set of examples with value $v_i$ for $A$;\n",
        "\n",
        "* $S = \\cup_i S_i$\n",
        "\n",
        "* $H(T \\mid S_i)$ is the entropy of $T$ in $S_i$.\n",
        "\n",
        "The Information Gain (IG) of some predictive attribute $A$ is the difference between the entropies for the target attribute $T$ as measured before and after spliting a dataset by the values ​​of $A$. \n",
        "\n",
        "$$\n",
        "IG(A) = H(T) - H(T \\mid A)\n",
        "$$\n",
        "\n",
        "The selection criterion based on information gain chooses the predictive attribute that produces the highest information gain among the available attributes. Notice that maximizing information gain $IG(A)$ is equivalent to minimizing average\n",
        "entropy $H(T \\mid A)$, because $H(T)$ is constant for all attributes $A$.\n",
        "\n",
        "As an example, consider the following toy dataset, which contains four predictive attributes: `Outlook`, `Temp`, `Humidity` and `Windy`. `PlayGolf` is the target.\n",
        "\n",
        "![alt text](https://miro.medium.com/max/661/0*DX1px-z340TgpXTN.png)\n",
        "\n",
        "If we split the above dataset by the values ​​of the attribute `Outlook`, the result is three other datasets, as shown in the following figure.\n",
        "\n",
        "![alt text](https://miro.medium.com/max/446/0*N01l6jqQtVXvsEyk.png)\n",
        "\n",
        "We can compute the entropy $H(\\text{PlayGolf})$ of the attribute `PlayGolf` in the original dataset. We can also compute $H(\\text{Playgolf} \\mid \\text{Outlook})$, the weighted average entropy for `PlayGolf` considering the three sets resulting from the split by the `Outlook` attribute. We can finally compute the informatio gain for `Outlook` attribute:\n",
        "\n",
        "$$\n",
        "IG(\\text{Outlook}) = H(\\text{Playgolf}) - H(\\text{Playgolf} \\mid \\text{Outlook})\n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uAqVjDz_e9R4",
        "colab_type": "text"
      },
      "source": [
        "Let us compute the value $IG(\\text{Outlook})$. For this, consider the following probability values.\n",
        "\n",
        "$$\n",
        "\\begin{aligned}\n",
        "\\Pr(\\text{Outlook} = Sunny) &= 5/14 \\\\\n",
        "\\Pr(\\text{Outlook} = Overcast) &= 4/14 \\\\\n",
        "\\Pr(\\text{Outlook} = Rainy) &= 5/14\n",
        "\\end{aligned}\n",
        "$$\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a7U81R28e8vR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "outputId": "50d43be4-caa4-4742-c043-bdc73443706a"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "entropy_playgolf = -(((9/14) * np.log2(9/14) + (5/14) * np.log2(5/14)))\n",
        "print('H(PlayGolf): %.3f' %  entropy_playgolf)\n",
        "\n",
        "entropy_playgolf_sunny = -(((3/5) * np.log2(3/5) + (2/5) * np.log2(2/5)))\n",
        "entropy_playgolf_overcast = 0 # all values of PlayGolf are 'yes'\n",
        "entropy_playgolf_rainy = -(((2/5) * np.log2(2/5)) + ((3/5) * np.log2(3/5)))\n",
        "\n",
        "entropy_playgolf_outlook = (5/14)*entropy_playgolf_sunny + (4/14)*entropy_playgolf_overcast + (5/14)*entropy_playgolf_rainy \n",
        "print('H(PlayGolf | Outlook): %.3f' % entropy_playgolf_outlookk)\n",
        "\n",
        "print('IG(Outlook): %.3f' % (entropy_playgolf - entropy_playgolf_outlook))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "H(PlayGolf): 0.940\n",
            "H(PlayGolf | Outlook): 0.694\n",
            "IG(Outlook): 0.247\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rY0-_Q39488P",
        "colab_type": "text"
      },
      "source": [
        "The information gain for the other predictive attibutes can be computed in a similar way. Hence, we have:\n",
        "\n",
        "* $IG(\\text{Outlook}) = H(\\text{PlayGolf}) - H(\\text{PlayGolf} \\mid \\text{Outlook}) = 0.247$\n",
        "\n",
        "* $IG(\\text{Temp}) = H(\\text{PlayGolf}) - H(\\text{PlayGolf} \\mid \\text{Temp}) = 0.029$\n",
        "\n",
        "* $IG(\\text{Humidity}) = H(\\text{PlayGolf}) - H(\\text{PlayGolf} \\mid \\text{Humidity}) = 0.152$\n",
        "\n",
        "* $IG(\\text{Windy}) = H(\\text{PlayGolf}) - H(\\text{PlayGolf} \\mid \\text{Windy}) = 0.048$\n",
        "\n",
        "Since the greater value for $IG$ is related to `Outlook`, according to the information gain criterion, this should be the selected attribute to further grow the tree. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Flo8JFPskHek",
        "colab_type": "text"
      },
      "source": [
        "In Scikit-Learn, the function [mutual_info_classif](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.mutual_info_classif.html) can be used to compute the information gain for a set of predictive attributes with relation to a target attribute, as shown in the following example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C21GAGd_ZDDO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "8302a2c4-cce2-4fb6-ae5d-938eb77c4802"
      },
      "source": [
        "from sklearn.feature_selection import mutual_info_classif\n",
        "mi = mutual_info_classif(X, y)\n",
        "print(mi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.14335279 0.02131564 0.04796711 0.06307143]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FNDH00Zr9Izt",
        "colab_type": "text"
      },
      "source": [
        "From the values above, we can conclude that the attribute `Sex` is to be selected as the root of the tree."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ml5Ksc5nZfTp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 207
        },
        "outputId": "ee90190e-afb2-4cec-aeb1-b73fb5339810"
      },
      "source": [
        "X.info()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 891 entries, 0 to 890\n",
            "Data columns (total 4 columns):\n",
            " #   Column  Non-Null Count  Dtype  \n",
            "---  ------  --------------  -----  \n",
            " 0   Sex     891 non-null    int64  \n",
            " 1   Age     891 non-null    float64\n",
            " 2   SibSp   891 non-null    int64  \n",
            " 3   Pclass  891 non-null    int64  \n",
            "dtypes: float64(1), int64(3)\n",
            "memory usage: 28.0 KB\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DpPS1xYY-JgT",
        "colab_type": "text"
      },
      "source": [
        "### Gini Impurity (aka Gini Index)\n",
        "\n",
        "Consider a set of examples $S$, and a target attribute $T$ attribute with $n$ possible values. Also, consider that $p_j$ is the probability of the $j$-th value of $T$ ($1 \\leq j \\leq n$). The Gini Impurity for $T$ considering the examples in $S$ is defined as the following.\n",
        "\n",
        "$$\n",
        "I_G(T \\mid S) = 1 - \\sum_{j}^n p_j^2\n",
        "$$\n",
        "\n",
        "Then, we can compute the Gini index considering all the splits generated by the values of $A$:\n",
        "\n",
        "$$\n",
        "G(T \\mid A) = \\sum_{v_i \\in A} \\frac{|S_i|}{|S|} I_G(T \\mid S_i)\n",
        "$$\n",
        "\n",
        "During the process of learning a decision tree, according to the Gini criterion, we should select the predictive attribute with the least value for $G(T \\mid A)$ among the available attributes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zpHr3cd_zDR8",
        "colab_type": "text"
      },
      "source": [
        "As an example, consider again the dataset PlayGolf.\n",
        "\n",
        "![alt text](https://miro.medium.com/max/446/0*N01l6jqQtVXvsEyk.png)\n",
        "\n",
        "Let us compute $I_G$ for each split generated by the values of the attribute Outlook:\n",
        "\n",
        "$$\n",
        "\\begin{aligned}\n",
        "I_G(\\text{PlayGolf} \\mid \\text{Outlook} = \\text{'Sunny'}) &= 1 - \\left[ (3/5)^2 + (2/5)^2 \\right] = 0.48 \\\\\n",
        "I_G(\\text{PlayGolf} \\mid \\text{Outlook} = \\text{'Overcast'}) &= 1 - \\left[ (4/4)^2 + (0/4)^2 \\right] = 0 \\\\\n",
        "I_G(\\text{PlayGolf} \\mid \\text{Outlook} = \\text{'Rainy'}) &= 1 - \\left[ (2/5)^2 + (3/5)^2 \\right] = 0.48\n",
        "\\end{aligned}\n",
        "$$\n",
        "\n",
        "Now, we can compute $G(\\text{PlayGolf} \\mid \\text{Outlook})$:\n",
        "\n",
        "$$\n",
        "G(\\text{PlayGolf} \\mid \\text{Outlook}) = (5/14) \\times 0.48 + (4/14) \\times 0 + (5/14) \\times 0.48 \\approx 0.342\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9808yRmX3SJr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def gini_split(dict_split):\n",
        "  \"\"\"Compute impurity for given split\n",
        "\n",
        "  dict_split is a dictionary in which the i-th entry is a\n",
        "   tuple with the following structure: (s_i, g_i)\n",
        "      s_i -- the size of S_i subset\n",
        "      g_i -- I_G(S_i)\n",
        "  \"\"\"\n",
        "\n",
        "  total_sz = 0\n",
        "  for k, v in dict_split.items():\n",
        "    print(k,v)\n",
        "    total_sz = total_sz + v[0]\n",
        "  \n",
        "  s = 0\n",
        "  for k, v in dict_split.items():\n",
        "    s = s + (v[0]/total_sz) * v[1]\n",
        "\n",
        "  return s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9wxPxXeK3TbA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 86
        },
        "outputId": "b0d68497-5439-43fc-8e14-7ae43552ecbd"
      },
      "source": [
        "split = dict()\n",
        "split[1] = (5, 0.48)\n",
        "split[2] = (4, 0)\n",
        "split[3] = (5, 0.48)\n",
        "gini_split(split)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 (5, 0.48)\n",
            "2 (4, 0)\n",
            "3 (5, 0.48)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.34285714285714286"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ygYgTp5u469-",
        "colab_type": "text"
      },
      "source": [
        "The following example graphically illustrates the difference between entropy and the gini index. It can be noted that there are no major differences between these two measures.\n",
        "\n",
        "Credits: the following example is adapted from https://github.com/rasbt/python-machine-learning-book-2nd-edition/blob/master/code/ch03/ch03.ipynb "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "slmBjSoFzW1I",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 307
        },
        "outputId": "103c460e-ea44-4a70-fdee-62d555ba90b0"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "def gini(p):\n",
        "    return p * (1 - p) + (1 - p) * (1 - (1 - p))\n",
        "\n",
        "\n",
        "def entropy(p):\n",
        "    return - p * np.log2(p) - (1 - p) * np.log2((1 - p))\n",
        "\n",
        "\n",
        "x = np.arange(0.0, 1.0, 0.01)\n",
        "\n",
        "ent = [entropy(p) if p != 0 else None for p in x]\n",
        "\n",
        "fig = plt.figure()\n",
        "ax = plt.subplot(111)\n",
        "for i, lab, ls, c, in zip([ent, gini(x)], \n",
        "                          ['Entropy', 'Gini Impurity'],\n",
        "                          ['-', '-', '--', '-.'],\n",
        "                          ['red', 'blue', 'black', 'green', 'cyan']):\n",
        "    line = ax.plot(x, i, label=lab, linestyle=ls, lw=2, color=c)\n",
        "\n",
        "ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.15),\n",
        "          ncol=5, fancybox=True, shadow=False)\n",
        "\n",
        "ax.axhline(y=0.5, linewidth=1, color='k', linestyle='--')\n",
        "ax.axhline(y=1.0, linewidth=1, color='k', linestyle='--')\n",
        "plt.ylim([0, 1.1])\n",
        "plt.xlabel('p(i=1)')\n",
        "plt.ylabel('Impurity Index')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yyoIWLTqkgQn",
        "colab_type": "text"
      },
      "source": [
        "## Decision Tree Classifier in Scikit-Learn \n",
        "\n",
        "In Scikit-Learn, the class [`DecisionTreeClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html) implements a customizable algorithm for learning decision trees. The following code example illustrates the use of this class. The example is given in the context of the Iris data set. Here, the third and fourth attributes represent the petal length and petal width of each flower. The classes have already been converted to integer labels, where 0 = Iris-Setosa, 1 = Iris-Versicolor, 2 = Iris-Virginica."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iIiqgKQVlR1Z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        },
        "outputId": "765af4fb-4597-4b5f-dc25-7ddce7945370"
      },
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn import datasets\n",
        "import numpy as np\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "\n",
        "iris = datasets.load_iris()\n",
        "\n",
        "# petal length and petal width\n",
        "X = iris.data[:, [2, 3]]\n",
        "\n",
        "# response vector\n",
        "y = iris.target\n",
        "\n",
        "print('Class labels:', np.unique(y))\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(\n",
        "    X, y, test_size=0.3, random_state=1, stratify=y)\n",
        "\n",
        "print('Labels counts in y:', np.bincount(y))\n",
        "print('Labels counts in y_train:', np.bincount(y_train))\n",
        "print('Labels counts in y_test:', np.bincount(y_test))\n",
        "\n",
        "tree = DecisionTreeClassifier(criterion='gini', #'entropy'\n",
        "                              max_depth=4, \n",
        "                              random_state=1)\n",
        "tree.fit(X_train, y_train)\n",
        "\n",
        "y_pred = tree.predict(X_test)\n",
        "\n",
        "print('Accuracy on test set: %.2f' % accuracy_score(y_test, y_pred))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Class labels: [0 1 2]\n",
            "Labels counts in y: [50 50 50]\n",
            "Labels counts in y_train: [35 35 35]\n",
            "Labels counts in y_test: [15 15 15]\n",
            "Accuracy on test set: 0.98\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ph23zFQS7nXi",
        "colab_type": "text"
      },
      "source": [
        "We can also visualize the decisions boundary of this model. See below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JrC6KIU86dhX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 335
        },
        "outputId": "b13ee63a-7e0a-47f7-b8f3-8b787fe13f8d"
      },
      "source": [
        "from matplotlib.colors import ListedColormap\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def plot_decision_regions(X, y, classifier, test_idx=None, resolution=0.02):\n",
        "\n",
        "    # setup marker generator and color map\n",
        "    markers = ('s', 'x', 'o', '^', 'v')\n",
        "    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')\n",
        "    cmap = ListedColormap(colors[:len(np.unique(y))])\n",
        "\n",
        "    # plot the decision surface\n",
        "    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n",
        "    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n",
        "    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),\n",
        "                           np.arange(x2_min, x2_max, resolution))\n",
        "    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)\n",
        "    Z = Z.reshape(xx1.shape)\n",
        "    plt.contourf(xx1, xx2, Z, alpha=0.3, cmap=cmap)\n",
        "    plt.xlim(xx1.min(), xx1.max())\n",
        "    plt.ylim(xx2.min(), xx2.max())\n",
        "\n",
        "    for idx, cl in enumerate(np.unique(y)):\n",
        "        plt.scatter(x=X[y == cl, 0], \n",
        "                    y=X[y == cl, 1],\n",
        "                    alpha=0.8, \n",
        "                    c=colors[idx],\n",
        "                    marker=markers[idx], \n",
        "                    label=cl, \n",
        "                    edgecolor='black')\n",
        "\n",
        "    # highlight test samples\n",
        "    if test_idx:\n",
        "        # plot all samples\n",
        "        X_test, y_test = X[test_idx, :], y[test_idx]\n",
        "\n",
        "        plt.scatter(X_test[:, 0],\n",
        "                    X_test[:, 1],\n",
        "                    c='',\n",
        "                    edgecolor='black',\n",
        "                    alpha=1.0,\n",
        "                    linewidth=1,\n",
        "                    marker='o',\n",
        "                    s=100, \n",
        "                    label='test set')\n",
        "\n",
        "X_combined = np.vstack((X_train, X_test))\n",
        "y_combined = np.hstack((y_train, y_test))\n",
        "plot_decision_regions(X_combined, y_combined, \n",
        "                      classifier=tree, test_idx=range(105, 150))\n",
        "\n",
        "plt.xlabel('petal length [cm]')\n",
        "plt.ylabel('petal width [cm]')\n",
        "plt.legend(loc='upper left')\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:44: MatplotlibDeprecationWarning: Using a string of single character colors as a color sequence is deprecated. Use an explicit list instead.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nSUSO2nwl4lD",
        "colab_type": "text"
      },
      "source": [
        "For curiosity's sake, notice that it is possible to export the image above to a file. See below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J2sZpYsglzdG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from pydotplus import graph_from_dot_data\n",
        "from sklearn.tree import export_graphviz\n",
        "\n",
        "dot_data = export_graphviz(tree,\n",
        "                           filled=True, \n",
        "                           rounded=True,\n",
        "                           class_names=['Setosa', \n",
        "                                        'Versicolor',\n",
        "                                        'Virginica'],\n",
        "                           feature_names=['petal length', \n",
        "                                          'petal width'],\n",
        "                           out_file=None) \n",
        "graph = graph_from_dot_data(dot_data) \n",
        "graph.write_png('tree.png')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eg4ZJvfLGqYt",
        "colab_type": "text"
      },
      "source": [
        "# Decision trees for regression\n",
        "\n",
        "Decision trees can also be used in a regression task. However, in this case, an impurity metric suitable for continuous variables (instead of Gini index and information gain) should be used. Also, the value predicted by a leaf node in a regression tree is the average of the target values for the examples inside that leaf.\n",
        "\n",
        "One possible metric is the mean squared error (MSE). In particular, to quantify the level of impurity $I(t)$ in a node $t$ of the decision tree being built, we can apply the following expression:\n",
        "\n",
        "$$\n",
        "I(t) = \\operatorname{MSE}(t) = \\frac{1}{m_t}  \\sum_{i \\in D_t} (y^{(i)} - \\overline{y}_t)^2\n",
        "$$\n",
        "\n",
        "$$\n",
        "\\overline{y}_t = \\frac{1}{m_t} \\sum_{i \\in D_t} y^{(i)}\n",
        "$$\n",
        "\n",
        "In the expressions above:\n",
        "\n",
        "* $D_t$ is the training subset at node $t$.\n",
        "\n",
        "* $m_t$ is the size of $D_t$ (i.e., the number of training examples at node $t$).\n",
        "\n",
        "* $y^{(i)}$ is the true value of the target feature for the $i$-th training example in $D_t$.\n",
        "\n",
        "* $\\overline{y}_t$ is the average of the predicted values for examples  in $D_t$.\n",
        "\n",
        "Source: Python Machine Learning, 2nd ed., pp 341"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v-a6GGMunZmT",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ELCAB3Egnr1H",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "662aea32-2684-443d-d01e-a7f24977ecb0"
      },
      "source": [
        "import numpy as np\n",
        "expl = np.array([2.5, 2.5, 2.5, 2.5])\n",
        "print(expl.mean())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4.25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bI5-8JcB4jkF",
        "colab_type": "text"
      },
      "source": [
        "The following example illustrates the use of the class [DecisionTreeRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html), present in Scikit-Learn to induce decision tree models for regression."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vQ9q4uCO4WQS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "d241b016-0a2d-40f6-db08-cc1ed9eec4fc"
      },
      "source": [
        "from sklearn.tree import DecisionTreeRegressor\n",
        "from sklearn import datasets\n",
        "\n",
        "# Load data with only two features\n",
        "boston = datasets.load_boston()\n",
        "X = boston.data[:,0:2]\n",
        "y = boston.target\n",
        "\n",
        "# Create decision tree classifer object\n",
        "regr = DecisionTreeRegressor(random_state=0)\n",
        "\n",
        "# Train model\n",
        "model = regr.fit(X, y)\n",
        "\n",
        "# Make new observation\n",
        "observation = [[0.02, 16]]\n",
        "              \n",
        "# Predict observation's value  \n",
        "print(model.predict(observation))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[33.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJVhHUTL5NHG",
        "colab_type": "text"
      },
      "source": [
        "The following code ([source](https://scikit-learn.org/stable/auto_examples/tree/plot_tree_regression.html#sphx-glr-auto-examples-tree-plot-tree-regression-py)) provides another example of using the class `DecisionTreeRegressor`. Notice that, if the maximum depth of the tree (controlled by the parameter `max_depth`) is set too high, the decision trees learns very fine details from the training data and learns from the noise, that is, they overfit."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5UO1wNgx5QEp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "6ff3a12f-6116-48a7-fa1b-af58411fef82"
      },
      "source": [
        "# Import the necessary modules and libraries\n",
        "import numpy as np\n",
        "from sklearn.tree import DecisionTreeRegressor\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# 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))\n",
        "\n",
        "# Fit two regression models\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)\n",
        "\n",
        "# Plot the results\n",
        "plt.figure()\n",
        "plt.scatter(X, y, s=20, edgecolor=\"black\",\n",
        "            c=\"darkorange\", label=\"data\")\n",
        "plt.plot(X_test, y_1, color=\"cornflowerblue\",\n",
        "         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()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-TfecgGzmBqu",
        "colab_type": "text"
      },
      "source": [
        "# Final Remarks\n",
        "\n",
        "Some advantages of decision tree models are:\n",
        "\n",
        "* They are simple to understand and interpret. Trees can be viewed.\n",
        "\n",
        "* They require little data preparation. Other techniques usually require data normalization, dummy variables need to be created.\n",
        "\n",
        "* The cost of using the tree (ie, predicting data) is logarithmic in the number of data points used to train the tree.\n",
        "\n",
        "* They are able to handle numerical and categorical data. Other learning techniques are generally specialized in the analysis of data sets that have only one type of variable. \n"
      ]
    }
  ]
}